@visactor/vtable-sheet 1.20.0-alpha.0

package/es/components/vtable-sheet.d.ts

@@ -0,0 +1,78 @@
+import { FormulaManager } from '../managers/formula-manager';
+import SheetManager from '../managers/sheet-manager';
+import { WorkSheet } from '../core/WorkSheet';
+import type { IVTableSheetOptions, ISheetDefine } from '../ts-types';
+import { FormulaUIManager } from '../formula/formula-ui-manager';
+export default class VTableSheet {
+    private container;
+    private options;
+    private sheetManager;
+    formulaManager: FormulaManager;
+    private eventManager;
+    private menuManager;
+    private activeWorkSheet;
+    workSheetInstances: Map<string, WorkSheet>;
+    private formulaAutocomplete;
+    formulaUIManager: FormulaUIManager;
+    private rootElement;
+    private formulaBarElement;
+    private sheetTabElement;
+    private mainMenuElement;
+    private contentElement;
+    private dragManager;
+    constructor(container: HTMLElement, options: IVTableSheetOptions);
+    private mergeDefaultOptions;
+    private initFormulaAutocomplete;
+    private initUI;
+    private createSheetTab;
+    private toggleSheetMenu;
+    private updateFadeEffects;
+    private scrollSheetTabs;
+    private _activeSheetTab;
+    updateSheetTabs(tabsContainer?: HTMLElement): void;
+    private createSheetTabItem;
+    private handleSheetTabDblClick;
+    private renameSheet;
+    private getSheetTabElementByKey;
+    updateSheetMenu(): void;
+    private activeSheetMenuItem;
+    private scrollTabIntoView;
+    private initSheets;
+    activateSheet(sheetKey: string): void;
+    addSheet(sheet: ISheetDefine): void;
+    removeSheet(sheetKey: string): void;
+    getSheetCount(): number;
+    getSheet(sheetKey: string): ISheetDefine | null;
+    getAllSheets(): ISheetDefine[];
+    private createWorkSheetInstance;
+    private restoreFilterState;
+    private _addNewSheet;
+    private updateFormulaBar;
+    getFormulaManager(): FormulaManager;
+    getSheetManager(): SheetManager;
+    getActiveSheet(): WorkSheet | null;
+    saveToConfig(): IVTableSheetOptions;
+    exportSheetToFile(fileType: 'csv' | 'xlsx'): void;
+    importFileToSheet(): void;
+    getContainer(): HTMLElement;
+    getRootElement(): HTMLElement;
+    getOptions(): IVTableSheetOptions;
+    getFormulaBarElement(): HTMLElement | null;
+    getSheetTabElement(): HTMLElement | null;
+    getContentElement(): HTMLElement;
+    release(): void;
+    exportData(sheetKey: string): any[][];
+    exportAllData(): any[][];
+    resize(): void;
+    excludeEditCellFromSelection(range: {
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+    }, editRow: number, editCol: number): {
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+    };
+}

package/es/components/vtable-sheet.js

@@ -0,0 +1,462 @@
+var __rest = this && this.__rest || function(s, e) {
+    var t = {};
+    for (var p in s) Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0 && (t[p] = s[p]);
+    if (null != s && "function" == typeof Object.getOwnPropertySymbols) {
+        var i = 0;
+        for (p = Object.getOwnPropertySymbols(s); i < p.length; i++) e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]) && (t[p[i]] = s[p[i]]);
+    }
+    return t;
+};
+
+import { FormulaManager } from "../managers/formula-manager";
+
+import SheetManager from "../managers/sheet-manager";
+
+import { WorkSheet } from "../core/WorkSheet";
+
+import * as VTable from "@visactor/vtable";
+
+import { getTablePlugins } from "../core/table-plugins";
+
+import { EventManager } from "../event/event-manager";
+
+import { showSnackbar } from "../tools/ui/snackbar";
+
+import SheetTabDragManager from "../managers/tab-drag-manager";
+
+import { checkTabTitle } from "../tools";
+
+import { FormulaAutocomplete } from "../formula/formula-autocomplete";
+
+import { formulaEditor } from "../formula/formula-editor";
+
+import { MenuManager } from "../managers/menu-manager";
+
+import { FormulaUIManager } from "../formula/formula-ui-manager";
+
+VTable.register.editor("formula", formulaEditor);
+
+export default class VTableSheet {
+    constructor(container, options) {
+        this.activeWorkSheet = null, this.workSheetInstances = new Map, this.formulaAutocomplete = null, 
+        this.formulaBarElement = null, this.sheetTabElement = null, this.mainMenuElement = null, 
+        this.container = container, this.options = this.mergeDefaultOptions(options), this.sheetManager = new SheetManager, 
+        this.formulaManager = new FormulaManager(this), this.eventManager = new EventManager(this), 
+        this.dragManager = new SheetTabDragManager(this), this.menuManager = new MenuManager(this), 
+        this.formulaUIManager = new FormulaUIManager(this), this.initUI(), this.initSheets(), 
+        this.resize();
+    }
+    mergeDefaultOptions(options) {
+        return Object.assign({
+            showFormulaBar: !0,
+            showSheetTab: !0,
+            defaultRowHeight: 25,
+            defaultColWidth: 100
+        }, options);
+    }
+    initFormulaAutocomplete() {
+        if (!this.formulaBarElement) return;
+        const formulaInput = this.formulaUIManager.formulaInput;
+        formulaInput && (this.formulaAutocomplete = new FormulaAutocomplete(this.rootElement, this), 
+        this.formulaAutocomplete.attachTo(formulaInput));
+    }
+    initUI() {
+        var _a;
+        this.rootElement = document.createElement("div"), this.rootElement.className = "vtable-sheet-container", 
+        this.container.appendChild(this.rootElement);
+        const topContainer = document.createElement("div");
+        topContainer.className = "vtable-sheet-top-container", this.rootElement.appendChild(topContainer), 
+        (null === (_a = this.options.mainMenu) || void 0 === _a ? void 0 : _a.show) && (this.mainMenuElement = this.menuManager.createMainMenu(), 
+        topContainer.appendChild(this.mainMenuElement)), this.options.showFormulaBar && (this.formulaBarElement = this.formulaUIManager.createFormulaBar(), 
+        topContainer.appendChild(this.formulaBarElement), this.initFormulaAutocomplete()), 
+        this.contentElement = document.createElement("div"), this.contentElement.className = "vtable-sheet-content", 
+        this.rootElement.appendChild(this.contentElement), this.options.showSheetTab && (this.sheetTabElement = this.createSheetTab(), 
+        this.rootElement.appendChild(this.sheetTabElement));
+    }
+    createSheetTab() {
+        const sheetTab = document.createElement("div");
+        sheetTab.className = "vtable-sheet-tab-bar";
+        const fadeLeft = document.createElement("div");
+        fadeLeft.className = "vtable-sheet-fade-left", fadeLeft.style.display = "none", 
+        sheetTab.appendChild(fadeLeft);
+        const tabsContainer = document.createElement("div");
+        tabsContainer.className = "vtable-sheet-tabs-container", tabsContainer.addEventListener("scroll", (() => this.updateFadeEffects(tabsContainer, fadeLeft, fadeRight))), 
+        sheetTab.appendChild(tabsContainer);
+        const insertIndicator = document.createElement("div");
+        insertIndicator.className = "vtable-sheet-insert-indicator", insertIndicator.style.display = "none", 
+        tabsContainer.appendChild(insertIndicator);
+        const fadeRight = document.createElement("div");
+        fadeRight.className = "vtable-sheet-fade-right", sheetTab.appendChild(fadeRight);
+        const addButton = document.createElement("button");
+        addButton.className = "vtable-sheet-add-button", addButton.innerHTML = '<svg viewBox="0 0 24 24" width="16" height="16"><path fill="currentColor" d="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6z"/></svg>', 
+        addButton.title = "添加工作表", addButton.addEventListener("click", (() => this._addNewSheet())), 
+        sheetTab.appendChild(addButton);
+        const navButtons = document.createElement("div");
+        navButtons.className = "vtable-sheet-nav-buttons";
+        const leftScrollBtn = document.createElement("button");
+        leftScrollBtn.className = "vtable-sheet-scroll-button", leftScrollBtn.innerHTML = '<svg viewBox="0 0 24 24" width="16" height="16"><path fill="currentColor" d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"/></svg>', 
+        leftScrollBtn.title = "向左滚动", leftScrollBtn.addEventListener("click", (() => this.scrollSheetTabs("left", tabsContainer))), 
+        navButtons.appendChild(leftScrollBtn);
+        const rightScrollBtn = document.createElement("button");
+        rightScrollBtn.className = "vtable-sheet-scroll-button", rightScrollBtn.innerHTML = '<svg viewBox="0 0 24 24" width="16" height="16"><path fill="currentColor" d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"/></svg>', 
+        rightScrollBtn.title = "向右滚动", rightScrollBtn.addEventListener("click", (() => this.scrollSheetTabs("right", tabsContainer))), 
+        navButtons.appendChild(rightScrollBtn);
+        const menuButton = document.createElement("button");
+        menuButton.className = "vtable-sheet-menu-button", menuButton.innerHTML = '<svg viewBox="0 0 24 24" width="16" height="16"><path fill="currentColor" d="M12 8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"/></svg>', 
+        menuButton.title = "工作表选项", menuButton.addEventListener("click", (e => this.toggleSheetMenu(e))), 
+        navButtons.appendChild(menuButton);
+        const menuContainer = document.createElement("ul");
+        return menuContainer.className = "vtable-sheet-menu-list", sheetTab.appendChild(menuContainer), 
+        sheetTab.appendChild(navButtons), setTimeout((() => {
+            this.updateFadeEffects(tabsContainer, fadeLeft, fadeRight);
+        }), 100), sheetTab;
+    }
+    toggleSheetMenu(event) {
+        var _a;
+        (null === (_a = this.sheetTabElement) || void 0 === _a ? void 0 : _a.querySelector(".vtable-sheet-menu-list")).classList.toggle("active");
+    }
+    updateFadeEffects(tabsContainer, fadeLeft, fadeRight) {
+        tabsContainer.scrollLeft > 10 ? fadeLeft.style.display = "block" : fadeLeft.style.display = "none";
+        const maxScroll = tabsContainer.scrollWidth - tabsContainer.clientWidth;
+        tabsContainer.scrollLeft < maxScroll - 10 ? fadeRight.style.display = "block" : fadeRight.style.display = "none";
+    }
+    scrollSheetTabs(direction, tabsContainer) {
+        const currentScroll = tabsContainer.scrollLeft;
+        "left" === direction ? tabsContainer.scrollTo({
+            left: Math.max(0, currentScroll - 200),
+            behavior: "smooth"
+        }) : tabsContainer.scrollTo({
+            left: currentScroll + 200,
+            behavior: "smooth"
+        });
+    }
+    _activeSheetTab() {
+        var _a;
+        const tabs = null === (_a = this.sheetTabElement) || void 0 === _a ? void 0 : _a.querySelectorAll(".vtable-sheet-tab");
+        let activeTab = null;
+        tabs.forEach((tab => {
+            var _a;
+            tab.classList.remove("active"), tab.dataset.key === (null === (_a = this.activeWorkSheet) || void 0 === _a ? void 0 : _a.getKey()) && (tab.classList.add("active"), 
+            activeTab = tab);
+        })), setTimeout((() => {
+            activeTab && activeTab.scrollIntoView({
+                behavior: "smooth",
+                block: "nearest"
+            });
+        }), 100);
+    }
+    updateSheetTabs(tabsContainer) {
+        var _a;
+        if (void 0 === tabsContainer && (tabsContainer = null === (_a = this.sheetTabElement) || void 0 === _a ? void 0 : _a.querySelector(".vtable-sheet-tabs-container")), 
+        !tabsContainer) return;
+        tabsContainer.querySelectorAll(".vtable-sheet-tab").forEach((tab => {
+            tab.remove();
+        }));
+        this.sheetManager.getAllSheets().forEach(((sheet, index) => {
+            tabsContainer.appendChild(this.createSheetTabItem(sheet, index));
+        })), this._activeSheetTab();
+    }
+    createSheetTabItem(sheet, index) {
+        const tab = document.createElement("div");
+        return tab.className = "vtable-sheet-tab", tab.dataset.key = sheet.sheetKey, tab.textContent = sheet.sheetTitle, 
+        tab.title = sheet.sheetTitle, tab.addEventListener("click", (() => this.activateSheet(sheet.sheetKey))), 
+        tab.addEventListener("dblclick", (() => this.handleSheetTabDblClick(sheet.sheetKey, sheet.sheetTitle))), 
+        tab.addEventListener("mousedown", (e => this.dragManager.handleTabMouseDown(e, sheet.sheetKey))), 
+        tab;
+    }
+    handleSheetTabDblClick(sheetKey, originalTitle) {
+        const targetTab = this.getSheetTabElementByKey(sheetKey);
+        if (!targetTab) return;
+        targetTab.setAttribute("contenteditable", "true"), targetTab.setAttribute("spellcheck", "false"), 
+        targetTab.classList.add("editing");
+        const range = document.createRange();
+        range.selectNodeContents(targetTab);
+        const selection = window.getSelection();
+        selection.removeAllRanges(), selection.addRange(range);
+        const onBlur = () => {
+            finishInput(!0);
+        }, onKeyDown = e => {
+            e.stopPropagation(), "Enter" === e.key ? (e.preventDefault(), finishInput(!0)) : "Escape" === e.key && finishInput(!1);
+        }, finishInput = commit => {
+            var _a;
+            targetTab.removeEventListener("blur", onBlur), targetTab.removeEventListener("keydown", onKeyDown), 
+            targetTab.classList.remove("editing"), targetTab.setAttribute("contenteditable", "false");
+            const newTitle = null === (_a = targetTab.textContent) || void 0 === _a ? void 0 : _a.trim();
+            commit && newTitle !== originalTitle && this.renameSheet(sheetKey, newTitle) || (targetTab.textContent = originalTitle);
+        };
+        targetTab.addEventListener("blur", onBlur), targetTab.addEventListener("keydown", onKeyDown);
+    }
+    renameSheet(sheetKey, newTitle) {
+        var _a;
+        if (!this.sheetManager.getSheet(sheetKey)) return !1;
+        const error = checkTabTitle(newTitle);
+        if (error) return showSnackbar(error, 1300), !1;
+        return this.sheetManager.getAllSheets().find((s => s.sheetKey !== sheetKey && s.sheetTitle === newTitle)) ? (showSnackbar("工作表名称已存在，请重新输入", 1300), 
+        !1) : (this.sheetManager.renameSheet(sheetKey, newTitle), null === (_a = this.workSheetInstances.get(sheetKey)) || void 0 === _a || _a.setTitle(newTitle), 
+        this.updateSheetTabs(), this.updateSheetMenu(), !0);
+    }
+    getSheetTabElementByKey(sheetKey) {
+        var _a;
+        const tabsContainer = null === (_a = this.sheetTabElement) || void 0 === _a ? void 0 : _a.querySelector(".vtable-sheet-tabs-container");
+        return null == tabsContainer ? void 0 : tabsContainer.querySelector(`.vtable-sheet-tab[data-key="${sheetKey}"]`);
+    }
+    updateSheetMenu() {
+        var _a;
+        const menuContainer = null === (_a = this.sheetTabElement) || void 0 === _a ? void 0 : _a.querySelector(".vtable-sheet-menu-list");
+        menuContainer.innerHTML = "";
+        this.sheetManager.getAllSheets().forEach((sheet => {
+            const li = document.createElement("li");
+            li.className = "vtable-sheet-menu-item", li.dataset.key = sheet.sheetKey;
+            const title = document.createElement("span");
+            title.className = "vtable-sheet-menu-item-title", title.innerText = sheet.sheetTitle, 
+            li.appendChild(title);
+            const div = document.createElement("div");
+            div.className = "vtable-sheet-menu-delete-button", div.innerHTML = '<svg class="x-icon" width="16" height="16" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M18 6L6 18" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/><path d="M6 6L18 18" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></svg>', 
+            div.addEventListener("click", (e => {
+                e.stopPropagation(), this.removeSheet(sheet.sheetKey);
+            })), li.addEventListener("click", (() => this.activateSheet(sheet.sheetKey))), li.appendChild(div), 
+            menuContainer.appendChild(li);
+        })), this.activeSheetMenuItem(), setTimeout((() => {
+            const activeItem = menuContainer.querySelector(".vtable-sheet-main-menu-item.active");
+            activeItem && activeItem.scrollIntoView({
+                behavior: "smooth",
+                block: "nearest"
+            });
+        }), 100);
+    }
+    activeSheetMenuItem() {
+        var _a;
+        const menuItems = null === (_a = this.sheetTabElement) || void 0 === _a ? void 0 : _a.querySelectorAll(".vtable-sheet-main-menu-item");
+        let activeItem = null;
+        menuItems.forEach((item => {
+            var _a;
+            item.classList.remove("active"), item.dataset.key === (null === (_a = this.activeWorkSheet) || void 0 === _a ? void 0 : _a.getKey()) && (item.classList.add("active"), 
+            activeItem = item);
+        })), setTimeout((() => {
+            activeItem && activeItem.scrollIntoView({
+                behavior: "smooth",
+                block: "nearest"
+            });
+        }), 100);
+    }
+    scrollTabIntoView(tab, container) {
+        const tabRect = tab.getBoundingClientRect(), containerRect = container.getBoundingClientRect();
+        tabRect.left < containerRect.left ? container.scrollLeft += tabRect.left - containerRect.left - 10 : tabRect.right > containerRect.right && (container.scrollLeft += tabRect.right - containerRect.right + 10);
+    }
+    initSheets() {
+        if (this.options.sheets && this.options.sheets.length > 0) {
+            this.options.sheets.forEach((sheetDefine => {
+                this.sheetManager.addSheet(sheetDefine);
+            }));
+            let activeSheetKey = "";
+            const activeSheet = this.options.sheets.find((sheet => sheet.active));
+            activeSheetKey = activeSheet ? activeSheet.sheetKey : this.options.sheets[0].sheetKey, 
+            this.activateSheet(activeSheetKey);
+        } else this._addNewSheet();
+    }
+    activateSheet(sheetKey) {
+        this.sheetManager.setActiveSheet(sheetKey);
+        const sheetDefine = this.sheetManager.getSheet(sheetKey);
+        if (sheetDefine) {
+            if (this.workSheetInstances.forEach((instance => {
+                instance.getElement().style.display = "none";
+            })), this.workSheetInstances.has(sheetKey)) {
+                const instance = this.workSheetInstances.get(sheetKey);
+                instance.getElement().style.display = "block", this.activeWorkSheet = instance, 
+                this._activeSheetTab(), this.activeSheetMenuItem(), this.restoreFilterState(instance, sheetDefine);
+            } else {
+                const instance = this.createWorkSheetInstance(sheetDefine);
+                this.workSheetInstances.set(sheetKey, instance), this.activeWorkSheet = instance, 
+                this.updateSheetTabs(), this.updateSheetMenu(), this.restoreFilterState(instance, sheetDefine);
+            }
+            this.updateFormulaBar();
+        }
+    }
+    addSheet(sheet) {
+        this.sheetManager.addSheet(sheet), this.updateSheetTabs(), this.updateSheetMenu();
+    }
+    removeSheet(sheetKey) {
+        if (this.sheetManager.getSheetCount() <= 1) return void showSnackbar("至少保留一个工作表", 1300);
+        const instance = this.workSheetInstances.get(sheetKey);
+        instance && (instance.getElement().remove(), this.workSheetInstances.delete(sheetKey));
+        const newActiveSheetKey = this.sheetManager.removeSheet(sheetKey);
+        newActiveSheetKey && this.activateSheet(newActiveSheetKey), this.updateSheetTabs(), 
+        this.updateSheetMenu();
+    }
+    getSheetCount() {
+        return this.sheetManager.getSheetCount();
+    }
+    getSheet(sheetKey) {
+        return this.sheetManager.getSheet(sheetKey);
+    }
+    getAllSheets() {
+        return this.sheetManager.getAllSheets();
+    }
+    createWorkSheetInstance(sheetDefine) {
+        var _a, _b;
+        formulaEditor.setSheet(this);
+        const contentWidth = this.contentElement.clientWidth, contentHeight = this.contentElement.clientHeight, sheet = new WorkSheet(this, Object.assign(Object.assign({}, sheetDefine), {
+            container: this.contentElement,
+            width: contentWidth,
+            height: contentHeight,
+            defaultRowHeight: this.options.defaultRowHeight,
+            defaultColWidth: this.options.defaultColWidth,
+            plugins: getTablePlugins(sheetDefine, this.options),
+            headerEditor: "formula",
+            editor: "formula",
+            select: {
+                makeSelectCellVisible: !1
+            },
+            style: {
+                borderColor: [ "#E1E4E8", "#E1E4E8", "#E1E4E8", "#E1E4E8" ],
+                borderLineWidth: [ 1, 1, 1, 1 ],
+                borderLineDash: [ null, null, null, null ],
+                padding: [ 8, 8, 8, 8 ]
+            },
+            editCellTrigger: [ "api", "keydown", "doubleclick" ],
+            customMergeCell: sheetDefine.cellMerge,
+            theme: (null === (_a = sheetDefine.theme) || void 0 === _a ? void 0 : _a.tableTheme) || (null === (_b = this.options.theme) || void 0 === _b ? void 0 : _b.tableTheme)
+        }));
+        sheet.on("cell-selected", this.eventManager.handleCellSelectedBind), sheet.on("cell-value-changed", this.eventManager.handleCellValueChangedBind), 
+        sheet.on("selection-changed", this.eventManager.handleSelectionChangedForRangeModeBind), 
+        sheet.on("selection-end", this.eventManager.handleSelectionChangedForRangeModeBind);
+        try {
+            const normalizedData = this.formulaManager.normalizeSheetData(sheetDefine.data, sheet.tableInstance);
+            this.formulaManager.addSheet(sheetDefine.sheetKey, normalizedData);
+        } catch (error) {}
+        return sheet;
+    }
+    restoreFilterState(sheet, sheetDefine) {
+        sheetDefine.filterState && setTimeout((() => {
+            if (sheet.tableInstance && sheet.tableInstance.pluginManager) {
+                const filterPlugin = sheet.tableInstance.pluginManager.getPluginByName("Filter");
+                filterPlugin && filterPlugin.setFilterState(sheetDefine.filterState);
+            }
+        }), 0);
+    }
+    _addNewSheet() {
+        const sheetCount = this.sheetManager.getSheetCount();
+        let key = `sheet${sheetCount + 1}`, title = `Sheet ${sheetCount + 1}`, index = sheetCount + 1;
+        const existingKeys = new Set(this.sheetManager.getAllSheets().map((s => s.sheetKey))), existingTitles = new Set(this.sheetManager.getAllSheets().map((s => s.sheetTitle)));
+        for (;existingKeys.has(key) || existingTitles.has(title); ) index += 1, key = `sheet${index}`, 
+        title = `Sheet ${index}`;
+        const newSheet = {
+            sheetKey: key,
+            sheetTitle: title,
+            columnCount: 20,
+            rowCount: 100,
+            data: []
+        };
+        this.sheetManager.addSheet(newSheet), this.activateSheet(key);
+    }
+    updateFormulaBar() {
+        this.formulaUIManager.updateFormulaBar();
+    }
+    getFormulaManager() {
+        return this.formulaManager;
+    }
+    getSheetManager() {
+        return this.sheetManager;
+    }
+    getActiveSheet() {
+        return this.activeWorkSheet;
+    }
+    saveToConfig() {
+        const sheets = [];
+        return this.sheetManager.getAllSheets().forEach((sheetDefine => {
+            const instance = this.workSheetInstances.get(sheetDefine.sheetKey);
+            if (instance) {
+                const data = instance.getData(), columns = instance.getColumns().map((column => {
+                    const rest = __rest(column, []);
+                    return delete rest.field, rest;
+                })), lastTitleIndex = columns.reduce(((lastIndex, column, index) => column.title ? index : lastIndex), -1);
+                -1 === lastTitleIndex ? columns.length = 0 : columns.splice(lastTitleIndex + 1);
+                const lastDataIndex = data.reduce(((lastIndex, rowData, index) => rowData ? index : lastIndex), -1);
+                -1 === lastDataIndex ? data.length = 0 : data.splice(lastDataIndex + 1);
+                let filterState = null;
+                const filterPlugin = instance.tableInstance.pluginManager.getPluginByName("Filter");
+                filterPlugin && (filterState = filterPlugin.getFilterState());
+                let sortState = instance.tableInstance.internalProps.sortState;
+                sortState = Array.isArray(sortState) ? sortState : [ sortState ];
+                const currentSortState = sortState.map((item => Object.assign({
+                    field: item.field,
+                    order: item.order
+                }, null != item.orderFn && {
+                    orderFn: item.orderFn
+                })));
+                sheets.push(Object.assign(Object.assign({}, sheetDefine), {
+                    data: data,
+                    columns: columns,
+                    cellMerge: instance.tableInstance.options.customMergeCell,
+                    showHeader: instance.tableInstance.options.showHeader,
+                    frozenRowCount: instance.tableInstance.frozenRowCount,
+                    frozenColCount: instance.tableInstance.frozenColCount,
+                    active: sheetDefine.sheetKey === this.sheetManager.getActiveSheet().sheetKey,
+                    filterState: filterState,
+                    sortState: currentSortState
+                }));
+            } else sheets.push(sheetDefine);
+        })), Object.assign(Object.assign({}, this.options), {
+            sheets: sheets
+        });
+    }
+    exportSheetToFile(fileType) {
+        var _a, _b;
+        const sheet = this.getActiveSheet();
+        sheet && ("csv" === fileType ? (null === (_a = sheet.tableInstance) || void 0 === _a ? void 0 : _a.exportToCsv) && sheet.tableInstance.exportToCsv() : (null === (_b = sheet.tableInstance) || void 0 === _b ? void 0 : _b.exportToExcel) && sheet.tableInstance.exportToExcel());
+    }
+    importFileToSheet() {
+        var _a;
+        const sheet = this.getActiveSheet();
+        sheet && (null === (_a = sheet.tableInstance) || void 0 === _a ? void 0 : _a.importFile) && sheet.tableInstance.importFile();
+    }
+    getContainer() {
+        return this.container;
+    }
+    getRootElement() {
+        return this.rootElement;
+    }
+    getOptions() {
+        return this.options;
+    }
+    getFormulaBarElement() {
+        return this.formulaBarElement;
+    }
+    getSheetTabElement() {
+        return this.sheetTabElement;
+    }
+    getContentElement() {
+        return this.contentElement;
+    }
+    release() {
+        this.eventManager.release(), this.formulaManager.release(), this.formulaUIManager.release(), 
+        this.workSheetInstances.forEach((instance => {
+            instance.release();
+        })), this.rootElement && this.rootElement.parentNode && this.rootElement.parentNode.removeChild(this.rootElement), 
+        this.formulaAutocomplete && this.formulaAutocomplete.release(), this.formulaManager.cellHighlightManager && this.formulaManager.cellHighlightManager.release();
+    }
+    exportData(sheetKey) {
+        const sheet = this.workSheetInstances.get(sheetKey);
+        return sheet ? sheet.getData() : [];
+    }
+    exportAllData() {
+        return Array.from(this.workSheetInstances.values()).map((sheet => sheet.getData()));
+    }
+    resize() {
+        var _a;
+        null === (_a = this.getActiveSheet()) || void 0 === _a || _a.resize();
+    }
+    excludeEditCellFromSelection(range, editRow, editCol) {
+        const r = Object.assign({}, range), withinRow = r.startRow <= editRow && editRow <= r.endRow, withinCol = r.startCol <= editCol && editCol <= r.endCol;
+        if (!withinRow || !withinCol) return r;
+        const rowSpan = r.endRow - r.startRow, colSpan = r.endCol - r.startCol;
+        return 0 === rowSpan && 0 === colSpan && r.startRow === editRow && r.startCol === editCol ? {
+            startRow: -1,
+            startCol: -1,
+            endRow: -1,
+            endCol: -1
+        } : (rowSpan >= colSpan ? editRow === r.startRow && r.startRow < r.endRow ? r.startRow += 1 : editRow === r.endRow && r.startRow < r.endRow ? r.endRow -= 1 : r.startRow < r.endRow && (r.startRow += 1) : editCol === r.startCol && r.startCol < r.endCol ? r.startCol += 1 : editCol === r.endCol && r.startCol < r.endCol ? r.endCol -= 1 : r.startCol < r.endCol && (r.startCol += 1), 
+        r);
+    }
+}
+//# sourceMappingURL=vtable-sheet.js.map