docs: add missing feature docs and rearrange sidebar for progressive learning

website/docs/introduce.md

@@ -48,66 +48,20 @@ project's origin, background and vision.
   amounts of data at once. This design is especially important when dealing with hundreds of thousands or even millions
   of rows of data.
 
-## Example
+## Quick Example
 
 ### Read
 
-Below is an example of reading a spreadsheet document:
-
 ```java
-// Implement the ReadListener interface to set up operations for reading data
-public class DemoDataListener implements ReadListener<DemoData> {
-    @Override
-    public void invoke(DemoData data, AnalysisContext context) {
-        System.out.println("Parsed a data entry" + JSON.toJSONString(data));
-    }
-
-    @Override
-    public void doAfterAllAnalysed(AnalysisContext context) {
-        System.out.println("All data parsed!");
-    }
-}
-
-public static void main(String[] args) {
-    String fileName = "demo.xlsx";
-    // Read file
-    FesodSheet.read(fileName, DemoData.class, new DemoDataListener()).sheet().doRead();
-}
+FesodSheet.read("demo.xlsx", DemoData.class, new DemoDataListener()).sheet().doRead();
 ```
 
 ### Write
 
-Below is a simple example of creating a spreadsheet document:
-
 ```java
-// Sample data class
-public class DemoData {
-    @ExcelProperty("String Title")
-    private String string;
-    @ExcelProperty("Date Title")
-    private Date date;
-    @ExcelProperty("Number Title")
-    private Double doubleData;
-    @ExcelIgnore
-    private String ignore;
-}
-
-// Prepare data to write
-private static List<DemoData> data() {
-    List<DemoData> list = new ArrayList<>();
-    for (int i = 0; i < 10; i++) {
-        DemoData data = new DemoData();
-        data.setString("String" + i);
-        data.setDate(new Date());
-        data.setDoubleData(0.56);
-        list.add(data);
-    }
-    return list;
-}
-
-public static void main(String[] args) {
-    String fileName = "demo.xlsx";
-    // Create a "Template" sheet and write data
-    FesodSheet.write(fileName, DemoData.class).sheet("Template").doWrite(data());
-}
+FesodSheet.write("demo.xlsx", DemoData.class).sheet("Template").doWrite(data());
 ```
+
+:::tip
+For complete examples with POJO definitions, listeners, and data preparation, see the [Quick Start](/docs/quickstart/simple-example) guide.
+:::

website/docs/sheet/advanced/custom-converter.md

@@ -0,0 +1,104 @@
+---
+id: 'custom-converter'
+title: 'Custom Converter'
+---
+
+<!--
+- Licensed to the Apache Software Foundation (ASF) under one or more
+- contributor license agreements.  See the NOTICE file distributed with
+- this work for additional information regarding copyright ownership.
+- The ASF licenses this file to You under the Apache License, Version 2.0
+- (the "License"); you may not use this file except in compliance with
+- the License.  You may obtain a copy of the License at
+-
+-   http://www.apache.org/licenses/LICENSE-2.0
+-
+- Unless required by applicable law or agreed to in writing, software
+- distributed under the License is distributed on an "AS IS" BASIS,
+- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+- See the License for the specific language governing permissions and
+- limitations under the License.
+-->
+
+# Custom Converter
+
+This chapter introduces how to create and register custom converters for both read and write operations.
+
+## Overview
+
+Fesod provides a `Converter` interface that allows you to define custom data transformation logic. Converters can be registered per-field (via annotation) or globally (via builder), and work for both reading and writing.
+
+## Creating a Custom Converter
+
+### Converter Implementation
+
+```java
+public class CustomStringStringConverter implements Converter<String> {
+    @Override
+    public Class<?> supportJavaTypeKey() {
+        return String.class;
+    }
+
+    @Override
+    public CellDataTypeEnum supportExcelTypeKey() {
+        return CellDataTypeEnum.STRING;
+    }
+
+    @Override
+    public String convertToJavaData(ReadConverterContext<?> context) {
+        return "Custom: " + context.getReadCellData().getStringValue();
+    }
+
+    @Override
+    public WriteCellData<?> convertToExcelData(WriteConverterContext<String> context) {
+        return new WriteCellData<>("Custom: " + context.getValue());
+    }
+}
+```
+
+---
+
+## Per-Field vs. Global Registration
+
+| Approach | Scope | How |
+|:---|:---|:---|
+| Per-field | Single field only | `@ExcelProperty(converter = MyConverter.class)` |
+| Global | All fields matching Java type + Excel type | `.registerConverter(new MyConverter())` on the builder |
+
+### Converter Resolution Priority
+
+1. Field-level converter (`@ExcelProperty(converter = ...)`) — highest priority
+2. Builder-level converter (`.registerConverter(...)`)
+3. Built-in default converter — lowest priority
+
+---
+
+## Global Registration Example
+
+### Write with Global Converter
+
+```java
+@Test
+public void customConverterWrite() {
+    String fileName = "customConverterWrite" + System.currentTimeMillis() + ".xlsx";
+
+    FesodSheet.write(fileName, DemoData.class)
+        .registerConverter(new CustomStringStringConverter())
+        .sheet()
+        .doWrite(data());
+}
+```
+
+### Read with Global Converter
+
+```java
+@Test
+public void customConverterRead() {
+    String fileName = "path/to/demo.xlsx";
+
+    FesodSheet.read(fileName, DemoData.class, new DemoDataListener())
+        .registerConverter(new CustomStringStringConverter())
+        .sheet()
+        .doRead();
+}
+```

website/docs/sheet/advanced/large-file.md

@@ -0,0 +1,82 @@
+---
+id: 'large-file'
+title: 'Large File Writing'
+---
+
+<!--
+- Licensed to the Apache Software Foundation (ASF) under one or more
+- contributor license agreements.  See the NOTICE file distributed with
+- this work for additional information regarding copyright ownership.
+- The ASF licenses this file to You under the Apache License, Version 2.0
+- (the "License"); you may not use this file except in compliance with
+- the License.  You may obtain a copy of the License at
+-
+-   http://www.apache.org/licenses/LICENSE-2.0
+-
+- Unless required by applicable law or agreed to in writing, software
+- distributed under the License is distributed on an "AS IS" BASIS,
+- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+- See the License for the specific language governing permissions and
+- limitations under the License.
+-->
+
+# Large File Writing
+
+This chapter introduces how to write very large Excel files (100,000+ rows) with memory optimization.
+
+## Overview
+
+When exporting large datasets (e.g., database dumps, log analysis), loading all rows at once would exhaust memory. Fesod uses Apache POI's streaming API (SXSSF) internally, but temporary XML files can consume significant disk space. Enabling compression reduces disk usage at the cost of slightly more CPU.
+
+## Batch Writing with Compressed Temp Files
+
+### Code Example
+
+```java
+@Test
+public void largeFileWrite() {
+    String fileName = "largeFile" + System.currentTimeMillis() + ".xlsx";
+
+    try (ExcelWriter excelWriter = FesodSheet.write(fileName, DemoData.class)
+            .registerWriteHandler(new WorkbookWriteHandler() {
+                @Override
+                public void afterWorkbookCreate(WorkbookWriteHandlerContext context) {
+                    Workbook workbook = context.getWriteWorkbookHolder().getWorkbook();
+                    if (workbook instanceof SXSSFWorkbook) {
+                        ((SXSSFWorkbook) workbook).setCompressTempFiles(true);
+                    }
+                }
+            })
+            .build()) {
+        WriteSheet writeSheet = FesodSheet.writerSheet("Template").build();
+        // Write data in batches — each data() call returns one batch
+        for (int i = 0; i < 1000; i++) {
+            excelWriter.write(data(), writeSheet);
+        }
+    }
+}
+```
+
+---
+
+## Architecture
+
+```text
+Data (in memory, batched)        Fesod          POI/SXSSF
+    │                              │                 │
+    ├─ 100 rows batch ───────────▶ write() ──────▶ temp XML (compressed)
+    ├─ 100 rows batch ───────────▶ write() ──────▶ temp XML (append)
+    │  ... (1000 batches)           │                 │
+    └─ close() ──────────────────▶ finalize ─────▶ final .xlsx
+```
+
+## Performance Tips
+
+- Use `ExcelWriter` (try-with-resources) for batch writing instead of loading all data with `doWrite()`.
+- Enable temp file compression for disk-constrained environments.
+- Tune batch size (100 rows here) based on your row width and available memory.
+- Monitor temp directory size: `FileUtils.getPoiFilesPath()`.
+
+:::tip
+For large file **reading** optimization, see the [Large Data](/docs/sheet/help/large-data) section in the Help guide.
+:::

website/docs/sheet/advanced/password.md

@@ -0,0 +1,72 @@
+---
+id: 'password'
+title: 'Password Protection'
+---
+
+<!--
+- Licensed to the Apache Software Foundation (ASF) under one or more
+- contributor license agreements.  See the NOTICE file distributed with
+- this work for additional information regarding copyright ownership.
+- The ASF licenses this file to You under the Apache License, Version 2.0
+- (the "License"); you may not use this file except in compliance with
+- the License.  You may obtain a copy of the License at
+-
+-   http://www.apache.org/licenses/LICENSE-2.0
+-
+- Unless required by applicable law or agreed to in writing, software
+- distributed under the License is distributed on an "AS IS" BASIS,
+- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+- See the License for the specific language governing permissions and
+- limitations under the License.
+-->
+
+# Password Protection
+
+This chapter introduces how to read and write password-protected Excel files.
+
+## Overview
+
+Fesod supports Excel's built-in password protection for both reading and writing. Use `.password("xxx")` on the builder to encrypt/decrypt files. For `.xlsx` output, Fesod uses Apache POI's encryption (AES-based) which can be memory-intensive for large workbooks. For legacy `.xls` files, password protection behaves as write-protection rather than full content encryption, so behavior and security guarantees differ from `.xlsx`.
+
+## Writing with Password
+
+### Code Example
+
+```java
+@Test
+public void passwordWrite() {
+    String fileName = "passwordWrite" + System.currentTimeMillis() + ".xlsx";
+
+    FesodSheet.write(fileName)
+        .password("your_password")
+        .head(DemoData.class)
+        .sheet("PasswordSheet")
+        .doWrite(data());
+}
+```
+
+---
+
+## Reading with Password
+
+### Code Example
+
+```java
+@Test
+public void passwordRead() {
+    String fileName = "path/to/encrypted.xlsx";
+
+    FesodSheet.read(fileName, DemoData.class, new DemoDataListener())
+        .password("your_password")
+        .sheet()
+        .doRead();
+}
+```
+
+---
+
+## Security Notes
+
+- Excel password protection encrypts the file content, making it unreadable without the password.
+- Without the correct password, reading will throw an `EncryptedDocumentException`.
+- In production, avoid hardcoding passwords — use configuration files or secrets management.