init

node_modules/element-plus/lib/components/table/src/store/current.d.ts

@@ -0,0 +1,15 @@
+import type { Ref } from 'vue';
+import type { DefaultRow } from '../table/defaults';
+import type { WatcherPropsData } from '.';
+declare function useCurrent<T extends DefaultRow>(watcherData: WatcherPropsData<T>): {
+    setCurrentRowKey: (key: string) => void;
+    restoreCurrentRowKey: () => void;
+    setCurrentRowByKey: (key: string) => void;
+    updateCurrentRow: (_currentRow: T) => void;
+    updateCurrentRowData: () => void;
+    states: {
+        _currentRowKey: Ref<string | null>;
+        currentRow: Ref<T | null>;
+    };
+};
+export default useCurrent;

node_modules/element-plus/lib/components/table/src/store/current.js

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var lodashUnified = require('lodash-unified');
+var util = require('../util.js');
+
+function useCurrent(watcherData) {
+  const instance = vue.getCurrentInstance();
+  const _currentRowKey = vue.ref(null);
+  const currentRow = vue.ref(null);
+  const setCurrentRowKey = (key) => {
+    instance.store.assertRowKey();
+    _currentRowKey.value = key;
+    setCurrentRowByKey(key);
+  };
+  const restoreCurrentRowKey = () => {
+    _currentRowKey.value = null;
+  };
+  const setCurrentRowByKey = (key) => {
+    var _a;
+    const { data, rowKey } = watcherData;
+    let _currentRow = null;
+    if (rowKey.value) {
+      _currentRow = (_a = (vue.unref(data) || []).find((item) => util.getRowIdentity(item, rowKey.value) === key)) != null ? _a : null;
+    }
+    currentRow.value = _currentRow != null ? _currentRow : null;
+    instance.emit("current-change", currentRow.value, null);
+  };
+  const updateCurrentRow = (_currentRow) => {
+    const oldCurrentRow = currentRow.value;
+    if (_currentRow && _currentRow !== oldCurrentRow) {
+      currentRow.value = _currentRow;
+      instance.emit("current-change", currentRow.value, oldCurrentRow);
+      return;
+    }
+    if (!_currentRow && oldCurrentRow) {
+      currentRow.value = null;
+      instance.emit("current-change", null, oldCurrentRow);
+    }
+  };
+  const updateCurrentRowData = () => {
+    const rowKey = watcherData.rowKey.value;
+    const data = watcherData.data.value || [];
+    const oldCurrentRow = currentRow.value;
+    if (oldCurrentRow && !data.includes(oldCurrentRow)) {
+      if (rowKey) {
+        const currentRowKey = util.getRowIdentity(oldCurrentRow, rowKey);
+        setCurrentRowByKey(currentRowKey);
+      } else {
+        currentRow.value = null;
+      }
+      if (lodashUnified.isNull(currentRow.value)) {
+        instance.emit("current-change", null, oldCurrentRow);
+      }
+    } else if (_currentRowKey.value) {
+      setCurrentRowByKey(_currentRowKey.value);
+      restoreCurrentRowKey();
+    }
+  };
+  return {
+    setCurrentRowKey,
+    restoreCurrentRowKey,
+    setCurrentRowByKey,
+    updateCurrentRow,
+    updateCurrentRowData,
+    states: {
+      _currentRowKey,
+      currentRow
+    }
+  };
+}
+
+exports["default"] = useCurrent;
+//# sourceMappingURL=current.js.map

node_modules/element-plus/lib/components/table/src/store/expand.d.ts

@@ -0,0 +1,14 @@
+import type { Ref } from 'vue';
+import type { WatcherPropsData } from '.';
+import type { DefaultRow } from '../table/defaults';
+declare function useExpand<T extends DefaultRow>(watcherData: WatcherPropsData<T>): {
+    updateExpandRows: () => void;
+    toggleRowExpansion: (row: T, expanded?: boolean) => void;
+    setExpandRowKeys: (rowKeys: (string | number)[]) => void;
+    isRowExpanded: (row: T) => boolean;
+    states: {
+        expandRows: Ref<T[]>;
+        defaultExpandAll: Ref<boolean>;
+    };
+};
+export default useExpand;

node_modules/element-plus/lib/components/table/src/store/expand.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var util = require('../util.js');
+
+function useExpand(watcherData) {
+  const instance = vue.getCurrentInstance();
+  const defaultExpandAll = vue.ref(false);
+  const expandRows = vue.ref([]);
+  const updateExpandRows = () => {
+    const data = watcherData.data.value || [];
+    const rowKey = watcherData.rowKey.value;
+    if (defaultExpandAll.value) {
+      expandRows.value = data.slice();
+    } else if (rowKey) {
+      const expandRowsMap = util.getKeysMap(expandRows.value, rowKey);
+      expandRows.value = data.reduce((prev, row) => {
+        const rowId = util.getRowIdentity(row, rowKey);
+        const rowInfo = expandRowsMap[rowId];
+        if (rowInfo) {
+          prev.push(row);
+        }
+        return prev;
+      }, []);
+    } else {
+      expandRows.value = [];
+    }
+  };
+  const toggleRowExpansion = (row, expanded) => {
+    const changed = util.toggleRowStatus(expandRows.value, row, expanded, void 0, void 0, void 0, watcherData.rowKey.value);
+    if (changed) {
+      instance.emit("expand-change", row, expandRows.value.slice());
+    }
+  };
+  const setExpandRowKeys = (rowKeys) => {
+    instance.store.assertRowKey();
+    const data = watcherData.data.value || [];
+    const rowKey = watcherData.rowKey.value;
+    const keysMap = util.getKeysMap(data, rowKey);
+    expandRows.value = rowKeys.reduce((prev, cur) => {
+      const info = keysMap[cur];
+      if (info) {
+        prev.push(info.row);
+      }
+      return prev;
+    }, []);
+  };
+  const isRowExpanded = (row) => {
+    const rowKey = watcherData.rowKey.value;
+    if (rowKey) {
+      const expandMap = util.getKeysMap(expandRows.value, rowKey);
+      return !!expandMap[util.getRowIdentity(row, rowKey)];
+    }
+    return expandRows.value.includes(row);
+  };
+  return {
+    updateExpandRows,
+    toggleRowExpansion,
+    setExpandRowKeys,
+    isRowExpanded,
+    states: {
+      expandRows,
+      defaultExpandAll
+    }
+  };
+}
+
+exports["default"] = useExpand;
+//# sourceMappingURL=expand.js.map

node_modules/element-plus/lib/components/table/src/store/helper.d.ts

@@ -0,0 +1,519 @@
+import type { DefaultRow, Table, TableProps } from '../table/defaults';
+export declare function createStore<T extends DefaultRow>(table: Table<T>, props: TableProps<T>): {
+    mutations: {
+        setData(states: {
+            _currentRowKey: import("vue").Ref<string | null>;
+            currentRow: import("vue").Ref<T | null>;
+            expandRowKeys: import("vue").Ref<string[]>;
+            treeData: import("vue").Ref<Record<string, import("./tree").TreeData>>;
+            indent: import("vue").Ref<number>;
+            lazy: import("vue").Ref<boolean>;
+            lazyTreeNodeMap: import("vue").Ref<Record<string, T[]>>;
+            lazyColumnIdentifier: import("vue").Ref<string>;
+            childrenColumnName: import("vue").Ref<string>;
+            checkStrictly: import("vue").Ref<boolean>;
+            expandRows: import("vue").Ref<T[]>;
+            defaultExpandAll: import("vue").Ref<boolean>;
+            tableSize: import("vue").Ref<any>;
+            rowKey: import("vue").Ref<string | null>;
+            data: import("vue").Ref<T[]>;
+            _data: import("vue").Ref<T[]>;
+            isComplex: import("vue").Ref<boolean>;
+            _columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            originColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            leafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            updateOrderFns: (() => void)[];
+            leafColumnsLength: import("vue").Ref<number>;
+            fixedLeafColumnsLength: import("vue").Ref<number>;
+            rightFixedLeafColumnsLength: import("vue").Ref<number>;
+            isAllSelected: import("vue").Ref<boolean>;
+            selection: import("vue").Ref<T[]>;
+            reserveSelection: import("vue").Ref<boolean>;
+            selectOnIndeterminate: import("vue").Ref<boolean>;
+            selectable: import("vue").Ref<((row: T, index: number) => boolean) | null>;
+            filters: import("vue").Ref<import(".").StoreFilter>;
+            filteredData: import("vue").Ref<T[] | null>;
+            sortingColumn: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T> | null>;
+            sortProp: import("vue").Ref<string | null>;
+            sortOrder: import("vue").Ref<string | number | null>;
+            hoverRow: import("vue").Ref<T | null>;
+        }, data: T[]): void;
+        insertColumn(states: {
+            _currentRowKey: import("vue").Ref<string | null>;
+            currentRow: import("vue").Ref<T | null>;
+            expandRowKeys: import("vue").Ref<string[]>;
+            treeData: import("vue").Ref<Record<string, import("./tree").TreeData>>;
+            indent: import("vue").Ref<number>;
+            lazy: import("vue").Ref<boolean>;
+            lazyTreeNodeMap: import("vue").Ref<Record<string, T[]>>;
+            lazyColumnIdentifier: import("vue").Ref<string>;
+            childrenColumnName: import("vue").Ref<string>;
+            checkStrictly: import("vue").Ref<boolean>;
+            expandRows: import("vue").Ref<T[]>;
+            defaultExpandAll: import("vue").Ref<boolean>;
+            tableSize: import("vue").Ref<any>;
+            rowKey: import("vue").Ref<string | null>;
+            data: import("vue").Ref<T[]>;
+            _data: import("vue").Ref<T[]>;
+            isComplex: import("vue").Ref<boolean>;
+            _columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            originColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            leafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            updateOrderFns: (() => void)[];
+            leafColumnsLength: import("vue").Ref<number>;
+            fixedLeafColumnsLength: import("vue").Ref<number>;
+            rightFixedLeafColumnsLength: import("vue").Ref<number>;
+            isAllSelected: import("vue").Ref<boolean>;
+            selection: import("vue").Ref<T[]>;
+            reserveSelection: import("vue").Ref<boolean>;
+            selectOnIndeterminate: import("vue").Ref<boolean>;
+            selectable: import("vue").Ref<((row: T, index: number) => boolean) | null>;
+            filters: import("vue").Ref<import(".").StoreFilter>;
+            filteredData: import("vue").Ref<T[] | null>;
+            sortingColumn: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T> | null>;
+            sortProp: import("vue").Ref<string | null>;
+            sortOrder: import("vue").Ref<string | number | null>;
+            hoverRow: import("vue").Ref<T | null>;
+        }, column: import("../table-column/defaults").TableColumnCtx<T>, parent: import("../table-column/defaults").TableColumnCtx<T>, updateColumnOrder: () => void): void;
+        updateColumnOrder(states: {
+            _currentRowKey: import("vue").Ref<string | null>;
+            currentRow: import("vue").Ref<T | null>;
+            expandRowKeys: import("vue").Ref<string[]>;
+            treeData: import("vue").Ref<Record<string, import("./tree").TreeData>>;
+            indent: import("vue").Ref<number>;
+            lazy: import("vue").Ref<boolean>;
+            lazyTreeNodeMap: import("vue").Ref<Record<string, T[]>>;
+            lazyColumnIdentifier: import("vue").Ref<string>;
+            childrenColumnName: import("vue").Ref<string>;
+            checkStrictly: import("vue").Ref<boolean>;
+            expandRows: import("vue").Ref<T[]>;
+            defaultExpandAll: import("vue").Ref<boolean>;
+            tableSize: import("vue").Ref<any>;
+            rowKey: import("vue").Ref<string | null>;
+            data: import("vue").Ref<T[]>;
+            _data: import("vue").Ref<T[]>;
+            isComplex: import("vue").Ref<boolean>;
+            _columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            originColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            leafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            updateOrderFns: (() => void)[];
+            leafColumnsLength: import("vue").Ref<number>;
+            fixedLeafColumnsLength: import("vue").Ref<number>;
+            rightFixedLeafColumnsLength: import("vue").Ref<number>;
+            isAllSelected: import("vue").Ref<boolean>;
+            selection: import("vue").Ref<T[]>;
+            reserveSelection: import("vue").Ref<boolean>;
+            selectOnIndeterminate: import("vue").Ref<boolean>;
+            selectable: import("vue").Ref<((row: T, index: number) => boolean) | null>;
+            filters: import("vue").Ref<import(".").StoreFilter>;
+            filteredData: import("vue").Ref<T[] | null>;
+            sortingColumn: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T> | null>;
+            sortProp: import("vue").Ref<string | null>;
+            sortOrder: import("vue").Ref<string | number | null>;
+            hoverRow: import("vue").Ref<T | null>;
+        }, column: import("../table-column/defaults").TableColumnCtx<T>): void;
+        removeColumn(states: {
+            _currentRowKey: import("vue").Ref<string | null>;
+            currentRow: import("vue").Ref<T | null>;
+            expandRowKeys: import("vue").Ref<string[]>;
+            treeData: import("vue").Ref<Record<string, import("./tree").TreeData>>;
+            indent: import("vue").Ref<number>;
+            lazy: import("vue").Ref<boolean>;
+            lazyTreeNodeMap: import("vue").Ref<Record<string, T[]>>;
+            lazyColumnIdentifier: import("vue").Ref<string>;
+            childrenColumnName: import("vue").Ref<string>;
+            checkStrictly: import("vue").Ref<boolean>;
+            expandRows: import("vue").Ref<T[]>;
+            defaultExpandAll: import("vue").Ref<boolean>;
+            tableSize: import("vue").Ref<any>;
+            rowKey: import("vue").Ref<string | null>;
+            data: import("vue").Ref<T[]>;
+            _data: import("vue").Ref<T[]>;
+            isComplex: import("vue").Ref<boolean>;
+            _columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            originColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            leafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            updateOrderFns: (() => void)[];
+            leafColumnsLength: import("vue").Ref<number>;
+            fixedLeafColumnsLength: import("vue").Ref<number>;
+            rightFixedLeafColumnsLength: import("vue").Ref<number>;
+            isAllSelected: import("vue").Ref<boolean>;
+            selection: import("vue").Ref<T[]>;
+            reserveSelection: import("vue").Ref<boolean>;
+            selectOnIndeterminate: import("vue").Ref<boolean>;
+            selectable: import("vue").Ref<((row: T, index: number) => boolean) | null>;
+            filters: import("vue").Ref<import(".").StoreFilter>;
+            filteredData: import("vue").Ref<T[] | null>;
+            sortingColumn: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T> | null>;
+            sortProp: import("vue").Ref<string | null>;
+            sortOrder: import("vue").Ref<string | number | null>;
+            hoverRow: import("vue").Ref<T | null>;
+        }, column: import("../table-column/defaults").TableColumnCtx<T>, parent: import("../table-column/defaults").TableColumnCtx<T>, updateColumnOrder: () => void): void;
+        sort(states: {
+            _currentRowKey: import("vue").Ref<string | null>;
+            currentRow: import("vue").Ref<T | null>;
+            expandRowKeys: import("vue").Ref<string[]>;
+            treeData: import("vue").Ref<Record<string, import("./tree").TreeData>>;
+            indent: import("vue").Ref<number>;
+            lazy: import("vue").Ref<boolean>;
+            lazyTreeNodeMap: import("vue").Ref<Record<string, T[]>>;
+            lazyColumnIdentifier: import("vue").Ref<string>;
+            childrenColumnName: import("vue").Ref<string>;
+            checkStrictly: import("vue").Ref<boolean>;
+            expandRows: import("vue").Ref<T[]>;
+            defaultExpandAll: import("vue").Ref<boolean>;
+            tableSize: import("vue").Ref<any>;
+            rowKey: import("vue").Ref<string | null>;
+            data: import("vue").Ref<T[]>;
+            _data: import("vue").Ref<T[]>;
+            isComplex: import("vue").Ref<boolean>;
+            _columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            originColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            leafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            updateOrderFns: (() => void)[];
+            leafColumnsLength: import("vue").Ref<number>;
+            fixedLeafColumnsLength: import("vue").Ref<number>;
+            rightFixedLeafColumnsLength: import("vue").Ref<number>;
+            isAllSelected: import("vue").Ref<boolean>;
+            selection: import("vue").Ref<T[]>;
+            reserveSelection: import("vue").Ref<boolean>;
+            selectOnIndeterminate: import("vue").Ref<boolean>;
+            selectable: import("vue").Ref<((row: T, index: number) => boolean) | null>;
+            filters: import("vue").Ref<import(".").StoreFilter>;
+            filteredData: import("vue").Ref<T[] | null>;
+            sortingColumn: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T> | null>;
+            sortProp: import("vue").Ref<string | null>;
+            sortOrder: import("vue").Ref<string | number | null>;
+            hoverRow: import("vue").Ref<T | null>;
+        }, options: import("../table/defaults").Sort): void;
+        changeSortCondition(states: {
+            _currentRowKey: import("vue").Ref<string | null>;
+            currentRow: import("vue").Ref<T | null>;
+            expandRowKeys: import("vue").Ref<string[]>;
+            treeData: import("vue").Ref<Record<string, import("./tree").TreeData>>;
+            indent: import("vue").Ref<number>;
+            lazy: import("vue").Ref<boolean>;
+            lazyTreeNodeMap: import("vue").Ref<Record<string, T[]>>;
+            lazyColumnIdentifier: import("vue").Ref<string>;
+            childrenColumnName: import("vue").Ref<string>;
+            checkStrictly: import("vue").Ref<boolean>;
+            expandRows: import("vue").Ref<T[]>;
+            defaultExpandAll: import("vue").Ref<boolean>;
+            tableSize: import("vue").Ref<any>;
+            rowKey: import("vue").Ref<string | null>;
+            data: import("vue").Ref<T[]>;
+            _data: import("vue").Ref<T[]>;
+            isComplex: import("vue").Ref<boolean>;
+            _columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            originColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            leafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            updateOrderFns: (() => void)[];
+            leafColumnsLength: import("vue").Ref<number>;
+            fixedLeafColumnsLength: import("vue").Ref<number>;
+            rightFixedLeafColumnsLength: import("vue").Ref<number>;
+            isAllSelected: import("vue").Ref<boolean>;
+            selection: import("vue").Ref<T[]>;
+            reserveSelection: import("vue").Ref<boolean>;
+            selectOnIndeterminate: import("vue").Ref<boolean>;
+            selectable: import("vue").Ref<((row: T, index: number) => boolean) | null>;
+            filters: import("vue").Ref<import(".").StoreFilter>;
+            filteredData: import("vue").Ref<T[] | null>;
+            sortingColumn: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T> | null>;
+            sortProp: import("vue").Ref<string | null>;
+            sortOrder: import("vue").Ref<string | number | null>;
+            hoverRow: import("vue").Ref<T | null>;
+        }, options: import("../table/defaults").Sort): void;
+        filterChange(_states: {
+            _currentRowKey: import("vue").Ref<string | null>;
+            currentRow: import("vue").Ref<T | null>;
+            expandRowKeys: import("vue").Ref<string[]>;
+            treeData: import("vue").Ref<Record<string, import("./tree").TreeData>>;
+            indent: import("vue").Ref<number>;
+            lazy: import("vue").Ref<boolean>;
+            lazyTreeNodeMap: import("vue").Ref<Record<string, T[]>>;
+            lazyColumnIdentifier: import("vue").Ref<string>;
+            childrenColumnName: import("vue").Ref<string>;
+            checkStrictly: import("vue").Ref<boolean>;
+            expandRows: import("vue").Ref<T[]>;
+            defaultExpandAll: import("vue").Ref<boolean>;
+            tableSize: import("vue").Ref<any>;
+            rowKey: import("vue").Ref<string | null>;
+            data: import("vue").Ref<T[]>;
+            _data: import("vue").Ref<T[]>;
+            isComplex: import("vue").Ref<boolean>;
+            _columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            originColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            leafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            updateOrderFns: (() => void)[];
+            leafColumnsLength: import("vue").Ref<number>;
+            fixedLeafColumnsLength: import("vue").Ref<number>;
+            rightFixedLeafColumnsLength: import("vue").Ref<number>;
+            isAllSelected: import("vue").Ref<boolean>;
+            selection: import("vue").Ref<T[]>;
+            reserveSelection: import("vue").Ref<boolean>;
+            selectOnIndeterminate: import("vue").Ref<boolean>;
+            selectable: import("vue").Ref<((row: T, index: number) => boolean) | null>;
+            filters: import("vue").Ref<import(".").StoreFilter>;
+            filteredData: import("vue").Ref<T[] | null>;
+            sortingColumn: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T> | null>;
+            sortProp: import("vue").Ref<string | null>;
+            sortOrder: import("vue").Ref<string | number | null>;
+            hoverRow: import("vue").Ref<T | null>;
+        }, options: import("../table/defaults").Filter<T>): void;
+        toggleAllSelection(): void;
+        rowSelectedChanged(_states: {
+            _currentRowKey: import("vue").Ref<string | null>;
+            currentRow: import("vue").Ref<T | null>;
+            expandRowKeys: import("vue").Ref<string[]>;
+            treeData: import("vue").Ref<Record<string, import("./tree").TreeData>>;
+            indent: import("vue").Ref<number>;
+            lazy: import("vue").Ref<boolean>;
+            lazyTreeNodeMap: import("vue").Ref<Record<string, T[]>>;
+            lazyColumnIdentifier: import("vue").Ref<string>;
+            childrenColumnName: import("vue").Ref<string>;
+            checkStrictly: import("vue").Ref<boolean>;
+            expandRows: import("vue").Ref<T[]>;
+            defaultExpandAll: import("vue").Ref<boolean>;
+            tableSize: import("vue").Ref<any>;
+            rowKey: import("vue").Ref<string | null>;
+            data: import("vue").Ref<T[]>;
+            _data: import("vue").Ref<T[]>;
+            isComplex: import("vue").Ref<boolean>;
+            _columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            originColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            leafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            updateOrderFns: (() => void)[];
+            leafColumnsLength: import("vue").Ref<number>;
+            fixedLeafColumnsLength: import("vue").Ref<number>;
+            rightFixedLeafColumnsLength: import("vue").Ref<number>;
+            isAllSelected: import("vue").Ref<boolean>;
+            selection: import("vue").Ref<T[]>;
+            reserveSelection: import("vue").Ref<boolean>;
+            selectOnIndeterminate: import("vue").Ref<boolean>;
+            selectable: import("vue").Ref<((row: T, index: number) => boolean) | null>;
+            filters: import("vue").Ref<import(".").StoreFilter>;
+            filteredData: import("vue").Ref<T[] | null>;
+            sortingColumn: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T> | null>;
+            sortProp: import("vue").Ref<string | null>;
+            sortOrder: import("vue").Ref<string | number | null>;
+            hoverRow: import("vue").Ref<T | null>;
+        }, row: T): void;
+        setHoverRow(states: {
+            _currentRowKey: import("vue").Ref<string | null>;
+            currentRow: import("vue").Ref<T | null>;
+            expandRowKeys: import("vue").Ref<string[]>;
+            treeData: import("vue").Ref<Record<string, import("./tree").TreeData>>;
+            indent: import("vue").Ref<number>;
+            lazy: import("vue").Ref<boolean>;
+            lazyTreeNodeMap: import("vue").Ref<Record<string, T[]>>;
+            lazyColumnIdentifier: import("vue").Ref<string>;
+            childrenColumnName: import("vue").Ref<string>;
+            checkStrictly: import("vue").Ref<boolean>;
+            expandRows: import("vue").Ref<T[]>;
+            defaultExpandAll: import("vue").Ref<boolean>;
+            tableSize: import("vue").Ref<any>;
+            rowKey: import("vue").Ref<string | null>;
+            data: import("vue").Ref<T[]>;
+            _data: import("vue").Ref<T[]>;
+            isComplex: import("vue").Ref<boolean>;
+            _columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            originColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            leafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            updateOrderFns: (() => void)[];
+            leafColumnsLength: import("vue").Ref<number>;
+            fixedLeafColumnsLength: import("vue").Ref<number>;
+            rightFixedLeafColumnsLength: import("vue").Ref<number>;
+            isAllSelected: import("vue").Ref<boolean>;
+            selection: import("vue").Ref<T[]>;
+            reserveSelection: import("vue").Ref<boolean>;
+            selectOnIndeterminate: import("vue").Ref<boolean>;
+            selectable: import("vue").Ref<((row: T, index: number) => boolean) | null>;
+            filters: import("vue").Ref<import(".").StoreFilter>;
+            filteredData: import("vue").Ref<T[] | null>;
+            sortingColumn: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T> | null>;
+            sortProp: import("vue").Ref<string | null>;
+            sortOrder: import("vue").Ref<string | number | null>;
+            hoverRow: import("vue").Ref<T | null>;
+        }, row: T): void;
+        setCurrentRow(_states: {
+            _currentRowKey: import("vue").Ref<string | null>;
+            currentRow: import("vue").Ref<T | null>;
+            expandRowKeys: import("vue").Ref<string[]>;
+            treeData: import("vue").Ref<Record<string, import("./tree").TreeData>>;
+            indent: import("vue").Ref<number>;
+            lazy: import("vue").Ref<boolean>;
+            lazyTreeNodeMap: import("vue").Ref<Record<string, T[]>>;
+            lazyColumnIdentifier: import("vue").Ref<string>;
+            childrenColumnName: import("vue").Ref<string>;
+            checkStrictly: import("vue").Ref<boolean>;
+            expandRows: import("vue").Ref<T[]>;
+            defaultExpandAll: import("vue").Ref<boolean>;
+            tableSize: import("vue").Ref<any>;
+            rowKey: import("vue").Ref<string | null>;
+            data: import("vue").Ref<T[]>;
+            _data: import("vue").Ref<T[]>;
+            isComplex: import("vue").Ref<boolean>;
+            _columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            originColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            leafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            fixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            rightFixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+            updateOrderFns: (() => void)[];
+            leafColumnsLength: import("vue").Ref<number>;
+            fixedLeafColumnsLength: import("vue").Ref<number>;
+            rightFixedLeafColumnsLength: import("vue").Ref<number>;
+            isAllSelected: import("vue").Ref<boolean>;
+            selection: import("vue").Ref<T[]>;
+            reserveSelection: import("vue").Ref<boolean>;
+            selectOnIndeterminate: import("vue").Ref<boolean>;
+            selectable: import("vue").Ref<((row: T, index: number) => boolean) | null>;
+            filters: import("vue").Ref<import(".").StoreFilter>;
+            filteredData: import("vue").Ref<T[] | null>;
+            sortingColumn: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T> | null>;
+            sortProp: import("vue").Ref<string | null>;
+            sortOrder: import("vue").Ref<string | number | null>;
+            hoverRow: import("vue").Ref<T | null>;
+        }, row: T): void;
+    };
+    commit: (name: "sort" | "setData" | "insertColumn" | "updateColumnOrder" | "removeColumn" | "changeSortCondition" | "filterChange" | "toggleAllSelection" | "rowSelectedChanged" | "setHoverRow" | "setCurrentRow", ...args: any[]) => void;
+    updateTableScrollY: () => void;
+    assertRowKey: () => void;
+    updateColumns: () => void;
+    scheduleLayout: (needUpdateColumns?: boolean, immediate?: boolean) => void;
+    isSelected: (row: T) => boolean;
+    clearSelection: () => void;
+    cleanSelection: () => void;
+    getSelectionRows: () => T[];
+    toggleRowSelection: (row: T, selected?: boolean, emitChange?: boolean, ignoreSelectable?: boolean) => void;
+    _toggleAllSelection: () => void;
+    toggleAllSelection: (() => void) | null;
+    updateAllSelected: () => void;
+    updateFilters: (column: import("../table-column/defaults").TableColumnCtx<T>, values: string[]) => Record<string, string[]>;
+    updateCurrentRow: (_currentRow: T) => void;
+    updateSort: (column: import("../table-column/defaults").TableColumnCtx<T> | null, prop: string | null, order: import("../table/defaults").TableSortOrder | null) => void;
+    execFilter: () => void;
+    execSort: () => void;
+    execQuery: (ignore?: {
+        filter: boolean;
+    } | undefined) => void;
+    clearFilter: (columnKeys?: string[] | string) => void;
+    clearSort: () => void;
+    toggleRowExpansion: (row: T, expanded?: boolean) => void;
+    setExpandRowKeysAdapter: (val: string[]) => void;
+    setCurrentRowKey: (key: string) => void;
+    toggleRowExpansionAdapter: (row: T, expanded?: boolean) => void;
+    isRowExpanded: (row: T) => boolean;
+    updateExpandRows: () => void;
+    updateCurrentRowData: () => void;
+    loadOrToggle: (row: T) => void;
+    updateTreeData: (ifChangeExpandRowKeys?: boolean, ifExpandAll?: boolean) => void;
+    updateKeyChildren: (key: string, data: T[]) => void;
+    states: {
+        _currentRowKey: import("vue").Ref<string | null>;
+        currentRow: import("vue").Ref<T | null>;
+        expandRowKeys: import("vue").Ref<string[]>;
+        treeData: import("vue").Ref<Record<string, import("./tree").TreeData>>;
+        indent: import("vue").Ref<number>;
+        lazy: import("vue").Ref<boolean>;
+        lazyTreeNodeMap: import("vue").Ref<Record<string, T[]>>;
+        lazyColumnIdentifier: import("vue").Ref<string>;
+        childrenColumnName: import("vue").Ref<string>;
+        checkStrictly: import("vue").Ref<boolean>;
+        expandRows: import("vue").Ref<T[]>;
+        defaultExpandAll: import("vue").Ref<boolean>;
+        tableSize: import("vue").Ref<any>;
+        rowKey: import("vue").Ref<string | null>;
+        data: import("vue").Ref<T[]>;
+        _data: import("vue").Ref<T[]>;
+        isComplex: import("vue").Ref<boolean>;
+        _columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+        originColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+        columns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+        fixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+        rightFixedColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+        leafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+        fixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+        rightFixedLeafColumns: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T>[]>;
+        updateOrderFns: (() => void)[];
+        leafColumnsLength: import("vue").Ref<number>;
+        fixedLeafColumnsLength: import("vue").Ref<number>;
+        rightFixedLeafColumnsLength: import("vue").Ref<number>;
+        isAllSelected: import("vue").Ref<boolean>;
+        selection: import("vue").Ref<T[]>;
+        reserveSelection: import("vue").Ref<boolean>;
+        selectOnIndeterminate: import("vue").Ref<boolean>;
+        selectable: import("vue").Ref<((row: T, index: number) => boolean) | null>;
+        filters: import("vue").Ref<import(".").StoreFilter>;
+        filteredData: import("vue").Ref<T[] | null>;
+        sortingColumn: import("vue").Ref<import("../table-column/defaults").TableColumnCtx<T> | null>;
+        sortProp: import("vue").Ref<string | null>;
+        sortOrder: import("vue").Ref<string | number | null>;
+        hoverRow: import("vue").Ref<T | null>;
+    };
+    ns: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+};

node_modules/element-plus/lib/components/table/src/store/helper.js

@@ -0,0 +1,72 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var lodashUnified = require('lodash-unified');
+var index = require('./index.js');
+var shared = require('@vue/shared');
+
+const InitialStateMap = {
+  rowKey: "rowKey",
+  defaultExpandAll: "defaultExpandAll",
+  selectOnIndeterminate: "selectOnIndeterminate",
+  indent: "indent",
+  lazy: "lazy",
+  data: "data",
+  ["treeProps.hasChildren"]: {
+    key: "lazyColumnIdentifier",
+    default: "hasChildren"
+  },
+  ["treeProps.children"]: {
+    key: "childrenColumnName",
+    default: "children"
+  },
+  ["treeProps.checkStrictly"]: {
+    key: "checkStrictly",
+    default: false
+  }
+};
+function createStore(table, props) {
+  if (!table) {
+    throw new Error("Table is required.");
+  }
+  const store = index["default"]();
+  store.toggleAllSelection = lodashUnified.debounce(store._toggleAllSelection, 10);
+  Object.keys(InitialStateMap).forEach((key) => {
+    handleValue(getArrKeysValue(props, key), key, store);
+  });
+  proxyTableProps(store, props);
+  return store;
+}
+function proxyTableProps(store, props) {
+  Object.keys(InitialStateMap).forEach((key) => {
+    vue.watch(() => getArrKeysValue(props, key), (value) => {
+      handleValue(value, key, store);
+    });
+  });
+}
+function handleValue(value, propsKey, store) {
+  let newVal = value;
+  let storeKey = InitialStateMap[propsKey];
+  if (shared.isObject(storeKey)) {
+    newVal = newVal || storeKey.default;
+    storeKey = storeKey.key;
+  }
+  store.states[storeKey].value = newVal;
+}
+function getArrKeysValue(props, key) {
+  if (key.includes(".")) {
+    const keyList = key.split(".");
+    let value = props;
+    keyList.forEach((k) => {
+      value = value[k];
+    });
+    return value;
+  } else {
+    return props[key];
+  }
+}
+
+exports.createStore = createStore;
+//# sourceMappingURL=helper.js.map

node_modules/element-plus/lib/components/table/src/store/helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.js","sources":["../../../../../../../packages/components/table/src/store/helper.ts"],"sourcesContent":["import { watch } from 'vue'\nimport { debounce } from 'lodash-unified'\nimport { isObject } from '@element-plus/utils'\nimport useStore from '.'\n\nimport type { Store } from '.'\nimport type { DefaultRow, Table, TableProps } from '../table/defaults'\n\nconst InitialStateMap = {\n  rowKey: 'rowKey',\n  defaultExpandAll: 'defaultExpandAll',\n  selectOnIndeterminate: 'selectOnIndeterminate',\n  indent: 'indent',\n  lazy: 'lazy',\n  data: 'data',\n  ['treeProps.hasChildren']: {\n    key: 'lazyColumnIdentifier',\n    default: 'hasChildren',\n  },\n  ['treeProps.children']: {\n    key: 'childrenColumnName',\n    default: 'children',\n  },\n  ['treeProps.checkStrictly']: {\n    key: 'checkStrictly',\n    default: false,\n  },\n}\n\nexport function createStore<T extends DefaultRow>(\n  table: Table<T>,\n  props: TableProps<T>\n) {\n  if (!table) {\n    throw new Error('Table is required.')\n  }\n\n  const store = useStore<T>()\n  // fix https://github.com/ElemeFE/element/issues/14075\n  // related pr https://github.com/ElemeFE/element/pull/14146\n  store.toggleAllSelection = debounce(store._toggleAllSelection, 10)\n  Object.keys(InitialStateMap).forEach((key) => {\n    handleValue(getArrKeysValue(props, key), key, store)\n  })\n  proxyTableProps(store, props)\n  return store\n}\n\nfunction proxyTableProps<T extends DefaultRow>(\n  store: Store<T>,\n  props: TableProps<T>\n) {\n  Object.keys(InitialStateMap).forEach((key) => {\n    watch(\n      () => getArrKeysValue(props, key),\n      (value) => {\n        handleValue(value, key, store)\n      }\n    )\n  })\n}\n\nfunction handleValue<T extends DefaultRow>(\n  value: string | boolean | Record<string, any>,\n  propsKey: string,\n  store: Store<T>\n) {\n  let newVal = value\n  let storeKey = InitialStateMap[propsKey as keyof typeof InitialStateMap]\n  if (isObject(storeKey)) {\n    newVal = newVal || storeKey.default\n    storeKey = storeKey.key\n  }\n  ;((store.states as any)[storeKey] as any).value = newVal\n}\n\nfunction getArrKeysValue<T extends DefaultRow>(\n  props: TableProps<T>,\n  key: string\n) {\n  if ((key as keyof typeof props).includes('.')) {\n    const keyList = (key as keyof typeof props).split('.')\n    let value: string | Record<string, any> = props\n    keyList.forEach((k) => {\n      value = (value as Record<string, any>)[k]\n    })\n    return value\n  } else {\n    return (props as any)[key] as boolean | string\n  }\n}\n"],"names":["useStore","debounce","watch","isObject"],"mappings":";;;;;;;;;AAIA,MAAM,eAAe,GAAG;AACxB,EAAE,MAAM,EAAE,QAAQ;AAClB,EAAE,gBAAgB,EAAE,kBAAkB;AACtC,EAAE,qBAAqB,EAAE,uBAAuB;AAChD,EAAE,MAAM,EAAE,QAAQ;AAClB,EAAE,IAAI,EAAE,MAAM;AACd,EAAE,IAAI,EAAE,MAAM;AACd,EAAE,CAAC,uBAAuB,GAAG;AAC7B,IAAI,GAAG,EAAE,sBAAsB;AAC/B,IAAI,OAAO,EAAE,aAAa;AAC1B,GAAG;AACH,EAAE,CAAC,oBAAoB,GAAG;AAC1B,IAAI,GAAG,EAAE,oBAAoB;AAC7B,IAAI,OAAO,EAAE,UAAU;AACvB,GAAG;AACH,EAAE,CAAC,yBAAyB,GAAG;AAC/B,IAAI,GAAG,EAAE,eAAe;AACxB,IAAI,OAAO,EAAE,KAAK;AAClB,GAAG;AACH,CAAC,CAAC;AACK,SAAS,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE;AAC1C,EAAE,IAAI,CAAC,KAAK,EAAE;AACd,IAAI,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;AAC1C,GAAG;AACH,EAAE,MAAM,KAAK,GAAGA,gBAAQ,EAAE,CAAC;AAC3B,EAAE,KAAK,CAAC,kBAAkB,GAAGC,sBAAQ,CAAC,KAAK,CAAC,mBAAmB,EAAE,EAAE,CAAC,CAAC;AACrE,EAAE,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,KAAK;AAChD,IAAI,WAAW,CAAC,eAAe,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AACzD,GAAG,CAAC,CAAC;AACL,EAAE,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAChC,EAAE,OAAO,KAAK,CAAC;AACf,CAAC;AACD,SAAS,eAAe,CAAC,KAAK,EAAE,KAAK,EAAE;AACvC,EAAE,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,KAAK;AAChD,IAAIC,SAAK,CAAC,MAAM,eAAe,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,KAAK;AACxD,MAAM,WAAW,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AACrC,KAAK,CAAC,CAAC;AACP,GAAG,CAAC,CAAC;AACL,CAAC;AACD,SAAS,WAAW,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE;AAC7C,EAAE,IAAI,MAAM,GAAG,KAAK,CAAC;AACrB,EAAE,IAAI,QAAQ,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAC;AAC3C,EAAE,IAAIC,eAAQ,CAAC,QAAQ,CAAC,EAAE;AAC1B,IAAI,MAAM,GAAG,MAAM,IAAI,QAAQ,CAAC,OAAO,CAAC;AACxC,IAAI,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC;AAC5B,GAAG;AAEH,EAAE,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,GAAG,MAAM,CAAC;AACxC,CAAC;AACD,SAAS,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE;AACrC,EAAE,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;AACzB,IAAI,MAAM,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AACnC,IAAI,IAAI,KAAK,GAAG,KAAK,CAAC;AACtB,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK;AAC3B,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AACvB,KAAK,CAAC,CAAC;AACP,IAAI,OAAO,KAAK,CAAC;AACjB,GAAG,MAAM;AACT,IAAI,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC;AACtB,GAAG;AACH;;;;"}

node_modules/element-plus/lib/components/table/src/store/index.js

@@ -0,0 +1,197 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var lodashUnified = require('lodash-unified');
+var watcher = require('./watcher.js');
+var index = require('../../../../hooks/use-namespace/index.js');
+
+function replaceColumn(array, column) {
+  return array.map((item) => {
+    var _a;
+    if (item.id === column.id) {
+      return column;
+    } else if ((_a = item.children) == null ? void 0 : _a.length) {
+      item.children = replaceColumn(item.children, column);
+    }
+    return item;
+  });
+}
+function sortColumn(array) {
+  array.forEach((item) => {
+    var _a, _b;
+    item.no = (_a = item.getColumnIndex) == null ? void 0 : _a.call(item);
+    if ((_b = item.children) == null ? void 0 : _b.length) {
+      sortColumn(item.children);
+    }
+  });
+  array.sort((cur, pre) => cur.no - pre.no);
+}
+function useStore() {
+  const instance = vue.getCurrentInstance();
+  const watcher$1 = watcher["default"]();
+  const ns = index.useNamespace("table");
+  const mutations = {
+    setData(states, data) {
+      const dataInstanceChanged = vue.unref(states._data) !== data;
+      states.data.value = data;
+      states._data.value = data;
+      instance.store.execQuery();
+      instance.store.updateCurrentRowData();
+      instance.store.updateExpandRows();
+      instance.store.updateTreeData(instance.store.states.defaultExpandAll.value);
+      if (vue.unref(states.reserveSelection)) {
+        instance.store.assertRowKey();
+      } else {
+        if (dataInstanceChanged) {
+          instance.store.clearSelection();
+        } else {
+          instance.store.cleanSelection();
+        }
+      }
+      instance.store.updateAllSelected();
+      if (instance.$ready) {
+        instance.store.scheduleLayout();
+      }
+    },
+    insertColumn(states, column, parent, updateColumnOrder) {
+      var _a;
+      const array = vue.unref(states._columns);
+      let newColumns = [];
+      if (!parent) {
+        array.push(column);
+        newColumns = array;
+      } else {
+        if (parent && !parent.children) {
+          parent.children = [];
+        }
+        (_a = parent.children) == null ? void 0 : _a.push(column);
+        newColumns = replaceColumn(array, parent);
+      }
+      sortColumn(newColumns);
+      states._columns.value = newColumns;
+      states.updateOrderFns.push(updateColumnOrder);
+      if (column.type === "selection") {
+        states.selectable.value = column.selectable;
+        states.reserveSelection.value = column.reserveSelection;
+      }
+      if (instance.$ready) {
+        instance.store.updateColumns();
+        instance.store.scheduleLayout();
+      }
+    },
+    updateColumnOrder(states, column) {
+      var _a;
+      const newColumnIndex = (_a = column.getColumnIndex) == null ? void 0 : _a.call(column);
+      if (newColumnIndex === column.no)
+        return;
+      sortColumn(states._columns.value);
+      if (instance.$ready) {
+        instance.store.updateColumns();
+      }
+    },
+    removeColumn(states, column, parent, updateColumnOrder) {
+      var _a;
+      const array = vue.unref(states._columns) || [];
+      if (parent) {
+        (_a = parent.children) == null ? void 0 : _a.splice(parent.children.findIndex((item) => item.id === column.id), 1);
+        vue.nextTick(() => {
+          var _a2;
+          if (((_a2 = parent.children) == null ? void 0 : _a2.length) === 0) {
+            delete parent.children;
+          }
+        });
+        states._columns.value = replaceColumn(array, parent);
+      } else {
+        const index = array.indexOf(column);
+        if (index > -1) {
+          array.splice(index, 1);
+          states._columns.value = array;
+        }
+      }
+      const updateFnIndex = states.updateOrderFns.indexOf(updateColumnOrder);
+      updateFnIndex > -1 && states.updateOrderFns.splice(updateFnIndex, 1);
+      if (instance.$ready) {
+        instance.store.updateColumns();
+        instance.store.scheduleLayout();
+      }
+    },
+    sort(states, options) {
+      const { prop, order, init } = options;
+      if (prop) {
+        const column = vue.unref(states.columns).find((column2) => column2.property === prop);
+        if (column) {
+          column.order = order;
+          instance.store.updateSort(column, prop, order);
+          instance.store.commit("changeSortCondition", { init });
+        }
+      }
+    },
+    changeSortCondition(states, options) {
+      const { sortingColumn, sortProp, sortOrder } = states;
+      const columnValue = vue.unref(sortingColumn), propValue = vue.unref(sortProp), orderValue = vue.unref(sortOrder);
+      if (lodashUnified.isNull(orderValue)) {
+        states.sortingColumn.value = null;
+        states.sortProp.value = null;
+      }
+      const ignore = { filter: true };
+      instance.store.execQuery(ignore);
+      if (!options || !(options.silent || options.init)) {
+        instance.emit("sort-change", {
+          column: columnValue,
+          prop: propValue,
+          order: orderValue
+        });
+      }
+      instance.store.updateTableScrollY();
+    },
+    filterChange(_states, options) {
+      const { column, values, silent } = options;
+      const newFilters = instance.store.updateFilters(column, values);
+      instance.store.execQuery();
+      if (!silent) {
+        instance.emit("filter-change", newFilters);
+      }
+      instance.store.updateTableScrollY();
+    },
+    toggleAllSelection() {
+      var _a, _b;
+      (_b = (_a = instance.store).toggleAllSelection) == null ? void 0 : _b.call(_a);
+    },
+    rowSelectedChanged(_states, row) {
+      instance.store.toggleRowSelection(row);
+      instance.store.updateAllSelected();
+    },
+    setHoverRow(states, row) {
+      states.hoverRow.value = row;
+    },
+    setCurrentRow(_states, row) {
+      instance.store.updateCurrentRow(row);
+    }
+  };
+  const commit = function(name, ...args) {
+    const mutations2 = instance.store.mutations;
+    if (mutations2[name]) {
+      mutations2[name].apply(instance, [
+        instance.store.states,
+        ...args
+      ]);
+    } else {
+      throw new Error(`Action not found: ${name}`);
+    }
+  };
+  const updateTableScrollY = function() {
+    vue.nextTick(() => instance.layout.updateScrollY.apply(instance.layout));
+  };
+  return {
+    ns,
+    ...watcher$1,
+    mutations,
+    commit,
+    updateTableScrollY
+  };
+}
+
+exports["default"] = useStore;
+//# sourceMappingURL=index.js.map

node_modules/element-plus/lib/components/table/src/store/tree.d.ts

@@ -0,0 +1,27 @@
+import type { WatcherPropsData } from '.';
+import type { DefaultRow, TreeNode } from '../table/defaults';
+export interface TreeData extends TreeNode {
+    children?: string[];
+    lazy?: boolean;
+    loaded?: boolean;
+}
+declare function useTree<T extends DefaultRow>(watcherData: WatcherPropsData<T>): {
+    loadData: (row: T, key: string, treeNode: TreeNode) => void;
+    loadOrToggle: (row: T) => void;
+    toggleTreeExpansion: (row: T, expanded?: boolean) => void;
+    updateTreeExpandKeys: (value: string[]) => void;
+    updateTreeData: (ifChangeExpandRowKeys?: boolean, ifExpandAll?: boolean) => void;
+    updateKeyChildren: (key: string, data: T[]) => void;
+    normalize: (data: T[]) => Record<string, TreeData>;
+    states: {
+        expandRowKeys: import("vue").Ref<string[]>;
+        treeData: import("vue").Ref<Record<string, TreeData>>;
+        indent: import("vue").Ref<number>;
+        lazy: import("vue").Ref<boolean>;
+        lazyTreeNodeMap: import("vue").Ref<Record<string, T[]>>;
+        lazyColumnIdentifier: import("vue").Ref<string>;
+        childrenColumnName: import("vue").Ref<string>;
+        checkStrictly: import("vue").Ref<boolean>;
+    };
+};
+export default useTree;

node_modules/element-plus/lib/components/table/src/store/tree.js

@@ -0,0 +1,222 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var util = require('../util.js');
+var shared = require('@vue/shared');
+var types = require('../../../../utils/types.js');
+
+function useTree(watcherData) {
+  const expandRowKeys = vue.ref([]);
+  const treeData = vue.ref({});
+  const indent = vue.ref(16);
+  const lazy = vue.ref(false);
+  const lazyTreeNodeMap = vue.ref({});
+  const lazyColumnIdentifier = vue.ref("hasChildren");
+  const childrenColumnName = vue.ref("children");
+  const checkStrictly = vue.ref(false);
+  const instance = vue.getCurrentInstance();
+  const normalizedData = vue.computed(() => {
+    if (!watcherData.rowKey.value)
+      return {};
+    const data = watcherData.data.value || [];
+    return normalize(data);
+  });
+  const normalizedLazyNode = vue.computed(() => {
+    const rowKey = watcherData.rowKey.value;
+    const keys = Object.keys(lazyTreeNodeMap.value);
+    const res = {};
+    if (!keys.length)
+      return res;
+    keys.forEach((key) => {
+      if (lazyTreeNodeMap.value[key].length) {
+        const item = { children: [] };
+        lazyTreeNodeMap.value[key].forEach((row) => {
+          const currentRowKey = util.getRowIdentity(row, rowKey);
+          item.children.push(currentRowKey);
+          if (row[lazyColumnIdentifier.value] && !res[currentRowKey]) {
+            res[currentRowKey] = { children: [] };
+          }
+        });
+        res[key] = item;
+      }
+    });
+    return res;
+  });
+  const normalize = (data) => {
+    const rowKey = watcherData.rowKey.value;
+    const res = {};
+    util.walkTreeNode(data, (parent, children, level) => {
+      const parentId = util.getRowIdentity(parent, rowKey);
+      if (shared.isArray(children)) {
+        res[parentId] = {
+          children: children.map((row) => util.getRowIdentity(row, rowKey)),
+          level
+        };
+      } else if (lazy.value) {
+        res[parentId] = {
+          children: [],
+          lazy: true,
+          level
+        };
+      }
+    }, childrenColumnName.value, lazyColumnIdentifier.value, lazy.value);
+    return res;
+  };
+  const updateTreeData = (ifChangeExpandRowKeys = false, ifExpandAll) => {
+    var _a, _b;
+    ifExpandAll || (ifExpandAll = (_a = instance.store) == null ? void 0 : _a.states.defaultExpandAll.value);
+    const nested = normalizedData.value;
+    const normalizedLazyNode_ = normalizedLazyNode.value;
+    const keys = Object.keys(nested);
+    const newTreeData = {};
+    if (keys.length) {
+      const oldTreeData = vue.unref(treeData);
+      const rootLazyRowKeys = [];
+      const getExpanded = (oldValue, key) => {
+        if (ifChangeExpandRowKeys) {
+          if (expandRowKeys.value) {
+            return ifExpandAll || expandRowKeys.value.includes(key);
+          } else {
+            return !!(ifExpandAll || (oldValue == null ? void 0 : oldValue.expanded));
+          }
+        } else {
+          const included = ifExpandAll || expandRowKeys.value && expandRowKeys.value.includes(key);
+          return !!((oldValue == null ? void 0 : oldValue.expanded) || included);
+        }
+      };
+      keys.forEach((key) => {
+        const oldValue = oldTreeData[key];
+        const newValue = { ...nested[key] };
+        newValue.expanded = getExpanded(oldValue, key);
+        if (newValue.lazy) {
+          const { loaded = false, loading = false } = oldValue || {};
+          newValue.loaded = !!loaded;
+          newValue.loading = !!loading;
+          rootLazyRowKeys.push(key);
+        }
+        newTreeData[key] = newValue;
+      });
+      const lazyKeys = Object.keys(normalizedLazyNode_);
+      if (lazy.value && lazyKeys.length && rootLazyRowKeys.length) {
+        lazyKeys.forEach((key) => {
+          var _a2;
+          const oldValue = oldTreeData[key];
+          const lazyNodeChildren = normalizedLazyNode_[key].children;
+          if (rootLazyRowKeys.includes(key)) {
+            if (((_a2 = newTreeData[key].children) == null ? void 0 : _a2.length) !== 0) {
+              throw new Error("[ElTable]children must be an empty array.");
+            }
+            newTreeData[key].children = lazyNodeChildren;
+          } else {
+            const { loaded = false, loading = false } = oldValue || {};
+            newTreeData[key] = {
+              lazy: true,
+              loaded: !!loaded,
+              loading: !!loading,
+              expanded: getExpanded(oldValue, key),
+              children: lazyNodeChildren,
+              level: void 0
+            };
+          }
+        });
+      }
+    }
+    treeData.value = newTreeData;
+    (_b = instance.store) == null ? void 0 : _b.updateTableScrollY();
+  };
+  vue.watch(() => expandRowKeys.value, () => {
+    updateTreeData(true);
+  });
+  vue.watch(() => normalizedData.value, () => {
+    updateTreeData();
+  });
+  vue.watch(() => normalizedLazyNode.value, () => {
+    updateTreeData();
+  });
+  const updateTreeExpandKeys = (value) => {
+    expandRowKeys.value = value;
+    updateTreeData();
+  };
+  const isUseLazy = (data) => {
+    return lazy.value && data && "loaded" in data && !data.loaded;
+  };
+  const toggleTreeExpansion = (row, expanded) => {
+    instance.store.assertRowKey();
+    const rowKey = watcherData.rowKey.value;
+    const id = util.getRowIdentity(row, rowKey);
+    const data = id && treeData.value[id];
+    if (id && data && "expanded" in data) {
+      const oldExpanded = data.expanded;
+      expanded = types.isUndefined(expanded) ? !data.expanded : expanded;
+      treeData.value[id].expanded = expanded;
+      if (oldExpanded !== expanded) {
+        instance.emit("expand-change", row, expanded);
+      }
+      isUseLazy(data) && loadData(row, id, data);
+      instance.store.updateTableScrollY();
+    }
+  };
+  const loadOrToggle = (row) => {
+    instance.store.assertRowKey();
+    const rowKey = watcherData.rowKey.value;
+    const id = util.getRowIdentity(row, rowKey);
+    const data = treeData.value[id];
+    if (isUseLazy(data)) {
+      loadData(row, id, data);
+    } else {
+      toggleTreeExpansion(row, void 0);
+    }
+  };
+  const loadData = (row, key, treeNode) => {
+    const { load } = instance.props;
+    if (load && !treeData.value[key].loaded) {
+      treeData.value[key].loading = true;
+      load(row, treeNode, (data) => {
+        if (!shared.isArray(data)) {
+          throw new TypeError("[ElTable] data must be an array");
+        }
+        treeData.value[key].loading = false;
+        treeData.value[key].loaded = true;
+        treeData.value[key].expanded = true;
+        if (data.length) {
+          lazyTreeNodeMap.value[key] = data;
+        }
+        instance.emit("expand-change", row, true);
+      });
+    }
+  };
+  const updateKeyChildren = (key, data) => {
+    const { lazy: lazy2, rowKey } = instance.props;
+    if (!lazy2)
+      return;
+    if (!rowKey)
+      throw new Error("[Table] rowKey is required in updateKeyChild");
+    if (lazyTreeNodeMap.value[key]) {
+      lazyTreeNodeMap.value[key] = data;
+    }
+  };
+  return {
+    loadData,
+    loadOrToggle,
+    toggleTreeExpansion,
+    updateTreeExpandKeys,
+    updateTreeData,
+    updateKeyChildren,
+    normalize,
+    states: {
+      expandRowKeys,
+      treeData,
+      indent,
+      lazy,
+      lazyTreeNodeMap,
+      lazyColumnIdentifier,
+      childrenColumnName,
+      checkStrictly
+    }
+  };
+}
+
+exports["default"] = useTree;
+//# sourceMappingURL=tree.js.map

node_modules/element-plus/lib/components/table/src/store/watcher.d.ts

@@ -0,0 +1,80 @@
+import type { Ref } from 'vue';
+import type { TableColumnCtx } from '../table-column/defaults';
+import type { DefaultRow, TableSortOrder } from '../table/defaults';
+import type { StoreFilter } from '.';
+declare function useWatcher<T extends DefaultRow>(): {
+    assertRowKey: () => void;
+    updateColumns: () => void;
+    scheduleLayout: (needUpdateColumns?: boolean, immediate?: boolean) => void;
+    isSelected: (row: T) => boolean;
+    clearSelection: () => void;
+    cleanSelection: () => void;
+    getSelectionRows: () => T[];
+    toggleRowSelection: (row: T, selected?: boolean, emitChange?: boolean, ignoreSelectable?: boolean) => void;
+    _toggleAllSelection: () => void;
+    toggleAllSelection: (() => void) | null;
+    updateAllSelected: () => void;
+    updateFilters: (column: TableColumnCtx<T>, values: string[]) => Record<string, string[]>;
+    updateCurrentRow: (_currentRow: T) => void;
+    updateSort: (column: TableColumnCtx<T> | null, prop: string | null, order: TableSortOrder | null) => void;
+    execFilter: () => void;
+    execSort: () => void;
+    execQuery: (ignore?: {
+        filter: boolean;
+    } | undefined) => void;
+    clearFilter: (columnKeys?: string[] | string) => void;
+    clearSort: () => void;
+    toggleRowExpansion: (row: T, expanded?: boolean) => void;
+    setExpandRowKeysAdapter: (val: string[]) => void;
+    setCurrentRowKey: (key: string) => void;
+    toggleRowExpansionAdapter: (row: T, expanded?: boolean) => void;
+    isRowExpanded: (row: T) => boolean;
+    updateExpandRows: () => void;
+    updateCurrentRowData: () => void;
+    loadOrToggle: (row: T) => void;
+    updateTreeData: (ifChangeExpandRowKeys?: boolean, ifExpandAll?: boolean) => void;
+    updateKeyChildren: (key: string, data: T[]) => void;
+    states: {
+        _currentRowKey: Ref<string | null>;
+        currentRow: Ref<T | null>;
+        expandRowKeys: Ref<string[]>;
+        treeData: Ref<Record<string, import("./tree").TreeData>>;
+        indent: Ref<number>;
+        lazy: Ref<boolean>;
+        lazyTreeNodeMap: Ref<Record<string, T[]>>;
+        lazyColumnIdentifier: Ref<string>;
+        childrenColumnName: Ref<string>;
+        checkStrictly: Ref<boolean>;
+        expandRows: Ref<T[]>;
+        defaultExpandAll: Ref<boolean>;
+        tableSize: Ref<any>;
+        rowKey: Ref<string | null>;
+        data: Ref<T[]>;
+        _data: Ref<T[]>;
+        isComplex: Ref<boolean>;
+        _columns: Ref<TableColumnCtx<T>[]>;
+        originColumns: Ref<TableColumnCtx<T>[]>;
+        columns: Ref<TableColumnCtx<T>[]>;
+        fixedColumns: Ref<TableColumnCtx<T>[]>;
+        rightFixedColumns: Ref<TableColumnCtx<T>[]>;
+        leafColumns: Ref<TableColumnCtx<T>[]>;
+        fixedLeafColumns: Ref<TableColumnCtx<T>[]>;
+        rightFixedLeafColumns: Ref<TableColumnCtx<T>[]>;
+        updateOrderFns: (() => void)[];
+        leafColumnsLength: Ref<number>;
+        fixedLeafColumnsLength: Ref<number>;
+        rightFixedLeafColumnsLength: Ref<number>;
+        isAllSelected: Ref<boolean>;
+        selection: Ref<T[]>;
+        reserveSelection: Ref<boolean>;
+        selectOnIndeterminate: Ref<boolean>;
+        selectable: Ref<((row: T, index: number) => boolean) | null>;
+        filters: Ref<StoreFilter>;
+        filteredData: Ref<T[] | null>;
+        sortingColumn: Ref<TableColumnCtx<T> | null>;
+        sortProp: Ref<string | null>;
+        sortOrder: Ref<string | number | null>;
+        hoverRow: Ref<T | null>;
+    };
+};
+export default useWatcher;

node_modules/element-plus/lib/components/table/src/store/watcher.js

@@ -0,0 +1,453 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var util = require('../util.js');
+var expand = require('./expand.js');
+var current = require('./current.js');
+var tree = require('./tree.js');
+var shared = require('@vue/shared');
+var lodashUnified = require('lodash-unified');
+
+const sortData = (data, states) => {
+  const sortingColumn = states.sortingColumn;
+  if (!sortingColumn || shared.isString(sortingColumn.sortable)) {
+    return data;
+  }
+  return util.orderBy(data, states.sortProp, states.sortOrder, sortingColumn.sortMethod, sortingColumn.sortBy);
+};
+const doFlattenColumns = (columns) => {
+  const result = [];
+  columns.forEach((column) => {
+    if (column.children && column.children.length > 0) {
+      result.push.apply(result, doFlattenColumns(column.children));
+    } else {
+      result.push(column);
+    }
+  });
+  return result;
+};
+function useWatcher() {
+  var _a;
+  const instance = vue.getCurrentInstance();
+  const { size: tableSize } = vue.toRefs((_a = instance.proxy) == null ? void 0 : _a.$props);
+  const rowKey = vue.ref(null);
+  const data = vue.ref([]);
+  const _data = vue.ref([]);
+  const isComplex = vue.ref(false);
+  const _columns = vue.ref([]);
+  const originColumns = vue.ref([]);
+  const columns = vue.ref([]);
+  const fixedColumns = vue.ref([]);
+  const rightFixedColumns = vue.ref([]);
+  const leafColumns = vue.ref([]);
+  const fixedLeafColumns = vue.ref([]);
+  const rightFixedLeafColumns = vue.ref([]);
+  const updateOrderFns = [];
+  const leafColumnsLength = vue.ref(0);
+  const fixedLeafColumnsLength = vue.ref(0);
+  const rightFixedLeafColumnsLength = vue.ref(0);
+  const isAllSelected = vue.ref(false);
+  const selection = vue.ref([]);
+  const reserveSelection = vue.ref(false);
+  const selectOnIndeterminate = vue.ref(false);
+  const selectable = vue.ref(null);
+  const filters = vue.ref({});
+  const filteredData = vue.ref(null);
+  const sortingColumn = vue.ref(null);
+  const sortProp = vue.ref(null);
+  const sortOrder = vue.ref(null);
+  const hoverRow = vue.ref(null);
+  const selectedMap = vue.computed(() => {
+    return rowKey.value ? util.getKeysMap(selection.value, rowKey.value) : void 0;
+  });
+  vue.watch(data, () => {
+    var _a2;
+    if (instance.state) {
+      scheduleLayout(false);
+      const needUpdateFixed = instance.props.tableLayout === "auto";
+      if (needUpdateFixed) {
+        (_a2 = instance.refs.tableHeaderRef) == null ? void 0 : _a2.updateFixedColumnStyle();
+      }
+    }
+  }, {
+    deep: true
+  });
+  const assertRowKey = () => {
+    if (!rowKey.value)
+      throw new Error("[ElTable] prop row-key is required");
+  };
+  const updateChildFixed = (column) => {
+    var _a2;
+    (_a2 = column.children) == null ? void 0 : _a2.forEach((childColumn) => {
+      childColumn.fixed = column.fixed;
+      updateChildFixed(childColumn);
+    });
+  };
+  const updateColumns = () => {
+    _columns.value.forEach((column) => {
+      updateChildFixed(column);
+    });
+    fixedColumns.value = _columns.value.filter((column) => [true, "left"].includes(column.fixed));
+    const selectColumn = _columns.value.find((column) => column.type === "selection");
+    let selectColFixLeft;
+    if (selectColumn && selectColumn.fixed !== "right" && !fixedColumns.value.includes(selectColumn)) {
+      const selectColumnIndex = _columns.value.indexOf(selectColumn);
+      if (selectColumnIndex === 0 && fixedColumns.value.length) {
+        fixedColumns.value.unshift(selectColumn);
+        selectColFixLeft = true;
+      }
+    }
+    rightFixedColumns.value = _columns.value.filter((column) => column.fixed === "right");
+    const notFixedColumns = _columns.value.filter((column) => (selectColFixLeft ? column.type !== "selection" : true) && !column.fixed);
+    originColumns.value = Array.from(fixedColumns.value).concat(notFixedColumns).concat(rightFixedColumns.value);
+    const leafColumns2 = doFlattenColumns(notFixedColumns);
+    const fixedLeafColumns2 = doFlattenColumns(fixedColumns.value);
+    const rightFixedLeafColumns2 = doFlattenColumns(rightFixedColumns.value);
+    leafColumnsLength.value = leafColumns2.length;
+    fixedLeafColumnsLength.value = fixedLeafColumns2.length;
+    rightFixedLeafColumnsLength.value = rightFixedLeafColumns2.length;
+    columns.value = Array.from(fixedLeafColumns2).concat(leafColumns2).concat(rightFixedLeafColumns2);
+    isComplex.value = fixedColumns.value.length > 0 || rightFixedColumns.value.length > 0;
+  };
+  const scheduleLayout = (needUpdateColumns, immediate = false) => {
+    if (needUpdateColumns) {
+      updateColumns();
+    }
+    if (immediate) {
+      instance.state.doLayout();
+    } else {
+      instance.state.debouncedUpdateLayout();
+    }
+  };
+  const isSelected = (row) => {
+    if (selectedMap.value) {
+      return !!selectedMap.value[util.getRowIdentity(row, rowKey.value)];
+    } else {
+      return selection.value.includes(row);
+    }
+  };
+  const clearSelection = () => {
+    isAllSelected.value = false;
+    const oldSelection = selection.value;
+    selection.value = [];
+    if (oldSelection.length) {
+      instance.emit("selection-change", []);
+    }
+  };
+  const cleanSelection = () => {
+    var _a2, _b;
+    let deleted;
+    if (rowKey.value) {
+      deleted = [];
+      const childrenKey = (_b = (_a2 = instance == null ? void 0 : instance.store) == null ? void 0 : _a2.states) == null ? void 0 : _b.childrenColumnName.value;
+      const dataMap = util.getKeysMap(data.value, rowKey.value, true, childrenKey);
+      for (const key in selectedMap.value) {
+        if (shared.hasOwn(selectedMap.value, key) && !dataMap[key]) {
+          deleted.push(selectedMap.value[key].row);
+        }
+      }
+    } else {
+      deleted = selection.value.filter((item) => !data.value.includes(item));
+    }
+    if (deleted.length) {
+      const newSelection = selection.value.filter((item) => !deleted.includes(item));
+      selection.value = newSelection;
+      instance.emit("selection-change", newSelection.slice());
+    }
+  };
+  const getSelectionRows = () => {
+    return (selection.value || []).slice();
+  };
+  const toggleRowSelection = (row, selected, emitChange = true, ignoreSelectable = false) => {
+    var _a2, _b, _c, _d;
+    const treeProps = {
+      children: (_b = (_a2 = instance == null ? void 0 : instance.store) == null ? void 0 : _a2.states) == null ? void 0 : _b.childrenColumnName.value,
+      checkStrictly: (_d = (_c = instance == null ? void 0 : instance.store) == null ? void 0 : _c.states) == null ? void 0 : _d.checkStrictly.value
+    };
+    const changed = util.toggleRowStatus(selection.value, row, selected, treeProps, ignoreSelectable ? void 0 : selectable.value, data.value.indexOf(row), rowKey.value);
+    if (changed) {
+      const newSelection = (selection.value || []).slice();
+      if (emitChange) {
+        instance.emit("select", newSelection, row);
+      }
+      instance.emit("selection-change", newSelection);
+    }
+  };
+  const _toggleAllSelection = () => {
+    var _a2, _b;
+    const value = selectOnIndeterminate.value ? !isAllSelected.value : !(isAllSelected.value || selection.value.length);
+    isAllSelected.value = value;
+    let selectionChanged = false;
+    let childrenCount = 0;
+    const rowKey2 = (_b = (_a2 = instance == null ? void 0 : instance.store) == null ? void 0 : _a2.states) == null ? void 0 : _b.rowKey.value;
+    const { childrenColumnName } = instance.store.states;
+    const treeProps = {
+      children: childrenColumnName.value,
+      checkStrictly: false
+    };
+    data.value.forEach((row, index) => {
+      const rowIndex = index + childrenCount;
+      if (util.toggleRowStatus(selection.value, row, value, treeProps, selectable.value, rowIndex, rowKey2)) {
+        selectionChanged = true;
+      }
+      childrenCount += getChildrenCount(util.getRowIdentity(row, rowKey2));
+    });
+    if (selectionChanged) {
+      instance.emit("selection-change", selection.value ? selection.value.slice() : []);
+    }
+    instance.emit("select-all", (selection.value || []).slice());
+  };
+  const updateAllSelected = () => {
+    var _a2;
+    if (((_a2 = data.value) == null ? void 0 : _a2.length) === 0) {
+      isAllSelected.value = false;
+      return;
+    }
+    const { childrenColumnName } = instance.store.states;
+    let rowIndex = 0;
+    let selectedCount = 0;
+    const checkSelectedStatus = (data2) => {
+      var _a3;
+      for (const row of data2) {
+        const isRowSelectable = selectable.value && selectable.value.call(null, row, rowIndex);
+        if (!isSelected(row)) {
+          if (!selectable.value || isRowSelectable) {
+            return false;
+          }
+        } else {
+          selectedCount++;
+        }
+        rowIndex++;
+        if (((_a3 = row[childrenColumnName.value]) == null ? void 0 : _a3.length) && !checkSelectedStatus(row[childrenColumnName.value])) {
+          return false;
+        }
+      }
+      return true;
+    };
+    const isAllSelected_ = checkSelectedStatus(data.value || []);
+    isAllSelected.value = selectedCount === 0 ? false : isAllSelected_;
+  };
+  const getChildrenCount = (rowKey2) => {
+    var _a2;
+    if (!instance || !instance.store)
+      return 0;
+    const { treeData } = instance.store.states;
+    let count = 0;
+    const children = (_a2 = treeData.value[rowKey2]) == null ? void 0 : _a2.children;
+    if (children) {
+      count += children.length;
+      children.forEach((childKey) => {
+        count += getChildrenCount(childKey);
+      });
+    }
+    return count;
+  };
+  const updateFilters = (column, values) => {
+    const filters_ = {};
+    lodashUnified.castArray(column).forEach((col) => {
+      filters.value[col.id] = values;
+      filters_[col.columnKey || col.id] = values;
+    });
+    return filters_;
+  };
+  const updateSort = (column, prop, order) => {
+    if (sortingColumn.value && sortingColumn.value !== column) {
+      sortingColumn.value.order = null;
+    }
+    sortingColumn.value = column;
+    sortProp.value = prop;
+    sortOrder.value = order;
+  };
+  const execFilter = () => {
+    let sourceData = vue.unref(_data);
+    Object.keys(filters.value).forEach((columnId) => {
+      const values = filters.value[columnId];
+      if (!values || values.length === 0)
+        return;
+      const column = util.getColumnById({
+        columns: columns.value
+      }, columnId);
+      if (column && column.filterMethod) {
+        sourceData = sourceData.filter((row) => {
+          return values.some((value) => column.filterMethod.call(null, value, row, column));
+        });
+      }
+    });
+    filteredData.value = sourceData;
+  };
+  const execSort = () => {
+    var _a2;
+    data.value = sortData((_a2 = filteredData.value) != null ? _a2 : [], {
+      sortingColumn: sortingColumn.value,
+      sortProp: sortProp.value,
+      sortOrder: sortOrder.value
+    });
+  };
+  const execQuery = (ignore = void 0) => {
+    if (!(ignore == null ? void 0 : ignore.filter)) {
+      execFilter();
+    }
+    execSort();
+  };
+  const clearFilter = (columnKeys) => {
+    const { tableHeaderRef } = instance.refs;
+    if (!tableHeaderRef)
+      return;
+    const panels = Object.assign({}, tableHeaderRef.filterPanels);
+    const keys = Object.keys(panels);
+    if (!keys.length)
+      return;
+    if (shared.isString(columnKeys)) {
+      columnKeys = [columnKeys];
+    }
+    if (shared.isArray(columnKeys)) {
+      const columns_ = columnKeys.map((key) => util.getColumnByKey({
+        columns: columns.value
+      }, key));
+      keys.forEach((key) => {
+        const column = columns_.find((col) => col.id === key);
+        if (column) {
+          column.filteredValue = [];
+        }
+      });
+      instance.store.commit("filterChange", {
+        column: columns_,
+        values: [],
+        silent: true,
+        multi: true
+      });
+    } else {
+      keys.forEach((key) => {
+        const column = columns.value.find((col) => col.id === key);
+        if (column) {
+          column.filteredValue = [];
+        }
+      });
+      filters.value = {};
+      instance.store.commit("filterChange", {
+        column: {},
+        values: [],
+        silent: true
+      });
+    }
+  };
+  const clearSort = () => {
+    if (!sortingColumn.value)
+      return;
+    updateSort(null, null, null);
+    instance.store.commit("changeSortCondition", {
+      silent: true
+    });
+  };
+  const {
+    setExpandRowKeys,
+    toggleRowExpansion,
+    updateExpandRows,
+    states: expandStates,
+    isRowExpanded
+  } = expand["default"]({
+    data,
+    rowKey
+  });
+  const {
+    updateTreeExpandKeys,
+    toggleTreeExpansion,
+    updateTreeData,
+    updateKeyChildren,
+    loadOrToggle,
+    states: treeStates
+  } = tree["default"]({
+    data,
+    rowKey
+  });
+  const {
+    updateCurrentRowData,
+    updateCurrentRow,
+    setCurrentRowKey,
+    states: currentData
+  } = current["default"]({
+    data,
+    rowKey
+  });
+  const setExpandRowKeysAdapter = (val) => {
+    setExpandRowKeys(val);
+    updateTreeExpandKeys(val);
+  };
+  const toggleRowExpansionAdapter = (row, expanded) => {
+    const hasExpandColumn = columns.value.some(({ type }) => type === "expand");
+    if (hasExpandColumn) {
+      toggleRowExpansion(row, expanded);
+    } else {
+      toggleTreeExpansion(row, expanded);
+    }
+  };
+  return {
+    assertRowKey,
+    updateColumns,
+    scheduleLayout,
+    isSelected,
+    clearSelection,
+    cleanSelection,
+    getSelectionRows,
+    toggleRowSelection,
+    _toggleAllSelection,
+    toggleAllSelection: null,
+    updateAllSelected,
+    updateFilters,
+    updateCurrentRow,
+    updateSort,
+    execFilter,
+    execSort,
+    execQuery,
+    clearFilter,
+    clearSort,
+    toggleRowExpansion,
+    setExpandRowKeysAdapter,
+    setCurrentRowKey,
+    toggleRowExpansionAdapter,
+    isRowExpanded,
+    updateExpandRows,
+    updateCurrentRowData,
+    loadOrToggle,
+    updateTreeData,
+    updateKeyChildren,
+    states: {
+      tableSize,
+      rowKey,
+      data,
+      _data,
+      isComplex,
+      _columns,
+      originColumns,
+      columns,
+      fixedColumns,
+      rightFixedColumns,
+      leafColumns,
+      fixedLeafColumns,
+      rightFixedLeafColumns,
+      updateOrderFns,
+      leafColumnsLength,
+      fixedLeafColumnsLength,
+      rightFixedLeafColumnsLength,
+      isAllSelected,
+      selection,
+      reserveSelection,
+      selectOnIndeterminate,
+      selectable,
+      filters,
+      filteredData,
+      sortingColumn,
+      sortProp,
+      sortOrder,
+      hoverRow,
+      ...expandStates,
+      ...treeStates,
+      ...currentData
+    }
+  };
+}
+
+exports["default"] = useWatcher;
+//# sourceMappingURL=watcher.js.map