@visactor/vtable-plugins 1.22.8-alpha.13 → 1.22.8

package/dist/vtable-plugins.js

@@ -8622,12 +8622,304 @@
     	 * @copyright Louis-Dominique Dubeau
     	 */function n(e){return e>=65&&e<=90||95===e||e>=97&&e<=122||e>=192&&e<=214||e>=216&&e<=246||e>=248&&e<=767||e>=880&&e<=893||e>=895&&e<=8191||e>=8204&&e<=8205||e>=8304&&e<=8591||e>=11264&&e<=12271||e>=12289&&e<=55295||e>=63744&&e<=64975||e>=65008&&e<=65533||e>=65536&&e<=983039;}Object.defineProperty(r,"__esModule",{value:!0}),r.NC_NAME_START_CHAR="A-Z_a-z\xc0-\xd6\xd8-\xf6\xf8-\u02ff\u0370-\u037d\u037f-\u1fff\u200c-\u200d\u2070-\u218f\u2c00-\u2fef\u3001-\ud7ff\uf900-\ufdcf\ufdf0-\ufffd\ud800\udc00-\udb7f\udfff",r.NC_NAME_CHAR="-"+r.NC_NAME_START_CHAR+".0-9\xb7\u0300-\u036f\u203f-\u2040",r.NC_NAME_START_CHAR_RE=new RegExp("^["+r.NC_NAME_START_CHAR+"]$","u"),r.NC_NAME_CHAR_RE=new RegExp("^["+r.NC_NAME_CHAR+"]$","u"),r.NC_NAME_RE=new RegExp("^["+r.NC_NAME_START_CHAR+"]["+r.NC_NAME_CHAR+"]*$","u"),r.isNCNameStartChar=n,r.isNCNameChar=function(e){return n(e)||45===e||46===e||e>=48&&e<=57||183===e||e>=768&&e<=879||e>=8255&&e<=8256;};},{}]},{},[15])(15);});})(exceljs_min);var exceljs_minExports=exceljs_min.exports;var ExcelJS = /*@__PURE__*/getDefaultExportFromCjs(exceljs_minExports);
 
+    async function importCsvFile(file, options) {
+        const text = await file.text();
+        const delimiter = options?.delimiter || ',';
+        const lines = text.split(/\r?\n/).filter(line => line.trim().length > 0);
+        if (lines.length === 0) {
+            throw new Error('CSV 文件为空');
+        }
+        const data = [];
+        for (const line of lines) {
+            const row = parseCsvLine(line, delimiter);
+            data.push(row);
+        }
+        const rowCount = data.length;
+        const columnCount = Math.max(...data.map(row => row.length), 0);
+        const sheetTitle = file.name.replace(/\.(csv|txt)$/i, '') || 'Sheet1';
+        const sheetKey = `sheet_${Date.now()}_0`;
+        const sheetData = {
+            sheetTitle,
+            sheetKey,
+            data,
+            columnCount,
+            rowCount
+        };
+        return {
+            sheets: [sheetData]
+        };
+    }
+    function parseCsvLine(line, delimiter) {
+        const result = [];
+        let current = '';
+        let inQuotes = false;
+        for (let i = 0; i < line.length; i++) {
+            const char = line[i];
+            const nextChar = line[i + 1];
+            if (char === '"') {
+                if (inQuotes && nextChar === '"') {
+                    current += '"';
+                    i++;
+                }
+                else {
+                    inQuotes = !inQuotes;
+                }
+            }
+            else if (char === delimiter && !inQuotes) {
+                result.push(current.trim());
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        result.push(current.trim());
+        return result;
+    }
+    async function importExcelMultipleSheets(file, options) {
+        const workbook = new ExcelJS.Workbook();
+        await workbook.xlsx.load(await file.arrayBuffer());
+        if (!workbook.worksheets || workbook.worksheets.length === 0) {
+            throw new Error('Excel 文件无有效工作表');
+        }
+        let sheetIndices;
+        if (options?.sheetIndices && options.sheetIndices.length > 0) {
+            sheetIndices = options.sheetIndices.filter(index => index >= 0 && index < workbook.worksheets.length);
+        }
+        else {
+            sheetIndices = Array.from({ length: workbook.worksheets.length }, (_, i) => i);
+        }
+        const sheets = [];
+        for (const sheetIndex of sheetIndices) {
+            const worksheet = workbook.worksheets[sheetIndex];
+            if (!worksheet) {
+                continue;
+            }
+            try {
+                const sheetData = await parseWorksheetToSheetData(worksheet, sheetIndex, options);
+                sheets.push(sheetData);
+            }
+            catch (error) {
+            }
+        }
+        if (sheets.length === 0) {
+            throw new Error('没有成功解析任何工作表');
+        }
+        return { sheets };
+    }
+    async function parseWorksheetToSheetData(worksheet, sheetIndex, options) {
+        const sheetTitle = worksheet.name || `Sheet${sheetIndex + 1}`;
+        const sheetKey = `sheet_${Date.now()}_${sheetIndex}`;
+        const rowCount = worksheet.actualRowCount || 0;
+        const columnCount = worksheet.actualColumnCount || 0;
+        if (rowCount === 0 || columnCount === 0) {
+            const cellMerge = parseMergedCells(worksheet, []);
+            return {
+                sheetTitle,
+                sheetKey,
+                data: [],
+                columnCount: 0,
+                rowCount: 0,
+                ...(cellMerge.length > 0 ? { cellMerge } : {})
+            };
+        }
+        const data = [];
+        for (let rowNumber = 1; rowNumber <= rowCount; rowNumber++) {
+            const row = worksheet.getRow(rowNumber);
+            const rowData = [];
+            for (let colNumber = 1; colNumber <= columnCount; colNumber++) {
+                const cell = row.getCell(colNumber);
+                let cellValue = cell.value;
+                if (cellValue && typeof cellValue === 'object') {
+                    if ('richText' in cellValue) {
+                        cellValue = cellValue.richText
+                            .map((rt) => rt.text)
+                            .join('');
+                    }
+                    else if ('result' in cellValue) {
+                        cellValue = cellValue.result;
+                    }
+                    else if ('text' in cellValue && 'hyperlink' in cellValue) {
+                        cellValue = cellValue.text;
+                    }
+                    else if (cellValue instanceof Date) {
+                        cellValue = cellValue.toISOString();
+                    }
+                }
+                rowData.push(cellValue ?? null);
+            }
+            data.push(rowData);
+        }
+        const cellMerge = parseMergedCells(worksheet, data);
+        return {
+            sheetTitle,
+            sheetKey,
+            data,
+            columnCount,
+            rowCount,
+            ...(cellMerge.length > 0 ? { cellMerge } : {})
+        };
+    }
+    function parseMergedCells(worksheet, data) {
+        const cellMerge = [];
+        try {
+            const worksheetAny = worksheet;
+            const merges = worksheetAny.model?.merges ||
+                worksheetAny._merges ||
+                {};
+            for (const [masterCell, range] of Object.entries(merges)) {
+                try {
+                    let startCol;
+                    let startRow;
+                    let endCol;
+                    let endRow;
+                    if (typeof range === 'string') {
+                        const rangeMatch = range.match(/^([A-Z]+\d+):([A-Z]+\d+)$/i);
+                        if (!rangeMatch) {
+                            continue;
+                        }
+                        const startAddr = parseCellAddress(rangeMatch[1]);
+                        const endAddr = parseCellAddress(rangeMatch[2]);
+                        if (!startAddr || !endAddr) {
+                            continue;
+                        }
+                        startCol = startAddr.col;
+                        startRow = startAddr.row;
+                        endCol = endAddr.col;
+                        endRow = endAddr.row;
+                    }
+                    else if (typeof range === 'object' && range !== null) {
+                        const rangeObj = range;
+                        if (rangeObj.tl && rangeObj.br) {
+                            const startAddr = parseCellAddress(rangeObj.tl);
+                            const endAddr = parseCellAddress(rangeObj.br);
+                            if (!startAddr || !endAddr) {
+                                continue;
+                            }
+                            startCol = startAddr.col;
+                            startRow = startAddr.row;
+                            endCol = endAddr.col;
+                            endRow = endAddr.row;
+                        }
+                        else if (typeof rangeObj.top === 'number' &&
+                            typeof rangeObj.left === 'number' &&
+                            typeof rangeObj.bottom === 'number' &&
+                            typeof rangeObj.right === 'number') {
+                            startRow = rangeObj.top - 1;
+                            startCol = rangeObj.left - 1;
+                            endRow = rangeObj.bottom - 1;
+                            endCol = rangeObj.right - 1;
+                        }
+                        else {
+                            continue;
+                        }
+                    }
+                    else {
+                        continue;
+                    }
+                    let text;
+                    if (startRow >= 0 && startRow < data.length && startCol >= 0 && startCol < data[startRow].length) {
+                        const cellValue = data[startRow][startCol];
+                        if (cellValue !== null && cellValue !== undefined) {
+                            text = String(cellValue);
+                        }
+                    }
+                    cellMerge.push({
+                        text,
+                        range: {
+                            start: {
+                                col: startCol,
+                                row: startRow
+                            },
+                            end: {
+                                col: endCol,
+                                row: endRow
+                            },
+                            isCustom: true
+                        }
+                    });
+                }
+                catch (error) {
+                }
+            }
+        }
+        catch (error) {
+        }
+        return cellMerge;
+    }
+    function parseCellAddress(address) {
+        try {
+            const match = address.match(/^([A-Z]+)(\d+)$/i);
+            if (!match) {
+                return null;
+            }
+            const colLetters = match[1].toUpperCase();
+            const rowNumber = parseInt(match[2], 10);
+            let col = 0;
+            for (let i = 0; i < colLetters.length; i++) {
+                col = col * 26 + (colLetters.charCodeAt(i) - 64);
+            }
+            col = col - 1;
+            const row = rowNumber - 1;
+            return { col, row };
+        }
+        catch (error) {
+            return null;
+        }
+    }
+
+    function applyImportToVTableSheet(vtableSheetInstance, result, options) {
+        const clearExisting = options?.clearExisting !== false;
+        if (result.sheets.length === 0) {
+            return;
+        }
+        if (typeof vtableSheetInstance.addSheet !== 'function') {
+            throw new Error('VTableSheet 实例方法不完整');
+        }
+        const existingSheets = clearExisting ? [...vtableSheetInstance.getAllSheets()] : [];
+        const existingSheetKeys = existingSheets.map((s) => s.sheetKey);
+        const importedSheetKeys = [];
+        for (let i = 0; i < result.sheets.length; i++) {
+            const sheetData = result.sheets[i];
+            let sheetKey = sheetData.sheetKey;
+            let suffix = 1;
+            while (vtableSheetInstance.getSheet(sheetKey) || importedSheetKeys.includes(sheetKey)) {
+                sheetKey = `${sheetData.sheetKey}_${suffix}`;
+                suffix++;
+            }
+            const sheetDefine = {
+                sheetKey: sheetKey,
+                sheetTitle: sheetData.sheetTitle,
+                data: sheetData.data,
+                rowCount: Math.max(sheetData.rowCount, 100),
+                columnCount: Math.max(sheetData.columnCount, 26),
+                cellMerge: sheetData.cellMerge,
+                active: false
+            };
+            vtableSheetInstance.addSheet(sheetDefine);
+            importedSheetKeys.push(sheetKey);
+        }
+        if (clearExisting && existingSheetKeys.length > 0) {
+            for (const oldSheetKey of existingSheetKeys) {
+                if (importedSheetKeys.includes(oldSheetKey)) {
+                    continue;
+                }
+                if (vtableSheetInstance.getSheet(oldSheetKey) && vtableSheetInstance.getSheetCount() > 1) {
+                    vtableSheetInstance.removeSheet(oldSheetKey);
+                }
+            }
+        }
+        if (importedSheetKeys.length > 0) {
+            vtableSheetInstance.activateSheet(importedSheetKeys[0]);
+        }
+    }
+
     class ExcelImportPlugin {
         id = `excel-import-plugin`;
         name = 'ExcelImportPlugin';
         runTime = [VTable.TABLE_EVENT_TYPE.INITIALIZED];
         options;
-        _tableInstance = null;
+        table = null;
         constructor(options) {
             this.options = {
                 autoTable: true,
@@ -8637,6 +8929,8 @@
                 batchSize: 1000,
                 enableBatchProcessing: true,
                 asyncDelay: 5,
+                importAllSheets: false,
+                clearExisting: true,
                 ...options
             };
             if (options?.id) {
@@ -8644,64 +8938,55 @@
             }
         }
         run(...args) {
-            const tableInstance = args[2];
-            this._tableInstance = tableInstance;
-            this._tableInstance.importFile = () => {
-                this.import('file');
-            };
-        }
-        release() {
-            this._tableInstance = null;
-        }
-        async importFile() {
-            return this.import('file');
-        }
-        async import(type, source, options) {
-            const mergedOptions = { ...this.options, ...options };
-            if (type === 'file') {
-                return this._importFromFileDialog(mergedOptions);
+            const runTime = args[1];
+            if (runTime === VTable.TABLE_EVENT_TYPE.INITIALIZED) {
+                this.table = args[2];
+                this.table.importFile = () => {
+                    this.import('file');
+                };
+                if (this.table.__vtableSheet) {
+                    const vtableSheet = this.table.__vtableSheet;
+                    if (!vtableSheet._importFile) {
+                        vtableSheet._importFile = async (options) => {
+                            const mergedOptions = { ...this.options, ...options };
+                            return this._importFileFromDialogForVTableSheet(vtableSheet, mergedOptions);
+                        };
+                    }
+                }
             }
-            if (typeof source === 'string') {
-                return this._importFromString(type, source, mergedOptions);
+        }
+        async _importFile(options) {
+            if (!this.table) {
+                throw new Error('表格实例不存在或已销毁，无法导入数据！');
             }
-            if (Array.isArray(source) || typeof source === 'object') {
-                if (type !== 'json') {
-                    throw new Error('只有JSON格式支持从对象导入');
-                }
-                return this._importFromData('json', source, mergedOptions);
+            const mergedOptions = { ...this.options, ...options };
+            const isVTableSheet = this._detectVTableSheet(this.table);
+            if (isVTableSheet) {
+                return this._importMultipleSheetsFromFileDialog({
+                    ...mergedOptions,
+                    importAllSheets: true
+                });
             }
-            throw new Error('Invalid import source');
+            throw new Error('ListTable 单 sheet 导入功能需要进一步重构');
         }
-        async _importFromFileDialog(options) {
+        _selectFile(accept = '.xlsx,.xls,.csv,.txt,.json,.html,.htm') {
             return new Promise((resolve, reject) => {
-                if (!this._tableInstance) {
-                    reject(new Error('表格实例不存在或已销毁，无法导入数据！'));
-                    return;
-                }
                 const input = document.createElement('input');
                 input.type = 'file';
+                input.accept = accept;
                 input.style.display = 'none';
                 document.body.appendChild(input);
-                input.addEventListener('change', async (e) => {
+                input.addEventListener('change', () => {
                     try {
-                        const file = e.target.files?.[0];
+                        const file = input.files?.[0];
                         if (!file) {
                             document.body.removeChild(input);
                             reject(new Error('未选择文件'));
                             return;
                         }
-                        const result = await this._parseFile(file, options);
-                        if (options.autoTable && this._tableInstance) {
-                            if (options.autoColumns) {
-                                this._tableInstance.updateOption(Object.assign({}, this._tableInstance.options, {
-                                    columns: result.columns
-                                }));
-                            }
-                            this._tableInstance.setRecords(result.records);
-                        }
                         input.value = '';
                         document.body.removeChild(input);
-                        resolve(result);
+                        resolve(file);
                     }
                     catch (error) {
                         document.body.removeChild(input);
@@ -8711,6 +8996,116 @@
                 input.click();
             });
         }
+        async _importFileFromDialogForVTableSheet(vtableSheetInstance, options) {
+            try {
+                const file = await this._selectFile('.xlsx,.xls,.csv,.txt');
+                const fileExtension = this._getFileExtension(file.name).toLowerCase();
+                let result;
+                if (fileExtension === 'csv' || fileExtension === 'txt') {
+                    result = await importCsvFile(file, options);
+                }
+                else if (fileExtension === 'xlsx' || fileExtension === 'xls') {
+                    result = await importExcelMultipleSheets(file, options);
+                }
+                else {
+                    throw new Error('不支持的文件类型，仅支持 Excel (.xlsx, .xls) 和 CSV (.csv, .txt)');
+                }
+                if (options.autoTable !== false && result.sheets.length > 0) {
+                    applyImportToVTableSheet(vtableSheetInstance, result, options);
+                }
+                return result;
+            }
+            catch (error) {
+                throw error;
+            }
+        }
+        async _importMultipleSheetsFromFileDialog(options) {
+            try {
+                const file = await this._selectFile('.xlsx,.xls,.csv,.txt');
+                const fileExtension = this._getFileExtension(file.name).toLowerCase();
+                let result;
+                if (fileExtension === 'csv' || fileExtension === 'txt') {
+                    result = await importCsvFile(file, options);
+                }
+                else if (fileExtension === 'xlsx' || fileExtension === 'xls') {
+                    result = await importExcelMultipleSheets(file, options);
+                }
+                else {
+                    throw new Error('不支持的文件类型，仅支持 Excel (.xlsx, .xls) 和 CSV (.csv, .txt)');
+                }
+                if (options.autoTable !== false && this.table && this._detectVTableSheet(this.table)) {
+                    const vtableSheet = this.table.__vtableSheet;
+                    if (vtableSheet) {
+                        applyImportToVTableSheet(vtableSheet, result, options);
+                    }
+                }
+                return result;
+            }
+            catch (error) {
+                throw error;
+            }
+        }
+        _detectVTableSheet(instance) {
+            const inst = instance;
+            return !!(inst &&
+                typeof inst.updateOption === 'function' &&
+                inst.options &&
+                typeof inst.options === 'object' &&
+                inst.options !== null &&
+                Array.isArray(inst.options.sheets));
+        }
+        _getFileExtension(filename) {
+            const parts = filename.split('.');
+            return parts.length > 1 ? parts[parts.length - 1] : '';
+        }
+        release() {
+            if (this.table) {
+                delete this.table.importFile;
+                this.table = null;
+            }
+        }
+        async import(type, source, options) {
+            if (!this.table) {
+                throw new Error('表格实例不存在或已销毁，无法导入数据！');
+            }
+            const mergedOptions = { ...this.options, ...options };
+            const isVTableSheet = this._detectVTableSheet(this.table);
+            if (isVTableSheet && type === 'file') {
+                return this._importMultipleSheetsFromFileDialog({
+                    ...mergedOptions,
+                    importAllSheets: true
+                });
+            }
+            if (type === 'file') {
+                return this._importFromFileDialog(mergedOptions);
+            }
+            if (typeof source === 'string') {
+                return this._importFromString(type, source, mergedOptions);
+            }
+            if (Array.isArray(source) || typeof source === 'object') {
+                if (type !== 'json') {
+                    throw new Error('只有JSON格式支持从对象导入');
+                }
+                return this._importFromData('json', source, mergedOptions);
+            }
+            throw new Error('Invalid import source');
+        }
+        async _importFromFileDialog(options) {
+            if (!this.table) {
+                throw new Error('表格实例不存在或已销毁，无法导入数据！');
+            }
+            const file = await this._selectFile();
+            const result = await this._parseFile(file, options);
+            if (options.autoTable && this.table) {
+                if (options.autoColumns) {
+                    this.table.updateOption(Object.assign({}, this.table.options, {
+                        columns: result.columns
+                    }));
+                }
+                this.table.setRecords(result.records);
+            }
+            return result;
+        }
         async _importFromString(type, data, options) {
             let result;
             switch (type) {
@@ -8726,14 +9121,14 @@
                 default:
                     throw new Error(`不支持的导入类型: ${type}`);
             }
-            if (options.autoTable && this._tableInstance) {
+            if (options.autoTable && this.table) {
                 if (options.autoColumns) {
-                    this._tableInstance.updateOption({
+                    this.table.updateOption({
                         columns: result.columns,
                         plugins: [this]
                     });
                 }
-                this._tableInstance.setRecords(result.records);
+                this.table.setRecords(result.records);
             }
             return result;
         }
@@ -8745,14 +9140,14 @@
             else {
                 throw new Error(`不支持的数据类型: ${type}`);
             }
-            if (options.autoTable && this._tableInstance) {
+            if (options.autoTable && this.table) {
                 if (options.autoColumns) {
-                    this._tableInstance.updateOption({
+                    this.table.updateOption({
                         columns: result.columns,
                         plugins: [this]
                     });
                 }
-                this._tableInstance.setRecords(result.records);
+                this.table.setRecords(result.records);
             }
             return result;
         }
@@ -8774,10 +9169,6 @@
                     throw new Error(`不支持的文件类型: ${fileExtension}`);
             }
         }
-        _getFileExtension(filename) {
-            const parts = filename.split('.');
-            return parts.length > 1 ? parts[parts.length - 1] : '';
-        }
         async _parseExcelFile(file, options) {
             const mergedOptions = { ...this.options, ...options };
             return await ExcelImportPlugin.importExcelToVTableData(file, mergedOptions);
@@ -8934,16 +9325,40 @@
             return columns;
         }
         async _parseCSVString(text, options) {
-            const lines = text.split('\n').filter(line => line.trim());
+            const delimiter = options.delimiter || ',';
+            const lines = text.split(/\r?\n/).filter(line => line.trim().length > 0);
             if (lines.length === 0) {
                 throw new Error('CSV文件为空');
             }
-            const delimiter = options.delimiter || ',';
             const parseCSVLine = (line) => {
-                return line.split(delimiter).map(cell => cell.trim().replace(/^"|"$/g, ''));
+                const result = [];
+                let current = '';
+                let inQuotes = false;
+                for (let i = 0; i < line.length; i++) {
+                    const char = line[i];
+                    const nextChar = line[i + 1];
+                    if (char === '"') {
+                        if (inQuotes && nextChar === '"') {
+                            current += '"';
+                            i++;
+                        }
+                        else {
+                            inQuotes = !inQuotes;
+                        }
+                    }
+                    else if (char === delimiter && !inQuotes) {
+                        result.push(current.trim());
+                        current = '';
+                    }
+                    else {
+                        current += char;
+                    }
+                }
+                result.push(current.trim());
+                return result;
             };
             const headerRowCount = 1;
-            const headerRows = lines.slice(0, headerRowCount).map(parseCSVLine);
+            const headerRows = lines.slice(0, headerRowCount).map(line => parseCSVLine(line).map(cell => String(cell || '')));
             const dataRows = lines.slice(headerRowCount);
             const columns = this._buildColumnsFromHeaders(headerRows);
             const records = [];
@@ -8952,7 +9367,7 @@
                     const parsedRow = parseCSVLine(line);
                     const record = {};
                     parsedRow.forEach((cell, i) => {
-                        record[`col${i}`] = cell || '';
+                        record[`col${i}`] = cell ?? '';
                     });
                     return record;
                 });
@@ -9098,17 +9513,17 @@
             };
             const columnsStr = columns.map(col => formatColumn(col)).join(',\n');
             const recordsStr = records.map(formatRecord).join(',\n');
-            return `// VTable 数据导出 - JavaScript 对象字面量格式
-// 生成时间: ${new Date().toLocaleString()}
-
-const vtableData = {
-  columns: [
-${columnsStr}
-  ],
-  records: [
-${recordsStr}
-  ]
-};
+            return `// VTable 数据导出 - JavaScript 对象字面量格式
+// 生成时间: ${new Date().toLocaleString()}
+
+const vtableData = {
+  columns: [
+${columnsStr}
+  ],
+  records: [
+${recordsStr}
+  ]
+};
 `;
         }
         _exportToJS(columns, records) {
@@ -9554,6 +9969,10 @@ ${recordsStr}
             }
         }
         syncColWidthToComponent() {
+            const colRange = this.table.getBodyVisibleColRange();
+            if (!colRange) {
+                return;
+            }
             const { colStart, colEnd } = this.table.getBodyVisibleColRange();
             const adjustStartColIndex = colStart;
             const adjustEndColIndex = Math.min(colEnd, this.table.scenegraph.proxy.colEnd);
@@ -10471,9 +10890,7 @@ ${recordsStr}
         toggleSelectAll(fieldId, selected) {
             const options = this.valueFilterOptionList.get(fieldId);
             options.forEach(option => {
-                if (option.itemContainer.style.display !== 'none') {
-                    option.checkbox.checked = selected;
-                }
+                option.checkbox.checked = selected;
             });
         }
         syncSelectAllCheckbox(fieldId) {
@@ -11155,6 +11572,7 @@ ${recordsStr}
         clearFilterOptionLink;
         cancelFilterButton;
         applyFilterButton;
+        activeType = 'byValue';
         constructor(table, filterStateManager, pluginOptions) {
             this.table = table;
             this.filterStateManager = filterStateManager;
@@ -11265,12 +11683,20 @@ ${recordsStr}
             applyStyles(this.applyFilterButton, styles.footerButton(true));
             this.valueFilter.updateStyles(styles);
             this.conditionFilter.updateStyles(styles);
+            if (this.activeType === 'byCondition') {
+                this.onTabSwitch('byCondition');
+            }
+            else {
+                this.onTabSwitch('byValue');
+            }
         }
         attachEventListeners() {
             this.filterTabByValue.addEventListener('click', () => {
+                this.activeType = 'byValue';
                 this.onTabSwitch('byValue');
             });
             this.filterTabByCondition.addEventListener('click', () => {
+                this.activeType = 'byCondition';
                 this.onTabSwitch('byCondition');
             });
             this.cancelFilterButton.addEventListener('click', () => this.hide());
@@ -21506,20 +21932,38 @@ ${recordsStr}
     async function exportVTableToExcel(tableInstance, options, optimization = false) {
         const workbook = new ExcelJS.Workbook();
         const worksheet = workbook.addWorksheet('sheet1');
+        await renderTableToWorksheet(tableInstance, worksheet, workbook, options, optimization);
+        const buffer = await workbook.xlsx.writeBuffer();
+        return buffer;
+    }
+    async function exportMultipleVTablesToExcel(tables, options, optimization = false) {
+        const workbook = new ExcelJS.Workbook();
+        const usedWorksheetNames = new Set();
+        for (let i = 0; i < tables.length; i++) {
+            const { table, name } = tables[i];
+            const safeName = getUniqueWorksheetName(name || `sheet${i + 1}`, usedWorksheetNames);
+            usedWorksheetNames.add(safeName);
+            const worksheet = workbook.addWorksheet(safeName);
+            await renderTableToWorksheet(table, worksheet, workbook, options, optimization);
+        }
+        const buffer = await workbook.xlsx.writeBuffer();
+        return buffer;
+    }
+    async function renderTableToWorksheet(tableInstance, worksheet, workbook, options, optimization = false) {
         const exportAllData = !!options?.exportAllData;
         const { handleRowCount, reset } = handlePaginationExport(tableInstance, exportAllData);
-        const minRow = 0;
-        const maxRow = handleRowCount();
-        const minCol = 0;
-        const maxCol = tableInstance.colCount - 1;
-        worksheet.properties.defaultRowHeight = 40;
-        const columns = [];
-        const mergeCells = [];
-        const mergeCellSet = new Set();
-        const SLICE_SIZE = 100;
-        let currentRow = minRow;
-        function processSlice(deadline) {
-            return new Promise(async (resolve) => {
+        try {
+            const minRow = 0;
+            const maxRow = handleRowCount();
+            const minCol = 0;
+            const maxCol = tableInstance.colCount - 1;
+            worksheet.properties.defaultRowHeight = 40;
+            const columns = [];
+            const mergeCells = [];
+            const mergeCellSet = new Set();
+            const SLICE_SIZE = 100;
+            let currentRow = minRow;
+            const processSlice = async (deadline) => {
                 while (currentRow <= maxRow && (!optimization || deadline?.timeRemaining() > 0)) {
                     const endRow = Math.min(currentRow + SLICE_SIZE - 1, maxRow);
                     for (let col = minCol; col <= maxCol; col++) {
@@ -21546,53 +21990,70 @@ ${recordsStr}
                     }
                     currentRow = endRow + 1;
                 }
-                if (currentRow > maxRow) {
-                    resolve();
-                }
-                else {
-                    let nextDeadline;
-                    if (optimization) {
-                        nextDeadline = await requestIdleCallbackPromise();
-                    }
+                if (currentRow <= maxRow) {
+                    const nextDeadline = optimization ? await requestIdleCallbackPromise() : undefined;
                     await processSlice(nextDeadline);
-                    resolve();
                 }
-            });
-        }
-        await new Promise(async (resolve) => {
-            let deadline;
+            };
             if (optimization) {
-                deadline = await requestIdleCallbackPromise();
+                const deadline = await requestIdleCallbackPromise();
+                await processSlice(deadline);
             }
-            await processSlice(deadline);
-            resolve();
-        });
-        worksheet.columns = columns;
-        mergeCells.forEach(mergeCell => {
-            worksheet.mergeCells(mergeCell.start.row + 1, mergeCell.start.col + 1, mergeCell.end.row + 1, mergeCell.end.col + 1);
-        });
-        const frozenView = [];
-        if (tableInstance.frozenRowCount > 0) {
-            frozenView.push({
-                state: 'frozen',
-                ySplit: tableInstance.frozenRowCount,
-                topLeftCell: encodeCellAddress(0, tableInstance.frozenRowCount)
+            else {
+                await processSlice();
+            }
+            worksheet.columns = columns;
+            mergeCells.forEach(mergeCell => {
+                worksheet.mergeCells(mergeCell.start.row + 1, mergeCell.start.col + 1, mergeCell.end.row + 1, mergeCell.end.col + 1);
             });
+            const frozenView = [];
+            if (tableInstance.frozenRowCount > 0) {
+                frozenView.push({
+                    state: 'frozen',
+                    ySplit: tableInstance.frozenRowCount,
+                    topLeftCell: encodeCellAddress(0, tableInstance.frozenRowCount)
+                });
+            }
+            if (tableInstance.frozenColCount > 0) {
+                frozenView.push({
+                    state: 'frozen',
+                    xSplit: tableInstance.frozenColCount,
+                    topLeftCell: encodeCellAddress(tableInstance.frozenColCount, 0)
+                });
+            }
+            worksheet.views = frozenView;
+            if (options?.excelJSWorksheetCallback) {
+                options.excelJSWorksheetCallback(worksheet);
+            }
         }
-        if (tableInstance.frozenColCount > 0) {
-            frozenView.push({
-                state: 'frozen',
-                xSplit: tableInstance.frozenColCount,
-                topLeftCell: encodeCellAddress(tableInstance.frozenColCount, 0)
-            });
+        finally {
+            reset();
         }
-        worksheet.views = frozenView;
-        if (options?.excelJSWorksheetCallback) {
-            options.excelJSWorksheetCallback(worksheet);
+    }
+    function getUniqueWorksheetName(rawName, used) {
+        const cleanedBase = sanitizeWorksheetName(rawName) || 'sheet';
+        if (!used.has(cleanedBase)) {
+            return cleanedBase;
         }
-        const buffer = await workbook.xlsx.writeBuffer();
-        reset();
-        return buffer;
+        for (let n = 2; n < 10000; n++) {
+            const suffix = `-${n}`;
+            const baseMax = 31 - suffix.length;
+            const base = cleanedBase.length > baseMax ? cleanedBase.slice(0, baseMax) : cleanedBase;
+            const candidate = `${base}${suffix}`;
+            if (!used.has(candidate)) {
+                return candidate;
+            }
+        }
+        return `${cleanedBase.slice(0, 31 - 6)}-${Date.now().toString().slice(-5)}`;
+    }
+    function sanitizeWorksheetName(name) {
+        const trimmed = (name ?? '').toString().trim();
+        const noInvalidChars = trimmed
+            .replace(/[:\\\/\?\*\[\]]/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+        const nonEmpty = noInvalidChars || 'sheet';
+        return nonEmpty.length > 31 ? nonEmpty.slice(0, 31) : nonEmpty;
     }
     async function addCell(col, row, tableInstance, worksheet, workbook, options) {
         const { layoutMap } = tableInstance.internalProps;
@@ -21974,6 +22435,14 @@ ${recordsStr}
                     }
                     return exportVTableToExcel(this.table, options, this.pluginOptions.exportOnIdle);
                 };
+                if (this.table.__vtableSheet) {
+                    if (!this.table.__vtableSheet._exportMutipleTablesToExcel) {
+                        this.table.__vtableSheet._exportMutipleTablesToExcel = async (tables) => {
+                            const buffer = (await exportMultipleVTablesToExcel(tables, this.pluginOptions.exportExcelOptions));
+                            await downloadExcel(buffer, this.pluginOptions.exportExcelOptions.fileName || 'vtable-sheet-export');
+                        };
+                    }
+                }
             }
         }
         release() {