@visactor/vtable-plugins 1.22.6-alpha.2 → 1.22.6

package/dist/vtable-plugins.js

@@ -1125,7 +1125,7 @@
             document.addEventListener('keydown', this.handleKeyDown.bind(this), true);
         }
         handleKeyDown(event) {
-            if (this.table.editorManager && this.isExcelShortcutKey(event)) {
+            if (this.table?.editorManager && this.isExcelShortcutKey(event)) {
                 const eventKey = event.key.toLowerCase();
                 if (this.table.editorManager.editingEditor && this.table.editorManager.beginTriggerEditCellMode === 'keydown') {
                     const { col, row } = this.table.editorManager.editCell;
@@ -1173,7 +1173,7 @@
                         (eventKey === exports.ExcelEditCellKeyboardResponse.DELETE || eventKey === exports.ExcelEditCellKeyboardResponse.BACKSPACE)) {
                         const selectCells = this.table.getSelectedCellInfos();
                         if (selectCells?.length > 0 && document.activeElement === this.table.getElement()) {
-                            deleteSelectRange(selectCells, this.table);
+                            deleteSelectRange(selectCells, this.table, this.pluginOptions?.deleteWorkOnEditableCell ?? true);
                             event.stopPropagation();
                             event.preventDefault();
                         }
@@ -1197,10 +1197,10 @@
             document.removeEventListener('keydown', this.handleKeyDown, true);
         }
     }
-    function deleteSelectRange(selectCells, tableInstance) {
+    function deleteSelectRange(selectCells, tableInstance, workOnEditableCell = false) {
         for (let i = 0; i < selectCells.length; i++) {
             for (let j = 0; j < selectCells[i].length; j++) {
-                tableInstance.changeCellValue(selectCells[i][j].col, selectCells[i][j].row, '');
+                tableInstance.changeCellValue(selectCells[i][j].col, selectCells[i][j].row, '', workOnEditableCell);
             }
         }
     }
@@ -10144,7 +10144,7 @@ ${recordsStr}
                 exports.FilterActionType.CLEAR_ALL_FILTERS,
                 exports.FilterActionType.APPLY_FILTERS
             ];
-            return shouldApplyActions.includes(action.type) || action.payload.enable;
+            return shouldApplyActions.includes(action.type);
         }
     }
 
@@ -10296,289 +10296,171 @@ ${recordsStr}
     class ValueFilter {
         table;
         filterStateManager;
-        uniqueKeys = new Map();
-        displayToRawValueMap = new Map();
         selectedField;
+        selectedKeys = new Map();
+        candidateKeys = new Map();
+        formatFnCache = new Map();
+        toUnformattedCache = new Map();
         valueFilterOptionList = new Map();
         filterByValuePanel;
         filterByValueSearchInput;
         selectAllCheckbox;
+        totalCountSpan;
         filterItemsContainer;
+        _onInputKeyUpHandler;
+        _onCheckboxChangeHandler;
         constructor(table, filterStateManager) {
             this.table = table;
             this.filterStateManager = filterStateManager;
-            this.filterStateManager.subscribe((state) => {
-                const filterState = state.filters.get(this.selectedField);
-                if (filterState && filterState.type === 'byValue') {
-                    this.updateUI(filterState);
-                }
-            });
-        }
-        updateUI(filterState) {
-            this.syncCheckboxesWithFilterState(filterState);
-            this.syncSelectAllWithFilterState(filterState);
         }
         setSelectedField(fieldId) {
             this.selectedField = fieldId;
-            this.collectUniqueColumnValues(fieldId);
-        }
-        collectUniqueColumnValues(fieldId) {
-            const isEnable = this.filterStateManager.getFilterState(fieldId)?.enable;
-            const displayValueMap = new Map();
-            const rawToDisplayMap = new Map();
-            const displayToRawMap = new Map();
-            let targetCol = -1;
-            for (let col = 0; col < this.table.colCount; col++) {
-                for (let row = this.table.columnHeaderLevelCount; row < this.table.rowCount; row++) {
-                    if (!this.table.internalProps.layoutMap.isHeader(col, row)) {
-                        const bodyInfo = this.table.internalProps.layoutMap.getBody(col, row);
-                        if (bodyInfo && bodyInfo.field === fieldId) {
-                            targetCol = col;
-                            break;
-                        }
-                    }
-                }
-                if (targetCol !== -1) {
-                    break;
-                }
+        }
+        getFormatFnCache(fieldId) {
+            let formatFn = this.formatFnCache.get(fieldId);
+            if (formatFn !== null && formatFn !== undefined) {
+                return formatFn;
             }
-            if (isEnable) {
-                const records = this.table.internalProps.records;
-                const recordsLength = records.length;
-                for (let i = 0; i < recordsLength; i++) {
-                    let rawValue;
-                    let displayValue;
-                    if (targetCol !== -1) {
-                        const row = this.table.columnHeaderLevelCount + i;
-                        const currentRecord = records[i];
-                        rawValue = currentRecord[fieldId];
-                        const bodyInfo = this.table.internalProps.layoutMap.getBody(targetCol, row);
-                        if (bodyInfo &&
-                            'fieldFormat' in bodyInfo &&
-                            bodyInfo.fieldFormat &&
-                            typeof bodyInfo.fieldFormat === 'function') {
-                            displayValue = bodyInfo.fieldFormat({ [fieldId]: rawValue });
-                        }
-                        else {
-                            displayValue = rawValue;
-                        }
-                    }
-                    if (rawValue !== undefined && rawValue !== null) {
-                        displayValueMap.set(displayValue, (displayValueMap.get(displayValue) || 0) + 1);
-                        rawToDisplayMap.set(rawValue, displayValue);
-                        displayToRawMap.set(displayValue, rawValue);
-                    }
-                }
+            const headerAddress = this.table.internalProps.layoutMap.getHeaderCellAddressByField(String(fieldId));
+            const bodyInfo = this.table.internalProps.layoutMap.getBody(headerAddress?.col, headerAddress?.row);
+            if (bodyInfo && 'fieldFormat' in bodyInfo && typeof bodyInfo.fieldFormat === 'function') {
+                formatFn = bodyInfo.fieldFormat;
+            }
+            else if (bodyInfo && 'format' in bodyInfo && typeof bodyInfo.format === 'function') {
+                formatFn = bodyInfo.format;
             }
             else {
-                const dataSource = this.table.internalProps.dataSource;
-                const currentLength = dataSource.length;
-                for (let i = 0; i < currentLength; i++) {
-                    let rawValue;
-                    let displayValue;
-                    if (targetCol !== -1) {
-                        const row = this.table.columnHeaderLevelCount + i;
-                        if (row < this.table.rowCount) {
-                            rawValue = this.table.getCellOriginValue(targetCol, row);
-                            displayValue = this.table.getCellValue(targetCol, row);
-                        }
+                formatFn = (record) => record[fieldId];
+            }
+            this.formatFnCache.set(fieldId, formatFn);
+            return formatFn;
+        }
+        collectCandidateKeysForUnfilteredColumn(fieldId) {
+            const countMap = new Map();
+            const records = this.table.internalProps.dataSource.records;
+            const formatFn = this.getFormatFnCache(fieldId);
+            const toUnformatted = new Map();
+            records.forEach(record => {
+                const originalValue = record[fieldId];
+                const formattedValue = formatFn(record);
+                if (formattedValue !== undefined && formattedValue !== null) {
+                    countMap.set(formattedValue, (countMap.get(formattedValue) || 0) + 1);
+                    const unformattedSet = toUnformatted.get(formattedValue);
+                    if (unformattedSet !== undefined && unformattedSet !== null) {
+                        unformattedSet.add(originalValue);
                     }
                     else {
-                        rawValue = this.table.getFieldData(String(fieldId), targetCol !== -1 ? targetCol : 0, this.table.columnHeaderLevelCount + i);
-                        displayValue = rawValue;
-                    }
-                    if (rawValue !== undefined && rawValue !== null) {
-                        displayValueMap.set(displayValue, (displayValueMap.get(displayValue) || 0) + 1);
-                        rawToDisplayMap.set(rawValue, displayValue);
-                        displayToRawMap.set(displayValue, rawValue);
+                        toUnformatted.set(formattedValue, new Set([originalValue]));
                     }
                 }
-            }
-            this.displayToRawValueMap.set(fieldId, displayToRawMap);
-            const uniqueValues = Array.from(displayValueMap.entries()).map(([displayValue, count]) => ({
-                value: displayValue,
-                count,
-                rawValue: displayToRawMap.get(displayValue)
+            });
+            this.candidateKeys.set(fieldId, countMap);
+            this.toUnformattedCache.set(fieldId, toUnformatted);
+        }
+        collectCandidateKeysForFilteredColumn(candidateField) {
+            const filteredFields = this.filterStateManager.getActiveFilterFields().filter(field => field !== candidateField);
+            const toUnformatted = new Map();
+            const formatFn = this.getFormatFnCache(candidateField);
+            const countMap = new Map();
+            const recordsList = this.table.internalProps.records;
+            const records = recordsList.filter(record => filteredFields.every(field => {
+                const set = this.selectedKeys.get(field);
+                return set.has(record[field]);
             }));
-            this.uniqueKeys.set(fieldId, uniqueValues);
-        }
-        onValueSelect(fieldId, displayValue, selected) {
-            const displayToRawMap = this.displayToRawValueMap.get(fieldId);
-            const rawValue = displayToRawMap ? displayToRawMap.get(displayValue) : displayValue;
-            const filter = this.filterStateManager.getFilterState(fieldId);
-            if (!filter) {
-                this.filterStateManager.dispatch({
-                    type: exports.FilterActionType.ADD_FILTER,
-                    payload: {
-                        field: fieldId,
-                        type: 'byValue',
-                        values: [rawValue]
+            records.forEach(record => {
+                const originalValue = record[candidateField];
+                const formattedValue = formatFn(record);
+                countMap.set(formattedValue, (countMap.get(formattedValue) || 0) + 1);
+                if (formattedValue !== undefined && formattedValue !== null) {
+                    const unformattedSet = toUnformatted.get(formattedValue);
+                    if (unformattedSet !== undefined && unformattedSet !== null) {
+                        unformattedSet.add(originalValue);
                     }
-                });
-            }
-            else {
-                const updatedValues = selected
-                    ? [...(filter.values || []), rawValue]
-                    : (filter.values || []).filter(v => v !== rawValue);
-                this.filterStateManager.dispatch({
-                    type: exports.FilterActionType.UPDATE_FILTER,
-                    payload: {
-                        field: fieldId,
-                        values: updatedValues
+                    else {
+                        toUnformatted.set(formattedValue, new Set([originalValue]));
                     }
-                });
-            }
+                }
+            });
+            this.candidateKeys.set(candidateField, countMap);
+            this.toUnformattedCache.set(candidateField, toUnformatted);
         }
         toggleSelectAll(fieldId, selected) {
-            const filter = this.filterStateManager.getFilterState(fieldId);
-            const rawValuesToUpdate = selected ? this.uniqueKeys.get(fieldId)?.map(item => item.rawValue) || [] : [];
-            if (!filter) {
-                this.filterStateManager.dispatch({
-                    type: exports.FilterActionType.ADD_FILTER,
-                    payload: {
-                        field: fieldId,
-                        type: 'byValue',
-                        values: rawValuesToUpdate,
-                        enable: true
-                    }
-                });
-            }
-            else {
-                const updatedValues = selected ? rawValuesToUpdate : [];
-                this.filterStateManager.dispatch({
-                    type: exports.FilterActionType.UPDATE_FILTER,
-                    payload: {
-                        field: fieldId,
-                        values: updatedValues
-                    }
-                });
-            }
+            const options = this.valueFilterOptionList.get(fieldId);
+            options.forEach(option => {
+                option.checkbox.checked = selected;
+            });
+        }
+        syncSelectAllCheckbox(fieldId) {
+            const options = this.valueFilterOptionList.get(fieldId) || [];
+            const allChecked = options.every(o => o.checkbox.checked);
+            const noneChecked = options.every(o => !o.checkbox.checked);
+            this.selectAllCheckbox.checked = allChecked;
+            this.selectAllCheckbox.indeterminate = !allChecked && !noneChecked;
         }
         onSearch(fieldId, value) {
+            const items = this.valueFilterOptionList.get(fieldId);
             const filterKeywords = value
                 .toUpperCase()
                 .split(' ')
                 .filter(s => s);
-            const items = this.valueFilterOptionList.get(fieldId);
             for (const item of items) {
                 const txtValue = item.id.toUpperCase() || '';
                 const match = filterKeywords.some(keyword => txtValue.includes(keyword));
-                item.itemContainer.style.display = filterKeywords.length === 0 || match ? 'flex' : 'none';
+                const isVisible = filterKeywords.length === 0 || match;
+                item.itemContainer.style.display = isVisible ? 'flex' : 'none';
             }
         }
         initFilterStateFromTableData(fieldId) {
-            const filter = this.filterStateManager.getFilterState(fieldId);
-            const selectedRawValues = new Set();
-            const displayToRawMap = this.displayToRawValueMap.get(fieldId);
-            let targetCol = -1;
-            for (let col = 0; col < this.table.colCount; col++) {
-                for (let row = this.table.columnHeaderLevelCount; row < this.table.rowCount; row++) {
-                    if (!this.table.internalProps.layoutMap.isHeader(col, row)) {
-                        const bodyInfo = this.table.internalProps.layoutMap.getBody(col, row);
-                        if (bodyInfo && bodyInfo.field === fieldId) {
-                            targetCol = col;
-                            break;
-                        }
-                    }
-                }
-                if (targetCol !== -1) {
-                    break;
-                }
-            }
-            const dataSource = this.table.internalProps.dataSource;
-            const currentLength = dataSource.length;
-            for (let i = 0; i < currentLength; i++) {
-                let displayValue;
-                let rawValue;
-                if (targetCol !== -1) {
-                    const row = this.table.columnHeaderLevelCount + i;
-                    if (row < this.table.rowCount) {
-                        displayValue = this.table.getCellValue(targetCol, row);
-                        rawValue = displayToRawMap ? displayToRawMap.get(displayValue) : displayValue;
-                    }
-                }
-                else {
-                    displayValue = this.table.getFieldData(String(fieldId), targetCol !== -1 ? targetCol : 0, this.table.columnHeaderLevelCount + i);
-                    rawValue = displayToRawMap ? displayToRawMap.get(displayValue) : displayValue;
-                }
-                if (rawValue !== undefined && rawValue !== null) {
-                    selectedRawValues.add(rawValue);
-                }
-            }
-            const hasChanged = !filter || !arrayEqual(filter.values, Array.from(selectedRawValues));
-            if (!hasChanged) {
+            const isHasFilteredState = this.filterStateManager.getActiveFilterFields();
+            if (isHasFilteredState) {
                 return;
             }
-            if (filter) {
-                this.filterStateManager.dispatch({
-                    type: exports.FilterActionType.UPDATE_FILTER,
-                    payload: {
-                        field: fieldId,
-                        type: 'byValue',
-                        values: Array.from(selectedRawValues)
-                    }
-                });
-            }
-            else {
+            const selectedValues = new Set();
+            const originalValues = new Set();
+            const currentRecords = this.table.internalProps.dataSource.records;
+            currentRecords.forEach(record => {
+                selectedValues.add(record[fieldId]);
+            });
+            const originalRecords = this.table.internalProps.records;
+            originalRecords.forEach(record => {
+                originalValues.add(record[fieldId]);
+            });
+            const hasFiltered = !arrayEqual(Array.from(originalValues), Array.from(selectedValues));
+            if (hasFiltered) {
+                this.selectedKeys.set(fieldId, selectedValues);
                 this.filterStateManager.dispatch({
                     type: exports.FilterActionType.ADD_FILTER,
                     payload: {
                         field: fieldId,
                         type: 'byValue',
-                        values: Array.from(selectedRawValues)
+                        values: Array.from(selectedValues),
+                        enable: true
                     }
                 });
             }
         }
-        syncCheckboxesWithFilterState(filter) {
-            if (!filter) {
-                return;
-            }
-            const selectedRawValues = filter.values || [];
-            const displayToRawMap = this.displayToRawValueMap.get(filter.field);
-            const optionDomList = this.valueFilterOptionList.get(filter.field);
-            optionDomList?.forEach(optionDom => {
-                const displayValue = optionDom.originalValue;
-                const rawValue = displayToRawMap ? displayToRawMap.get(displayValue) : displayValue;
-                optionDom.checkbox.checked = selectedRawValues.some(v => v === rawValue);
-                const count = this.uniqueKeys.get(filter.field)?.find(key => String(key.value) === optionDom.id)?.count || 0;
-                optionDom.countSpan.textContent = String(count);
-                optionDom.itemContainer.style.display = count === 0 ? 'none' : 'flex';
-            });
-        }
-        syncSelectAllWithFilterState(filter) {
-            if (!filter || !filter.values) {
-                this.selectAllCheckbox.checked = false;
-                this.selectAllCheckbox.indeterminate = false;
+        applyFilter(fieldId = this.selectedField) {
+            const options = this.valueFilterOptionList.get(fieldId);
+            if (!options || options.length === 0) {
                 return;
             }
-            const uniqueValuesCount = this.uniqueKeys.get(filter.field)?.length || 0;
-            if (uniqueValuesCount === 0) {
-                this.selectAllCheckbox.checked = false;
-                this.selectAllCheckbox.indeterminate = false;
-            }
-            else if (filter.values.length === 0) {
-                this.selectAllCheckbox.checked = false;
-                this.selectAllCheckbox.indeterminate = false;
-            }
-            else if (filter.values.length === uniqueValuesCount) {
-                this.selectAllCheckbox.checked = true;
-                this.selectAllCheckbox.indeterminate = false;
-            }
-            else {
-                this.selectAllCheckbox.checked = false;
-                this.selectAllCheckbox.indeterminate = true;
-            }
-        }
-        applyFilter(fieldId = this.selectedField) {
-            const selectedKeys = this.filterStateManager.getFilterState(fieldId)?.values || [];
-            if (selectedKeys.length > 0 && selectedKeys.length < this.uniqueKeys.get(fieldId)?.length) {
+            const selections = options
+                .map(option => {
+                if (option.checkbox.checked) {
+                    return option.originalValue;
+                }
+                return null;
+            })
+                .filter(key => key !== null)
+                .flat();
+            this.selectedKeys.set(fieldId, new Set(selections));
+            if (selections.length > 0 && selections.length < this.valueFilterOptionList.get(fieldId).length) {
                 this.filterStateManager.dispatch({
                     type: exports.FilterActionType.APPLY_FILTERS,
                     payload: {
                         field: fieldId,
                         type: 'byValue',
-                        values: selectedKeys,
+                        values: selections,
                         enable: true
                     }
                 });
@@ -10621,8 +10503,11 @@ ${recordsStr}
             this.selectAllCheckbox.type = 'checkbox';
             this.selectAllCheckbox.checked = true;
             applyStyles(this.selectAllCheckbox, filterStyles.checkbox);
+            this.totalCountSpan = document.createElement('span');
+            this.totalCountSpan.textContent = '';
+            applyStyles(this.totalCountSpan, filterStyles.countSpan);
             selectAllLabel.append(this.selectAllCheckbox, ' 全选');
-            selectAllItemDiv.appendChild(selectAllLabel);
+            selectAllItemDiv.append(selectAllLabel, this.totalCountSpan);
             this.filterItemsContainer = document.createElement('div');
             optionsContainer.append(selectAllItemDiv, this.filterItemsContainer);
             this.filterByValuePanel.append(searchContainer, optionsContainer);
@@ -10633,28 +10518,49 @@ ${recordsStr}
             this.filterItemsContainer.innerHTML = '';
             this.valueFilterOptionList.delete(field);
             this.valueFilterOptionList.set(field, []);
-            const selectedRawValues = this.filterStateManager.getFilterState(field)?.values || [];
-            const selectedRawValueSet = new Set(selectedRawValues);
+            let totalCount = 0;
+            let allChecked = true;
+            let noneChecked = true;
+            const selectedKeysSet = this.selectedKeys.get(field);
             const itemDomList = [];
-            this.uniqueKeys.get(field)?.forEach(({ value, count, rawValue }) => {
+            const isFiltered = this.filterStateManager.getFilterState(field)?.enable;
+            const toUnformatted = this.toUnformattedCache.get(field);
+            const candidates = this.candidateKeys.get(field);
+            if (!candidates || candidates.size === 0) {
+                return;
+            }
+            const candidatesArr = [...candidates.entries()];
+            const sortedCandidatesArr = typeof candidatesArr[0][0] === 'number'
+                ? [...candidatesArr]?.sort(([a], [b]) => Number(a) - Number(b))
+                : [...candidatesArr]?.sort(([a], [b]) => String(a).localeCompare(String(b)));
+            sortedCandidatesArr?.forEach(([val, count]) => {
+                totalCount += count;
+                const unformattedArr = Array.from(toUnformatted.get(val) || new Set());
                 const itemDiv = document.createElement('div');
                 applyStyles(itemDiv, filterStyles.optionItem);
+                itemDiv.style.display = 'flex';
                 const label = document.createElement('label');
                 applyStyles(label, filterStyles.optionLabel);
                 const checkbox = document.createElement('input');
                 checkbox.type = 'checkbox';
-                checkbox.value = String(value);
-                checkbox.checked = selectedRawValueSet.has(rawValue);
+                checkbox.value = String(val);
+                checkbox.checked = isFiltered ? unformattedArr.some(v => selectedKeysSet?.has(v)) : true;
                 applyStyles(checkbox, filterStyles.checkbox);
+                if (checkbox.checked) {
+                    noneChecked = false;
+                }
+                else {
+                    allChecked = false;
+                }
                 const countSpan = document.createElement('span');
                 countSpan.textContent = String(count);
                 applyStyles(countSpan, filterStyles.countSpan);
-                label.append(checkbox, ` ${value}`);
+                label.append(checkbox, ` ${val}`);
                 itemDiv.append(label, countSpan);
                 this.filterItemsContainer.appendChild(itemDiv);
                 const itemDom = {
-                    id: String(value),
-                    originalValue: value,
+                    id: String(val),
+                    originalValue: unformattedArr,
                     itemContainer: itemDiv,
                     checkbox: checkbox,
                     countSpan: countSpan
@@ -10662,34 +10568,44 @@ ${recordsStr}
                 itemDomList.push(itemDom);
             });
             this.valueFilterOptionList.set(field, itemDomList);
+            this.selectAllCheckbox.checked = allChecked;
+            this.selectAllCheckbox.indeterminate = !allChecked && !noneChecked;
+            this.totalCountSpan.textContent = String(totalCount);
         }
         bindEventForFilterByValue() {
-            this.filterByValuePanel.addEventListener('keyup', (event) => {
+            this._onInputKeyUpHandler = (event) => {
                 const target = event.target;
                 if (target instanceof HTMLInputElement && target.type === 'text') {
                     const value = target.value;
                     this.onSearch(this.selectedField, value);
                 }
-            });
-            this.filterByValuePanel.addEventListener('change', (event) => {
+            };
+            this._onCheckboxChangeHandler = (event) => {
                 const target = event.target;
                 if (target instanceof HTMLInputElement && target.type === 'checkbox') {
                     if (target === this.selectAllCheckbox) {
                         this.toggleSelectAll(this.selectedField, this.selectAllCheckbox.checked);
                     }
                     else {
-                        const checkbox = target;
-                        const checked = checkbox.checked;
-                        const value = this.valueFilterOptionList
-                            .get(this.selectedField)
-                            ?.find(item => item.id === checkbox.value)?.originalValue;
-                        this.onValueSelect(this.selectedField, value, checked);
+                        this.syncSelectAllCheckbox(this.selectedField);
                     }
                 }
-            });
+            };
+            this.filterByValuePanel.addEventListener('keyup', this._onInputKeyUpHandler);
+            this.filterByValuePanel.addEventListener('change', this._onCheckboxChangeHandler);
         }
         show() {
+            const isFiltered = this.filterStateManager.getFilterState(this.selectedField)?.enable;
+            if (!isFiltered) {
+                this.collectCandidateKeysForUnfilteredColumn(this.selectedField);
+            }
+            else {
+                this.collectCandidateKeysForFilteredColumn(this.selectedField);
+            }
             this.initFilterStateFromTableData(this.selectedField);
+            if (this.filterByValueSearchInput) {
+                this.filterByValueSearchInput.value = '';
+            }
             this.renderFilterOptions(this.selectedField);
             this.filterByValuePanel.style.display = 'block';
         }
@@ -10699,6 +10615,43 @@ ${recordsStr}
         clearSearchInputValue() {
             this.filterByValueSearchInput.value = '';
         }
+        destroy() {
+            if (this.filterByValuePanel) {
+                if (this._onInputKeyUpHandler) {
+                    this.filterByValuePanel.removeEventListener('keyup', this._onInputKeyUpHandler);
+                }
+                if (this._onCheckboxChangeHandler) {
+                    this.filterByValuePanel.removeEventListener('change', this._onCheckboxChangeHandler);
+                }
+            }
+            this._onInputKeyUpHandler = undefined;
+            this._onCheckboxChangeHandler = undefined;
+            if (this.filterByValuePanel) {
+                const parent = this.filterByValuePanel.parentElement;
+                if (parent) {
+                    parent.removeChild(this.filterByValuePanel);
+                }
+                else {
+                    this.filterByValuePanel.remove();
+                }
+            }
+            if (this.filterItemsContainer) {
+                this.filterItemsContainer.innerHTML = '';
+            }
+            if (this.filterByValueSearchInput) {
+                this.filterByValueSearchInput.value = '';
+            }
+            this.selectedKeys && this.selectedKeys.clear();
+            this.candidateKeys && this.candidateKeys.clear();
+            this.formatFnCache && this.formatFnCache.clear();
+            this.toUnformattedCache && this.toUnformattedCache.clear();
+            this.valueFilterOptionList && this.valueFilterOptionList.clear();
+            this.filterByValuePanel = undefined;
+            this.filterByValueSearchInput = undefined;
+            this.selectAllCheckbox = undefined;
+            this.totalCountSpan = undefined;
+            this.filterItemsContainer = undefined;
+        }
     }
 
     class ConditionFilter {
@@ -11032,6 +10985,11 @@ ${recordsStr}
             this.valueFilter = new ValueFilter(this.table, this.filterStateManager);
             this.conditionFilter = new ConditionFilter(this.table, this.filterStateManager);
             this.filterMenuWidth = 300;
+            this.filterStateManager.subscribe(state => {
+                if (this.isVisible && this.selectedField !== null) {
+                    this.updateClearFilterButtonState(this.selectedField);
+                }
+            });
         }
         onTabSwitch(tab) {
             this.activeTab = tab;
@@ -11074,6 +11032,14 @@ ${recordsStr}
             }
             this.hide();
         }
+        updateClearFilterButtonState(field) {
+            const currentFilter = this.filterStateManager.getFilterState(field);
+            const hasActiveFilter = currentFilter && currentFilter.enable;
+            this.clearFilterOptionLink.style.display = 'inline';
+            this.clearFilterOptionLink.style.opacity = hasActiveFilter ? '1' : '0.5';
+            this.clearFilterOptionLink.style.pointerEvents = hasActiveFilter ? 'auto' : 'none';
+            this.clearFilterOptionLink.style.cursor = hasActiveFilter ? 'pointer' : 'not-allowed';
+        }
         render(container) {
             this.filterMenu = document.createElement('div');
             applyStyles(this.filterMenu, filterStyles.filterMenu);
@@ -11185,6 +11151,7 @@ ${recordsStr}
             else {
                 this.onTabSwitch('byValue');
             }
+            this.updateClearFilterButtonState(field);
             setTimeout(() => {
                 this.isVisible = true;
             }, 0);
@@ -11414,6 +11381,7 @@ ${recordsStr}
             this.table = null;
             this.filterEngine = null;
             this.filterStateManager = null;
+            this.filterToolbar.valueFilter.destroy();
             this.filterToolbar = null;
         }
     }
@@ -12295,26 +12263,26 @@ ${recordsStr}
         }
     }
 
-    var Direction;
+    exports.Direction = void 0;
     (function (Direction) {
         Direction["UP"] = "top";
         Direction["RIGHT"] = "right";
         Direction["DOWN"] = "bottom";
         Direction["LEFT"] = "left";
-    })(Direction || (Direction = {}));
-    var APPLY_TYPE;
+    })(exports.Direction || (exports.Direction = {}));
+    exports.APPLY_TYPE = void 0;
     (function (APPLY_TYPE) {
         APPLY_TYPE["COPY"] = "copy";
         APPLY_TYPE["SERIES"] = "series";
-    })(APPLY_TYPE || (APPLY_TYPE = {}));
-    var CellValueType;
+    })(exports.APPLY_TYPE || (exports.APPLY_TYPE = {}));
+    exports.CellValueType = void 0;
     (function (CellValueType) {
         CellValueType[CellValueType["STRING"] = 1] = "STRING";
         CellValueType[CellValueType["NUMBER"] = 2] = "NUMBER";
         CellValueType[CellValueType["BOOLEAN"] = 3] = "BOOLEAN";
         CellValueType[CellValueType["FORCE_STRING"] = 4] = "FORCE_STRING";
-    })(CellValueType || (CellValueType = {}));
-    var DATA_TYPE;
+    })(exports.CellValueType || (exports.CellValueType = {}));
+    exports.DATA_TYPE = void 0;
     (function (DATA_TYPE) {
         DATA_TYPE["NUMBER"] = "number";
         DATA_TYPE["DATE"] = "date";
@@ -12325,7 +12293,188 @@ ${recordsStr}
         DATA_TYPE["LOOP_SERIES"] = "loopSeries";
         DATA_TYPE["FORMULA"] = "formula";
         DATA_TYPE["OTHER"] = "other";
-    })(DATA_TYPE || (DATA_TYPE = {}));
+    })(exports.DATA_TYPE || (exports.DATA_TYPE = {}));
+
+    function getSelectedRangeArray(selectedRange) {
+        const minCol = Math.min(selectedRange.start.col, selectedRange.end.col);
+        const minRow = Math.min(selectedRange.start.row, selectedRange.end.row);
+        const maxCol = Math.max(selectedRange.start.col, selectedRange.end.col);
+        const maxRow = Math.max(selectedRange.start.row, selectedRange.end.row);
+        const cols = [];
+        const rows = [];
+        for (let i = minCol; i <= maxCol; i++) {
+            cols.push(i);
+        }
+        for (let i = minRow; i <= maxRow; i++) {
+            rows.push(i);
+        }
+        return { cols, rows };
+    }
+    function getTargetRange(direction, sourceRange, selectedRange) {
+        if (direction === exports.Direction.DOWN || direction === exports.Direction.UP) {
+            return {
+                cols: selectedRange.cols,
+                rows: selectedRange.rows.filter(row => !sourceRange.rows.includes(row))
+            };
+        }
+        else {
+            return {
+                cols: selectedRange.cols.filter(col => !sourceRange.cols.includes(col)),
+                rows: selectedRange.rows
+            };
+        }
+    }
+    function openAutoFillMenu(tableInstance, endCol, endRow) {
+        const rect = tableInstance.scenegraph.highPerformanceGetCell(endCol, endRow).globalAABBBounds;
+        tableInstance.showDropDownMenu(endCol, endRow, {
+            content: [
+                {
+                    type: 'item',
+                    text: '复制填充',
+                    icon: {
+                        width: 16,
+                        height: 16,
+                        svg: '<svg t="1756136702877" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="1474" width="200" height="200"><path d="M853.333333 981.333333h-384c-72.533333 0-128-55.466667-128-128v-384c0-72.533333 55.466667-128 128-128h384c72.533333 0 128 55.466667 128 128v384c0 72.533333-55.466667 128-128 128z m-384-554.666666c-25.6 0-42.666667 17.066667-42.666666 42.666666v384c0 25.6 17.066667 42.666667 42.666666 42.666667h384c25.6 0 42.666667-17.066667 42.666667-42.666667v-384c0-25.6-17.066667-42.666667-42.666667-42.666666h-384z" p-id="1475"></path><path d="M213.333333 682.666667H170.666667c-72.533333 0-128-55.466667-128-128V170.666667c0-72.533333 55.466667-128 128-128h384c72.533333 0 128 55.466667 128 128v42.666666c0 25.6-17.066667 42.666667-42.666667 42.666667s-42.666667-17.066667-42.666667-42.666667V170.666667c0-25.6-17.066667-42.666667-42.666666-42.666667H170.666667c-25.6 0-42.666667 17.066667-42.666667 42.666667v384c0 25.6 17.066667 42.666667 42.666667 42.666666h42.666666c25.6 0 42.666667 17.066667 42.666667 42.666667s-17.066667 42.666667-42.666667 42.666667z" p-id="1476"></path></svg>'
+                    }
+                },
+                {
+                    type: 'item',
+                    text: '序列填充',
+                    icon: {
+                        width: 16,
+                        height: 16,
+                        svg: '<svg t="1756136788547" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="2463" width="200" height="200"><path d="M312.832482 65.167035H959.204489c35.706211 0 64.64232 29.473622 64.64232 65.832527 0 36.346107-28.936109 65.832527-64.629522 65.832527H312.819684c-35.693413 0-64.629522-29.473622-64.629522-65.832527 0-36.346107 28.936109-65.832527 64.629522-65.832527z m0 394.982363H959.204489c35.706211 0 64.64232 29.460824 64.64232 65.819729 0 36.358905-28.936109 65.832527-64.629522 65.832527H312.819684c-35.693413 0-64.629522-29.473622-64.629522-65.832527 0-36.346107 28.936109-65.819729 64.629522-65.819729z m0 394.969566H959.204489c35.706211 0 64.64232 29.473622 64.64232 65.819729 0 36.358905-28.936109 65.832527-64.629522 65.832527H312.819684c-35.693413 0-64.629522-29.473622-64.629522-65.832527 0-36.346107 28.936109-65.819729 64.629522-65.819729zM12.286008 69.108796V38.176211c9.892796 0.767876 19.836784 0.767876 29.72958 0A41.823619 41.823619 0 0 0 63.989626 25.672638c4.261709-4.671243 7.358807-10.315128 9.048133-16.458132 0.37114-3.058704 0.37114-6.143004 0-9.214506H114.413451v229.748352H65.93491V69.108796H12.286008z m0 510.176487a130.730805 130.730805 0 0 1 45.240665-49.374395 334.537763 334.537763 0 0 0 40.070304-32.250771 48.47854 48.47854 0 0 0 14.218495-33.581756 37.31875 37.31875 0 0 0-7.755543-24.354451 28.193829 28.193829 0 0 0-23.266628-9.879998 27.643518 27.643518 0 0 0-31.02217 15.139945 78.27211 78.27211 0 0 0-5.170362 28.30901H2.585181a114.311067 114.311067 0 0 1 10.340723-48.056208c12.388392-24.124089 38.086625-37.984242 64.629522-34.887144a79.897447 79.897447 0 0 1 57.539472 20.41269 71.783562 71.783562 0 0 1 21.321343 53.981648 74.637499 74.637499 0 0 1-14.858391 46.072531 152.16733 152.16733 0 0 1-32.967455 29.627197L90.481331 553.625443l-23.266628 17.763521c-4.082538 3.583419-7.563574 7.806734-10.353522 12.51637h99.542262v40.147092H0a110.945213 110.945213 0 0 1 10.340724-45.419837l1.945284 0.665492zM44.600769 948.582211a53.495327 53.495327 0 0 0 4.517668 23.036265 30.279891 30.279891 0 0 0 29.742378 17.110826c7.422797 0.255959 14.717614-2.073264 20.681447-6.578133 6.7829-6.962071 10.315128-16.547717 9.688029-26.325332a30.356678 30.356678 0 0 0-18.096266-30.945383 91.735527 91.735527 0 0 0-32.314761-8.561812V883.440772a83.903197 83.903197 0 0 0 30.382274-4.607253 27.106005 27.106005 0 0 0 14.858391-28.30901 30.612637 30.612637 0 0 0-7.755542-21.730877 27.528337 27.528337 0 0 0-21.321344-8.549014 26.939632 26.939632 0 0 0-23.279425 10.532692 44.063256 44.063256 0 0 0-7.102849 27.643519H2.585181a117.101015 117.101015 0 0 1 5.823056-32.916264 74.381541 74.381541 0 0 1 17.443572-25.019944 60.534186 60.534186 0 0 1 20.681447-12.503572 89.55988 89.55988 0 0 1 29.742378-3.289067A78.540867 78.540867 0 0 1 129.259044 801.79001a57.744238 57.744238 0 0 1 20.041551 46.085328 51.921182 51.921182 0 0 1-12.286008 34.887144c-4.159326 5.170362-9.470465 9.227304-15.511086 11.850879 6.7829 1.510155 12.900309 5.208756 17.45637 10.532692a57.821026 57.821026 0 0 1 17.443572 44.10165 75.136618 75.136618 0 0 1-20.028753 52.010768 76.122059 76.122059 0 0 1-59.471958 22.383571 71.962733 71.962733 0 0 1-64.629522-32.250771A97.52019 97.52019 0 0 1 1.279793 946.611331l43.308178 1.97088z" fill="#515151" p-id="2464"></path></svg>'
+                    }
+                }
+            ],
+            referencePosition: {
+                rect: {
+                    right: rect.x2 + 110,
+                    bottom: rect.y2
+                }
+            }
+        });
+    }
+    function getCellMatrix(table) {
+        return {
+            getValue: (row, col) => {
+                const value = table.getCellValue(col, row);
+                if (typeof value === 'number' || !isNaN(Number(value))) {
+                    return {
+                        v: value,
+                        t: exports.CellValueType.NUMBER
+                    };
+                }
+                return {
+                    v: value || '',
+                    t: exports.CellValueType.STRING
+                };
+            },
+            getMaxRows: () => {
+                return table.records.length;
+            },
+            getMaxColumns: () => {
+                return table.columns.length;
+            }
+        };
+    }
+    function isMergeCell(table, col, row) {
+        const cellRange = table.getCellRange(col, row);
+        if (cellRange.start.col !== cellRange.end.col || cellRange.start.row !== cellRange.end.row) {
+            return cellRange;
+        }
+        return null;
+    }
+
+    class DefaultFormulaAdapter {
+        table;
+        constructor(table) {
+            this.table = table;
+        }
+        isFormulaCell(col, row) {
+            const cellValue = this.table.getCellValue(col, row);
+            return typeof cellValue === 'string' && cellValue.startsWith('=');
+        }
+        getCellFormula(col, row) {
+            const cellValue = this.table.getCellValue(col, row);
+            if (typeof cellValue === 'string' && cellValue.startsWith('=')) {
+                return cellValue;
+            }
+            return undefined;
+        }
+        setCellFormula(col, row, formula) {
+            this.table.changeCellValue(col, row, formula);
+        }
+        getCalculatedValue(col, row) {
+            return this.table.getCellValue(col, row);
+        }
+        refreshFormulas() {
+        }
+        hasFormulaEngine() {
+            return false;
+        }
+    }
+    function createFormulaAdapter(table, customIsFormulaCell, customGetCellFormula, customSetCellFormula) {
+        if (customIsFormulaCell || customGetCellFormula || customSetCellFormula) {
+            return new CustomFormulaAdapter(table, customIsFormulaCell, customGetCellFormula, customSetCellFormula);
+        }
+        return new DefaultFormulaAdapter(table);
+    }
+    class CustomFormulaAdapter {
+        table;
+        isFormulaCellFn;
+        getCellFormulaFn;
+        setCellFormulaFn;
+        constructor(table, isFormulaCellFn, getCellFormulaFn, setCellFormulaFn) {
+            this.table = table;
+            this.isFormulaCellFn = isFormulaCellFn;
+            this.getCellFormulaFn = getCellFormulaFn;
+            this.setCellFormulaFn = setCellFormulaFn;
+        }
+        isFormulaCell(col, row) {
+            if (this.isFormulaCellFn) {
+                const cellData = this.table.getCellValue(col, row);
+                return this.isFormulaCellFn(col, row, cellData, this.table);
+            }
+            const cellValue = this.table.getCellValue(col, row);
+            return typeof cellValue === 'string' && cellValue.startsWith('=');
+        }
+        getCellFormula(col, row) {
+            if (this.getCellFormulaFn) {
+                const cellData = this.table.getCellValue(col, row);
+                return this.getCellFormulaFn(col, row, cellData, this.table);
+            }
+            const cellValue = this.table.getCellValue(col, row);
+            if (typeof cellValue === 'string' && cellValue.startsWith('=')) {
+                return cellValue;
+            }
+            return undefined;
+        }
+        setCellFormula(col, row, formula) {
+            if (this.setCellFormulaFn) {
+                this.setCellFormulaFn(col, row, formula, this.table);
+                return;
+            }
+            this.table.changeCellValue(col, row, formula);
+        }
+        getCalculatedValue(col, row) {
+            return this.table.getCellValue(col, row);
+        }
+        refreshFormulas() {
+        }
+        hasFormulaEngine() {
+            return false;
+        }
+    }
+    function enhanceCellDataWithFormula(cellData, col, row, formulaAdapter) {
+        const enhanced = { ...cellData };
+        if (formulaAdapter.isFormulaCell(col, row)) {
+            enhanced.isFormula = true;
+            enhanced.formula = formulaAdapter.getCellFormula(col, row);
+            enhanced.calculatedValue = formulaAdapter.getCalculatedValue(col, row);
+        }
+        return enhanced;
+    }
 
     /**
      * A specialized version of `_.forEach` for arrays without support for
@@ -13508,7 +13657,7 @@ ${recordsStr}
                 const index = (i - 1) % data.length;
                 const d = deepClone(data[index]);
                 removeCellCustom(d);
-                const forward = direction === Direction.DOWN || direction === Direction.RIGHT;
+                const forward = direction === exports.Direction.DOWN || direction === exports.Direction.RIGHT;
                 const y = forecast(data.length + i, dataNumArr, xArr, forward);
                 if (d) {
                     d.v = converter ? converter.fromNumber(y, d.f) : y;
@@ -13858,22 +14007,22 @@ ${recordsStr}
     converterManager.register(new DateConverter());
 
     const dateRule = {
-        type: DATA_TYPE.DATE,
+        type: exports.DATA_TYPE.DATE,
         priority: 1100,
         match: (cellData, accessor) => {
             return typeof cellData?.v === 'string' && converterManager.getConverter(cellData.v) instanceof DateConverter;
         },
         isContinue: (prev, cur) => {
-            if (prev.type === DATA_TYPE.DATE) {
+            if (prev.type === exports.DATA_TYPE.DATE) {
                 return true;
             }
             return false;
         },
         applyFunctions: {
-            [APPLY_TYPE.SERIES]: (dataWithIndex, len, direction) => {
+            [exports.APPLY_TYPE.SERIES]: (dataWithIndex, len, direction) => {
                 const { data } = dataWithIndex;
                 const converter = converterManager.getConverter(data[0]?.v);
-                if (direction === Direction.LEFT || direction === Direction.UP) {
+                if (direction === exports.Direction.LEFT || direction === exports.Direction.UP) {
                     data.reverse();
                     return fillSeries(data, len, direction, converter).reverse();
                 }
@@ -13882,19 +14031,19 @@ ${recordsStr}
         }
     };
     const numberRule = {
-        type: DATA_TYPE.NUMBER,
+        type: exports.DATA_TYPE.NUMBER,
         priority: 1000,
-        match: (cellData) => typeof cellData?.v === 'number' || cellData?.t === CellValueType.NUMBER,
+        match: (cellData) => typeof cellData?.v === 'number' || cellData?.t === exports.CellValueType.NUMBER,
         isContinue: (prev, cur) => {
-            if (prev.type === DATA_TYPE.NUMBER) {
+            if (prev.type === exports.DATA_TYPE.NUMBER) {
                 return true;
             }
             return false;
         },
         applyFunctions: {
-            [APPLY_TYPE.SERIES]: (dataWithIndex, len, direction) => {
+            [exports.APPLY_TYPE.SERIES]: (dataWithIndex, len, direction) => {
                 const { data } = dataWithIndex;
-                if (direction === Direction.LEFT || direction === Direction.UP) {
+                if (direction === exports.Direction.LEFT || direction === exports.Direction.UP) {
                     data.reverse();
                     return fillSeries(data, len, direction).reverse();
                 }
@@ -13903,22 +14052,22 @@ ${recordsStr}
         }
     };
     const otherRule = {
-        type: DATA_TYPE.OTHER,
+        type: exports.DATA_TYPE.OTHER,
         priority: 0,
         match: () => true,
         isContinue: (prev, cur) => {
-            if (prev.type === DATA_TYPE.OTHER) {
+            if (prev.type === exports.DATA_TYPE.OTHER) {
                 return true;
             }
             return false;
         }
     };
     const extendNumberRule = {
-        type: DATA_TYPE.EXTEND_NUMBER,
+        type: exports.DATA_TYPE.EXTEND_NUMBER,
         priority: 900,
         match: cellData => matchExtendNumber(`${cellData?.v ?? ''}` || '').isExtendNumber,
         isContinue: (prev, cur) => {
-            if (prev.type === DATA_TYPE.EXTEND_NUMBER) {
+            if (prev.type === exports.DATA_TYPE.EXTEND_NUMBER) {
                 const { beforeTxt, afterTxt } = matchExtendNumber(`${prev.cellData?.v ?? ''}` || '');
                 const { beforeTxt: curBeforeTxt, afterTxt: curAfterTxt } = matchExtendNumber(`${cur?.v ?? ''}` || '');
                 if (beforeTxt === curBeforeTxt && afterTxt === curAfterTxt) {
@@ -13928,9 +14077,9 @@ ${recordsStr}
             return false;
         },
         applyFunctions: {
-            [APPLY_TYPE.SERIES]: (dataWithIndex, len, direction) => {
+            [exports.APPLY_TYPE.SERIES]: (dataWithIndex, len, direction) => {
                 const { data } = dataWithIndex;
-                const isReverse = direction === Direction.UP || direction === Direction.LEFT;
+                const isReverse = direction === exports.Direction.UP || direction === exports.Direction.LEFT;
                 let step;
                 if (data.length === 1) {
                     step = isReverse ? -1 : 1;
@@ -13954,7 +14103,7 @@ ${recordsStr}
         }
     };
     const chnNumberRule = {
-        type: DATA_TYPE.CHN_NUMBER,
+        type: exports.DATA_TYPE.CHN_NUMBER,
         priority: 830,
         match: cellData => {
             if (isChnNumber(`${cellData?.v ?? ''}` || '')) {
@@ -13963,15 +14112,15 @@ ${recordsStr}
             return false;
         },
         isContinue: (prev, cur) => {
-            if (prev.type === DATA_TYPE.CHN_NUMBER) {
+            if (prev.type === exports.DATA_TYPE.CHN_NUMBER) {
                 return true;
             }
             return false;
         },
         applyFunctions: {
-            [APPLY_TYPE.SERIES]: (dataWithIndex, len, direction) => {
+            [exports.APPLY_TYPE.SERIES]: (dataWithIndex, len, direction) => {
                 const { data } = dataWithIndex;
-                const isReverse = direction === Direction.LEFT || direction === Direction.UP;
+                const isReverse = direction === exports.Direction.LEFT || direction === exports.Direction.UP;
                 if (data.length === 1) {
                     let step;
                     if (!isReverse) {
@@ -14023,7 +14172,7 @@ ${recordsStr}
         }
     };
     const chnWeek2Rule = {
-        type: DATA_TYPE.CHN_WEEK2,
+        type: exports.DATA_TYPE.CHN_WEEK2,
         priority: 820,
         match: cellData => {
             if (isChnWeek2(`${cellData?.v ?? ''}` || '')) {
@@ -14031,11 +14180,11 @@ ${recordsStr}
             }
             return false;
         },
-        isContinue: (prev, cur) => prev.type === DATA_TYPE.CHN_WEEK2,
+        isContinue: (prev, cur) => prev.type === exports.DATA_TYPE.CHN_WEEK2,
         applyFunctions: {
-            [APPLY_TYPE.SERIES]: (dataWithIndex, len, direction) => {
+            [exports.APPLY_TYPE.SERIES]: (dataWithIndex, len, direction) => {
                 const { data } = dataWithIndex;
-                const isReverse = direction === Direction.LEFT || direction === Direction.UP;
+                const isReverse = direction === exports.Direction.LEFT || direction === exports.Direction.UP;
                 if (data.length === 1) {
                     let step;
                     if (!isReverse) {
@@ -14077,14 +14226,14 @@ ${recordsStr}
         }
     };
     const chnWeek3Rule = {
-        type: DATA_TYPE.CHN_WEEK3,
+        type: exports.DATA_TYPE.CHN_WEEK3,
         priority: 810,
         match: cellData => isChnWeek3(`${cellData?.v ?? ''}` || ''),
-        isContinue: (prev, cur) => prev.type === DATA_TYPE.CHN_WEEK3,
+        isContinue: (prev, cur) => prev.type === exports.DATA_TYPE.CHN_WEEK3,
         applyFunctions: {
-            [APPLY_TYPE.SERIES]: (dataWithIndex, len, direction) => {
+            [exports.APPLY_TYPE.SERIES]: (dataWithIndex, len, direction) => {
                 const { data } = dataWithIndex;
-                const isReverse = direction === Direction.LEFT || direction === Direction.UP;
+                const isReverse = direction === exports.Direction.LEFT || direction === exports.Direction.UP;
                 if (data.length === 1) {
                     let step;
                     if (!isReverse) {
@@ -14128,20 +14277,20 @@ ${recordsStr}
         }
     };
     const loopSeriesRule = {
-        type: DATA_TYPE.LOOP_SERIES,
+        type: exports.DATA_TYPE.LOOP_SERIES,
         priority: 800,
         match: cellData => isLoopSeries(`${cellData?.v ?? ''}` || ''),
         isContinue: (prev, cur) => {
-            if (prev.type === DATA_TYPE.LOOP_SERIES) {
+            if (prev.type === exports.DATA_TYPE.LOOP_SERIES) {
                 return (getLoopSeriesInfo(`${prev.cellData?.v ?? ''}` || '').name ===
                     getLoopSeriesInfo(`${cur?.v ?? ''}` || '').name);
             }
             return false;
         },
         applyFunctions: {
-            [APPLY_TYPE.SERIES]: (dataWithIndex, len, direction) => {
+            [exports.APPLY_TYPE.SERIES]: (dataWithIndex, len, direction) => {
                 const { data } = dataWithIndex;
-                const isReverse = direction === Direction.LEFT || direction === Direction.UP;
+                const isReverse = direction === exports.Direction.LEFT || direction === exports.Direction.UP;
                 const { series } = getLoopSeriesInfo(`${data[0]?.v}` || '');
                 if (data.length === 1) {
                     let step;
@@ -14187,6 +14336,192 @@ ${recordsStr}
     function reverseIfNeed(data, reverse) {
         return reverse ? data.reverse() : data;
     }
+    const formulaRule = {
+        type: exports.DATA_TYPE.FORMULA,
+        priority: 1200,
+        match: (cellData, accessor) => {
+            return typeof cellData?.v === 'string' && cellData.v.startsWith('=');
+        },
+        isContinue: (prev, cur) => {
+            if (prev.type === exports.DATA_TYPE.FORMULA && cur?.v?.startsWith('=')) {
+                return true;
+            }
+            return false;
+        },
+        applyFunctions: {
+            [exports.APPLY_TYPE.COPY]: (dataWithIndex, len, direction, copyDataPiece, location) => {
+                const { data } = dataWithIndex;
+                return fillCopy(data, len);
+            },
+            [exports.APPLY_TYPE.SERIES]: (dataWithIndex, len, direction, copyDataPiece, location) => {
+                const { data } = dataWithIndex;
+                if (data.length === 1) {
+                    return adjustFormulaReferences(data, len, direction);
+                }
+                const adjustedFormulas = adjustFormulaReferencesInSeries(data, len);
+                if (adjustedFormulas) {
+                    return adjustedFormulas;
+                }
+                return fillCopy(data, len);
+            }
+        }
+    };
+    function adjustFormulaReferences(formulas, len, direction, location) {
+        const result = [];
+        const baseFormula = formulas[0]?.v || '';
+        for (let i = 0; i < len; i++) {
+            let newFormula = baseFormula;
+            let rowOffset = 0;
+            let colOffset = 0;
+            switch (direction) {
+                case exports.Direction.DOWN:
+                    rowOffset = i + 1;
+                    break;
+                case exports.Direction.UP:
+                    rowOffset = -(i + 1);
+                    break;
+                case exports.Direction.RIGHT:
+                    colOffset = i + 1;
+                    break;
+                case exports.Direction.LEFT:
+                    colOffset = -(i + 1);
+                    break;
+            }
+            newFormula = adjustCellReferencesInFormula(baseFormula, rowOffset, colOffset);
+            result.push({
+                v: newFormula,
+                t: formulas[0]?.t
+            });
+        }
+        return result;
+    }
+    function adjustFormulaReferencesInSeries(formulas, len, direction, location) {
+        if (formulas.length < 2) {
+            return null;
+        }
+        const baseFormula1 = formulas[0]?.v || '';
+        const baseFormula2 = formulas[1]?.v || '';
+        const pattern = detectFormulaPattern(baseFormula1, baseFormula2);
+        if (!pattern) {
+            return null;
+        }
+        const result = [];
+        for (let i = 0; i < len; i++) {
+            let newFormula = baseFormula1;
+            const multiplier = i + 1;
+            newFormula = applyFormulaPattern(newFormula, pattern, multiplier);
+            result.push({
+                v: newFormula,
+                t: formulas[0]?.t
+            });
+        }
+        return result;
+    }
+    function detectFormulaPattern(formula1, formula2) {
+        const cellRefRegex = /\$?([A-Z]+)\$?(\d+)/g;
+        const matches1 = [...formula1.matchAll(cellRefRegex)];
+        const matches2 = [...formula2.matchAll(cellRefRegex)];
+        if (matches1.length !== matches2.length || matches1.length === 0) {
+            return null;
+        }
+        let totalRowOffset = 0;
+        let totalColOffset = 0;
+        let validMatches = 0;
+        for (let i = 0; i < matches1.length; i++) {
+            const col1 = matches1[i][1];
+            const row1 = parseInt(matches1[i][2], 10);
+            const col2 = matches2[i][1];
+            const row2 = parseInt(matches2[i][2], 10);
+            const colOffset = columnToNumber(col2) - columnToNumber(col1);
+            const rowOffset = row2 - row1;
+            if (Math.abs(colOffset) < 100 && Math.abs(rowOffset) < 10000) {
+                totalColOffset += colOffset;
+                totalRowOffset += rowOffset;
+                validMatches++;
+            }
+        }
+        if (validMatches === 0) {
+            return null;
+        }
+        return {
+            rowOffset: totalRowOffset / validMatches,
+            colOffset: totalColOffset / validMatches
+        };
+    }
+    function applyFormulaPattern(formula, pattern, multiplier, direction) {
+        const cellRefRegex = /\$?([A-Z]+)\$?(\d+)/g;
+        return formula.replace(cellRefRegex, (match, colStr, rowStr) => {
+            const isColAbsolute = match.startsWith('$') && match.indexOf(colStr) > 0;
+            const isRowAbsolute = match.includes('$' + rowStr);
+            let newCol = colStr;
+            let newRow = rowStr;
+            if (!isColAbsolute && pattern.colOffset !== 0) {
+                const colNum = columnToNumber(colStr);
+                const newColNum = colNum + pattern.colOffset * multiplier;
+                newCol = numberToColumn(newColNum);
+            }
+            if (!isRowAbsolute && pattern.rowOffset !== 0) {
+                const rowNum = parseInt(rowStr, 10);
+                const newRowNum = rowNum + pattern.rowOffset * multiplier;
+                newRow = newRowNum.toString();
+            }
+            let result = '';
+            if (isColAbsolute) {
+                result += '$';
+            }
+            result += newCol;
+            if (isRowAbsolute) {
+                result += '$';
+            }
+            result += newRow;
+            return result;
+        });
+    }
+    function adjustCellReferencesInFormula(formula, rowOffset, colOffset) {
+        const cellRefRegex = /\$?([A-Z]+)\$?(\d+)/g;
+        return formula.replace(cellRefRegex, (match, colStr, rowStr) => {
+            const isColAbsolute = match.startsWith('$') && match.indexOf(colStr) > 0;
+            const isRowAbsolute = match.includes('$' + rowStr);
+            let newCol = colStr;
+            let newRow = rowStr;
+            if (!isColAbsolute && colOffset !== 0) {
+                const colNum = columnToNumber(colStr);
+                const newColNum = colNum + colOffset;
+                newCol = numberToColumn(newColNum);
+            }
+            if (!isRowAbsolute && rowOffset !== 0) {
+                const rowNum = parseInt(rowStr, 10);
+                const newRowNum = rowNum + rowOffset;
+                newRow = newRowNum.toString();
+            }
+            let result = '';
+            if (isColAbsolute) {
+                result += '$';
+            }
+            result += newCol;
+            if (isRowAbsolute) {
+                result += '$';
+            }
+            result += newRow;
+            return result;
+        });
+    }
+    function columnToNumber(col) {
+        let result = 0;
+        for (let i = 0; i < col.length; i++) {
+            result = result * 26 + (col.charCodeAt(i) - 'A'.charCodeAt(0) + 1);
+        }
+        return result;
+    }
+    function numberToColumn(num) {
+        let result = '';
+        while (num > 0) {
+            num--;
+            result = String.fromCharCode('A'.charCodeAt(0) + (num % 26)) + result;
+            num = Math.floor(num / 26);
+        }
+        return result;
+    }
 
     class AutoFillService {
         _rules = [];
@@ -14195,6 +14530,7 @@ ${recordsStr}
         }
         _init() {
             this._rules = [
+                formulaRule,
                 dateRule,
                 numberRule,
                 extendNumberRule,
@@ -14217,97 +14553,6 @@ ${recordsStr}
         }
     }
 
-    function getSelectedRangeArray(selectedRange) {
-        const minCol = Math.min(selectedRange.start.col, selectedRange.end.col);
-        const minRow = Math.min(selectedRange.start.row, selectedRange.end.row);
-        const maxCol = Math.max(selectedRange.start.col, selectedRange.end.col);
-        const maxRow = Math.max(selectedRange.start.row, selectedRange.end.row);
-        const cols = [];
-        const rows = [];
-        for (let i = minCol; i <= maxCol; i++) {
-            cols.push(i);
-        }
-        for (let i = minRow; i <= maxRow; i++) {
-            rows.push(i);
-        }
-        return { cols, rows };
-    }
-    function getTargetRange(direction, sourceRange, selectedRange) {
-        if (direction === Direction.DOWN || direction === Direction.UP) {
-            return {
-                cols: selectedRange.cols,
-                rows: selectedRange.rows.filter(row => !sourceRange.rows.includes(row))
-            };
-        }
-        else {
-            return {
-                cols: selectedRange.cols.filter(col => !sourceRange.cols.includes(col)),
-                rows: selectedRange.rows
-            };
-        }
-    }
-    function openAutoFillMenu(tableInstance, endCol, endRow) {
-        const rect = tableInstance.scenegraph.highPerformanceGetCell(endCol, endRow).globalAABBBounds;
-        tableInstance.showDropDownMenu(endCol, endRow, {
-            content: [
-                {
-                    type: 'item',
-                    text: '复制填充',
-                    icon: {
-                        width: 16,
-                        height: 16,
-                        svg: '<svg t="1756136702877" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="1474" width="200" height="200"><path d="M853.333333 981.333333h-384c-72.533333 0-128-55.466667-128-128v-384c0-72.533333 55.466667-128 128-128h384c72.533333 0 128 55.466667 128 128v384c0 72.533333-55.466667 128-128 128z m-384-554.666666c-25.6 0-42.666667 17.066667-42.666666 42.666666v384c0 25.6 17.066667 42.666667 42.666666 42.666667h384c25.6 0 42.666667-17.066667 42.666667-42.666667v-384c0-25.6-17.066667-42.666667-42.666667-42.666666h-384z" p-id="1475"></path><path d="M213.333333 682.666667H170.666667c-72.533333 0-128-55.466667-128-128V170.666667c0-72.533333 55.466667-128 128-128h384c72.533333 0 128 55.466667 128 128v42.666666c0 25.6-17.066667 42.666667-42.666667 42.666667s-42.666667-17.066667-42.666667-42.666667V170.666667c0-25.6-17.066667-42.666667-42.666666-42.666667H170.666667c-25.6 0-42.666667 17.066667-42.666667 42.666667v384c0 25.6 17.066667 42.666667 42.666667 42.666666h42.666666c25.6 0 42.666667 17.066667 42.666667 42.666667s-17.066667 42.666667-42.666667 42.666667z" p-id="1476"></path></svg>'
-                    }
-                },
-                {
-                    type: 'item',
-                    text: '序列填充',
-                    icon: {
-                        width: 16,
-                        height: 16,
-                        svg: '<svg t="1756136788547" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="2463" width="200" height="200"><path d="M312.832482 65.167035H959.204489c35.706211 0 64.64232 29.473622 64.64232 65.832527 0 36.346107-28.936109 65.832527-64.629522 65.832527H312.819684c-35.693413 0-64.629522-29.473622-64.629522-65.832527 0-36.346107 28.936109-65.832527 64.629522-65.832527z m0 394.982363H959.204489c35.706211 0 64.64232 29.460824 64.64232 65.819729 0 36.358905-28.936109 65.832527-64.629522 65.832527H312.819684c-35.693413 0-64.629522-29.473622-64.629522-65.832527 0-36.346107 28.936109-65.819729 64.629522-65.819729z m0 394.969566H959.204489c35.706211 0 64.64232 29.473622 64.64232 65.819729 0 36.358905-28.936109 65.832527-64.629522 65.832527H312.819684c-35.693413 0-64.629522-29.473622-64.629522-65.832527 0-36.346107 28.936109-65.819729 64.629522-65.819729zM12.286008 69.108796V38.176211c9.892796 0.767876 19.836784 0.767876 29.72958 0A41.823619 41.823619 0 0 0 63.989626 25.672638c4.261709-4.671243 7.358807-10.315128 9.048133-16.458132 0.37114-3.058704 0.37114-6.143004 0-9.214506H114.413451v229.748352H65.93491V69.108796H12.286008z m0 510.176487a130.730805 130.730805 0 0 1 45.240665-49.374395 334.537763 334.537763 0 0 0 40.070304-32.250771 48.47854 48.47854 0 0 0 14.218495-33.581756 37.31875 37.31875 0 0 0-7.755543-24.354451 28.193829 28.193829 0 0 0-23.266628-9.879998 27.643518 27.643518 0 0 0-31.02217 15.139945 78.27211 78.27211 0 0 0-5.170362 28.30901H2.585181a114.311067 114.311067 0 0 1 10.340723-48.056208c12.388392-24.124089 38.086625-37.984242 64.629522-34.887144a79.897447 79.897447 0 0 1 57.539472 20.41269 71.783562 71.783562 0 0 1 21.321343 53.981648 74.637499 74.637499 0 0 1-14.858391 46.072531 152.16733 152.16733 0 0 1-32.967455 29.627197L90.481331 553.625443l-23.266628 17.763521c-4.082538 3.583419-7.563574 7.806734-10.353522 12.51637h99.542262v40.147092H0a110.945213 110.945213 0 0 1 10.340724-45.419837l1.945284 0.665492zM44.600769 948.582211a53.495327 53.495327 0 0 0 4.517668 23.036265 30.279891 30.279891 0 0 0 29.742378 17.110826c7.422797 0.255959 14.717614-2.073264 20.681447-6.578133 6.7829-6.962071 10.315128-16.547717 9.688029-26.325332a30.356678 30.356678 0 0 0-18.096266-30.945383 91.735527 91.735527 0 0 0-32.314761-8.561812V883.440772a83.903197 83.903197 0 0 0 30.382274-4.607253 27.106005 27.106005 0 0 0 14.858391-28.30901 30.612637 30.612637 0 0 0-7.755542-21.730877 27.528337 27.528337 0 0 0-21.321344-8.549014 26.939632 26.939632 0 0 0-23.279425 10.532692 44.063256 44.063256 0 0 0-7.102849 27.643519H2.585181a117.101015 117.101015 0 0 1 5.823056-32.916264 74.381541 74.381541 0 0 1 17.443572-25.019944 60.534186 60.534186 0 0 1 20.681447-12.503572 89.55988 89.55988 0 0 1 29.742378-3.289067A78.540867 78.540867 0 0 1 129.259044 801.79001a57.744238 57.744238 0 0 1 20.041551 46.085328 51.921182 51.921182 0 0 1-12.286008 34.887144c-4.159326 5.170362-9.470465 9.227304-15.511086 11.850879 6.7829 1.510155 12.900309 5.208756 17.45637 10.532692a57.821026 57.821026 0 0 1 17.443572 44.10165 75.136618 75.136618 0 0 1-20.028753 52.010768 76.122059 76.122059 0 0 1-59.471958 22.383571 71.962733 71.962733 0 0 1-64.629522-32.250771A97.52019 97.52019 0 0 1 1.279793 946.611331l43.308178 1.97088z" fill="#515151" p-id="2464"></path></svg>'
-                    }
-                }
-            ],
-            referencePosition: {
-                rect: {
-                    right: rect.x2 + 110,
-                    bottom: rect.y2
-                }
-            }
-        });
-    }
-    function getCellMatrix(table) {
-        return {
-            getValue: (row, col) => {
-                const value = table.getCellValue(col, row);
-                if (typeof value === 'number' || !isNaN(Number(value))) {
-                    return {
-                        v: value,
-                        t: CellValueType.NUMBER
-                    };
-                }
-                return {
-                    v: value || '',
-                    t: CellValueType.STRING
-                };
-            },
-            getMaxRows: () => {
-                return table.records.length;
-            },
-            getMaxColumns: () => {
-                return table.columns.length;
-            }
-        };
-    }
-    function isMergeCell(table, col, row) {
-        const cellRange = table.getCellRange(col, row);
-        if (cellRange.start.col !== cellRange.end.col || cellRange.start.row !== cellRange.end.row) {
-            return cellRange;
-        }
-        return null;
-    }
-
     class AutoFillManager {
         sourceData = [];
         autoFillService;
@@ -14317,9 +14562,11 @@ ${recordsStr}
         direction;
         headers;
         options;
+        formulaAdapter;
         constructor(options) {
             this.options = options;
             this.autoFillService = new AutoFillService();
+            this.formulaAdapter = new DefaultFormulaAdapter({});
         }
         setTable(table) {
             this.headers = {
@@ -14327,12 +14574,13 @@ ${recordsStr}
                 col: new Set()
             };
             this.tableInstance = table;
+            this.formulaAdapter = createFormulaAdapter(table, this.options?.isFormulaCell, this.options?.getCellFormula, this.options?.setCellFormula);
             table.on(VTable.TABLE_EVENT_TYPE.DROPDOWN_MENU_CLICK, (args) => {
                 if (args.text === '复制填充') {
-                    this.fillData(APPLY_TYPE.COPY);
+                    this.fillData(exports.APPLY_TYPE.COPY);
                 }
                 else if (args.text === '序列填充') {
-                    this.fillData(APPLY_TYPE.SERIES);
+                    this.fillData(exports.APPLY_TYPE.SERIES);
                 }
             });
             const rowHeaderCells = this.tableInstance.getAllRowHeaderCells()[0];
@@ -14370,7 +14618,7 @@ ${recordsStr}
             if (!this.sourceRange) {
                 return;
             }
-            this.direction = Direction.DOWN;
+            this.direction = exports.Direction.DOWN;
             const detectFillRange = getSelectedRangeArray(this._detectFillRange());
             this.targetRange = getTargetRange(this.direction, this.sourceRange, detectFillRange);
             this.targetRange.cols = this.targetRange.cols.filter(col => !this.headers.col.has(col));
@@ -14406,7 +14654,7 @@ ${recordsStr}
         getSourceData(source, direction) {
             const rules = this.autoFillService.getRules();
             const sourceData = [];
-            const isVertical = direction === Direction.DOWN || direction === Direction.UP;
+            const isVertical = direction === exports.Direction.DOWN || direction === exports.Direction.UP;
             let aArray;
             let bArray;
             if (isVertical) {
@@ -14426,13 +14674,25 @@ ${recordsStr}
                 };
                 bArray.forEach(b => {
                     let data;
+                    const col = isVertical ? a : b;
+                    const row = isVertical ? b : a;
                     if (isVertical) {
                         data = matrix.getValue(b, a);
                     }
                     else {
                         data = matrix.getValue(a, b);
                     }
-                    const { type, isContinue } = rules.find(r => r.match(data, null)) || otherRule;
+                    if (data && this.formulaAdapter.isFormulaCell(col, row)) {
+                        const formula = this.formulaAdapter.getCellFormula(col, row);
+                        if (formula) {
+                            data = {
+                                ...data,
+                                v: formula
+                            };
+                        }
+                    }
+                    const ruleMatch = rules.find((r) => r.match(data, null)) || otherRule;
+                    const { type, isContinue } = ruleMatch;
                     if (isContinue(prevData, data)) {
                         const typeInfo = sourceDataPiece[type];
                         const last = typeInfo[typeInfo.length - 1];
@@ -14513,14 +14773,14 @@ ${recordsStr}
             const { cols: sourceCols, rows: sourceRows } = source;
             const sourceData = this.sourceData;
             let csLen;
-            if (direction === Direction.DOWN || direction === Direction.UP) {
+            if (direction === exports.Direction.DOWN || direction === exports.Direction.UP) {
                 csLen = sourceRows.length;
             }
             else {
                 csLen = sourceCols.length;
             }
             const applyDatas = [];
-            if (direction === Direction.DOWN || direction === Direction.UP) {
+            if (direction === exports.Direction.DOWN || direction === exports.Direction.UP) {
                 const asLen = targetRows.length;
                 const untransformedApplyDatas = [];
                 targetCols.forEach((_, i) => {
@@ -14549,6 +14809,7 @@ ${recordsStr}
                 });
             }
             const values = [];
+            const formulaUpdates = [];
             targetRows.forEach((row, rowIndex) => {
                 const rowValues = [];
                 targetCols.forEach((col, colIndex) => {
@@ -14557,7 +14818,19 @@ ${recordsStr}
                         this.tableInstance.unmergeCells(range.start.col, range.start.row, range.end.col, range.end.row);
                     }
                     if (applyDatas[rowIndex][colIndex]) {
-                        rowValues.push(applyDatas[rowIndex][colIndex]?.v + '');
+                        const cellData = applyDatas[rowIndex][colIndex];
+                        const cellValue = cellData?.v + '';
+                        if (cellData && typeof cellData.v === 'string' && cellData.v.startsWith('=')) {
+                            formulaUpdates.push({
+                                col,
+                                row,
+                                formula: cellData.v
+                            });
+                            rowValues.push(cellValue);
+                        }
+                        else {
+                            rowValues.push(cellValue);
+                        }
                     }
                 });
                 values.push(rowValues);
@@ -14565,6 +14838,14 @@ ${recordsStr}
             const minRow = Math.min(...targetRows);
             const minCol = Math.min(...targetCols);
             this.tableInstance.changeCellValues(minCol, minRow, values);
+            if (formulaUpdates.length > 0) {
+                formulaUpdates.forEach(({ col, row, formula }) => {
+                    this.formulaAdapter.setCellFormula(col, row, formula);
+                });
+                if (this.formulaAdapter.hasFormulaEngine()) {
+                    this.formulaAdapter.refreshFormulas();
+                }
+            }
         }
         getApplyData(sourceDataPiece, csLen, asLen, direction, applyType, location) {
             const applyData = [];
@@ -14572,10 +14853,10 @@ ${recordsStr}
             const rsd = asLen % csLen;
             const rules = this.autoFillService.getRules();
             const applyDataInTypes = {};
-            rules.forEach(r => {
+            rules.forEach((r) => {
                 applyDataInTypes[r.type] = [];
             });
-            rules.forEach(r => {
+            rules.forEach((r) => {
                 const { type, applyFunctions: customApplyFunctions = {} } = r;
                 const copyDataInType = sourceDataPiece[type];
                 if (!copyDataInType) {
@@ -14590,7 +14871,7 @@ ${recordsStr}
                 });
             });
             for (let x = 0; x < asLen; x++) {
-                rules.forEach(r => {
+                rules.forEach((r) => {
                     const { type } = r;
                     const applyDataInType = applyDataInTypes[type];
                     for (let y = 0; y < applyDataInType.length; y++) {
@@ -14604,23 +14885,23 @@ ${recordsStr}
         }
         applyFunctions(copySquad, len, direction, applyType, customApplyFunctions, sourceDataPiece, location) {
             const { data } = copySquad;
-            const isReverse = direction === Direction.UP || direction === Direction.LEFT;
-            if (applyType === APPLY_TYPE.COPY) {
-                const custom = customApplyFunctions?.[APPLY_TYPE.COPY];
+            const isReverse = direction === exports.Direction.UP || direction === exports.Direction.LEFT;
+            if (applyType === exports.APPLY_TYPE.COPY) {
+                const custom = customApplyFunctions?.[exports.APPLY_TYPE.COPY];
                 if (custom) {
                     return custom(copySquad, len, direction, sourceDataPiece, location);
                 }
                 isReverse && data.reverse();
                 return fillCopy(data, len);
             }
-            if (applyType === APPLY_TYPE.SERIES) {
-                const custom = customApplyFunctions?.[APPLY_TYPE.SERIES];
+            if (applyType === exports.APPLY_TYPE.SERIES) {
+                const custom = customApplyFunctions?.[exports.APPLY_TYPE.SERIES];
                 if (custom) {
                     return custom(copySquad, len, direction, sourceDataPiece);
                 }
                 isReverse && data.reverse();
-                if (customApplyFunctions?.[APPLY_TYPE.COPY]) {
-                    return customApplyFunctions[APPLY_TYPE.COPY](copySquad, len, direction, sourceDataPiece, location);
+                if (customApplyFunctions?.[exports.APPLY_TYPE.COPY]) {
+                    return customApplyFunctions[exports.APPLY_TYPE.COPY](copySquad, len, direction, sourceDataPiece, location);
                 }
                 return fillCopy(data, len);
             }
@@ -14643,7 +14924,7 @@ ${recordsStr}
         }
         run(...args) {
             if (args[1] === VTable.TABLE_EVENT_TYPE.MOUSEDOWN_FILL_HANDLE) {
-                const [_, __, table] = args;
+                const [, , table] = args;
                 this.table = table;
                 this.autoFillManager.setTable(this.table);
                 this.autoFillManager.handleStartDrag(this.table?.getSelectedCellRanges()[0]);
@@ -14664,11 +14945,13 @@ ${recordsStr}
     exports.ColumnSeriesPlugin = ColumnSeriesPlugin;
     exports.ConditionFilter = ConditionFilter;
     exports.ContextMenuPlugin = ContextMenuPlugin;
+    exports.CustomFormulaAdapter = CustomFormulaAdapter;
     exports.DEFAULT_BODY_MENU_ITEMS = DEFAULT_BODY_MENU_ITEMS;
     exports.DEFAULT_COLUMN_SERIES_MENU_ITEMS = DEFAULT_COLUMN_SERIES_MENU_ITEMS;
     exports.DEFAULT_CORNER_SERIES_MENU_ITEMS = DEFAULT_CORNER_SERIES_MENU_ITEMS;
     exports.DEFAULT_HEADER_MENU_ITEMS = DEFAULT_HEADER_MENU_ITEMS;
     exports.DEFAULT_ROW_SERIES_MENU_ITEMS = DEFAULT_ROW_SERIES_MENU_ITEMS;
+    exports.DefaultFormulaAdapter = DefaultFormulaAdapter;
     exports.ExcelEditCellKeyboardPlugin = ExcelEditCellKeyboardPlugin;
     exports.ExcelImportPlugin = ExcelImportPlugin;
     exports.ExportGanttPlugin = ExportGanttPlugin;
@@ -14698,9 +14981,21 @@ ${recordsStr}
     exports.WpsFillHandlePlugin = WpsFillHandlePlugin;
     exports.applyStyles = applyStyles$1;
     exports.cancelTransform = cancelTransform;
+    exports.chnNumberRule = chnNumberRule;
+    exports.chnWeek2Rule = chnWeek2Rule;
+    exports.chnWeek3Rule = chnWeek3Rule;
     exports.createElement = createElement$1;
+    exports.createFormulaAdapter = createFormulaAdapter;
     exports.createIcon = createIcon;
     exports.createNumberInputItem = createNumberInputItem;
+    exports.dateRule = dateRule;
+    exports.enhanceCellDataWithFormula = enhanceCellDataWithFormula;
+    exports.extendNumberRule = extendNumberRule;
+    exports.formulaRule = formulaRule;
+    exports.loopSeriesRule = loopSeriesRule;
+    exports.numberRule = numberRule;
+    exports.otherRule = otherRule;
+    exports.reverseIfNeed = reverseIfNeed;
     exports.rotate90WithTransform = rotate90WithTransform;
 
 }));