@funcho/ui 1.0.0 → 1.1.1

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.5_patch_hash_415fe9eaeb4c26121ef1304c7dfbfaa75441fcd0d7ca1a8beb1acd12_87ac520f28bb40f5a8b03aa48269c150/node_modules/element-plus/es/components/table/src/store/watcher.js

@@ -0,0 +1,359 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const shared_esmBundler = require('../../../../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.js');
+const util = require('../util.js');
+const expand = require('./expand.js');
+const current = require('./current.js');
+const tree = require('./tree.js');
+const vue = require('vue');
+const castArray = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/castArray.js');
+
+//#region ../../packages/components/table/src/store/watcher.ts
+const sortData = (data, states) => {
+	const sortingColumn = states.sortingColumn;
+	if (!sortingColumn || shared_esmBundler.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() {
+	const instance = vue.getCurrentInstance();
+	const { size: tableSize } = vue.toRefs(instance.proxy?.$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 rowExpandable = 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, () => {
+		if (instance.state) {
+			scheduleLayout(false);
+			if (instance.props.tableLayout === "auto") instance.refs.tableHeaderRef?.updateFixedColumnStyle();
+		}
+	}, { deep: true });
+	const assertRowKey = () => {
+		if (!rowKey.value) throw new Error("[ElTable] prop row-key is required");
+	};
+	const updateChildFixed = (column) => {
+		column.children?.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)) {
+			if (_columns.value.indexOf(selectColumn) === 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 leafColumns = doFlattenColumns(notFixedColumns);
+		const fixedLeafColumns = doFlattenColumns(fixedColumns.value);
+		const rightFixedLeafColumns = doFlattenColumns(rightFixedColumns.value);
+		leafColumnsLength.value = leafColumns.length;
+		fixedLeafColumnsLength.value = fixedLeafColumns.length;
+		rightFixedLeafColumnsLength.value = rightFixedLeafColumns.length;
+		columns.value = Array.from(fixedLeafColumns).concat(leafColumns).concat(rightFixedLeafColumns);
+		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 = () => {
+		let deleted;
+		if (rowKey.value) {
+			deleted = [];
+			const childrenKey = instance?.store?.states?.childrenColumnName.value;
+			const dataMap = util.getKeysMap(data.value, rowKey.value, true, childrenKey);
+			for (const key in selectedMap.value) if (shared_esmBundler.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) => {
+		const treeProps = {
+			children: instance?.store?.states?.childrenColumnName.value,
+			checkStrictly: instance?.store?.states?.checkStrictly.value
+		};
+		if (util.toggleRowStatus(selection.value, row, selected, treeProps, ignoreSelectable ? void 0 : selectable.value, data.value.indexOf(row), rowKey.value)) {
+			const newSelection = (selection.value || []).slice();
+			if (emitChange) instance.emit("select", newSelection, row);
+			instance.emit("selection-change", newSelection);
+		}
+	};
+	const _toggleAllSelection = () => {
+		const value = selectOnIndeterminate.value ? !isAllSelected.value : !(isAllSelected.value || selection.value.length);
+		isAllSelected.value = value;
+		let selectionChanged = false;
+		let childrenCount = 0;
+		const rowKey = instance?.store?.states?.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, rowKey)) selectionChanged = true;
+			childrenCount += getChildrenCount(util.getRowIdentity(row, rowKey));
+		});
+		if (selectionChanged) instance.emit("selection-change", selection.value ? selection.value.slice() : []);
+		instance.emit("select-all", (selection.value || []).slice());
+	};
+	const updateAllSelected = () => {
+		if (data.value?.length === 0) {
+			isAllSelected.value = false;
+			return;
+		}
+		const { childrenColumnName } = instance.store.states;
+		let rowIndex = 0;
+		let selectedCount = 0;
+		const checkSelectedStatus = (data) => {
+			for (const row of data) {
+				const isRowSelectable = selectable.value && selectable.value.call(null, row, rowIndex);
+				if (!isSelected(row)) {
+					if (!selectable.value || isRowSelectable) return false;
+				} else selectedCount++;
+				rowIndex++;
+				if (row[childrenColumnName.value]?.length && !checkSelectedStatus(row[childrenColumnName.value])) return false;
+			}
+			return true;
+		};
+		const isAllSelected_ = checkSelectedStatus(data.value || []);
+		isAllSelected.value = selectedCount === 0 ? false : isAllSelected_;
+	};
+	const getChildrenCount = (rowKey) => {
+		if (!instance || !instance.store) return 0;
+		const { treeData } = instance.store.states;
+		let count = 0;
+		const children = treeData.value[rowKey]?.children;
+		if (children) {
+			count += children.length;
+			children.forEach((childKey) => {
+				count += getChildrenCount(childKey);
+			});
+		}
+		return count;
+	};
+	const updateFilters = (column, values) => {
+		const filters_ = {};
+		castArray.default(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 = () => {
+		data.value = sortData(filteredData.value ?? [], {
+			sortingColumn: sortingColumn.value,
+			sortProp: sortProp.value,
+			sortOrder: sortOrder.value
+		});
+	};
+	const execQuery = (ignore = void 0) => {
+		if (!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_esmBundler.isString(columnKeys)) columnKeys = [columnKeys];
+		if (shared_esmBundler.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) => {
+		if (columns.value.some(({ type }) => type === "expand")) 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,
+			rowExpandable,
+			filters,
+			filteredData,
+			sortingColumn,
+			sortProp,
+			sortOrder,
+			hoverRow,
+			...expandStates,
+			...treeStates,
+			...currentData
+		}
+	};
+}
+
+exports.default = useWatcher;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.5_patch_hash_415fe9eaeb4c26121ef1304c7dfbfaa75441fcd0d7ca1a8beb1acd12_87ac520f28bb40f5a8b03aa48269c150/node_modules/element-plus/es/components/table/src/table/defaults.js

@@ -0,0 +1,105 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const index = require('../../../../hooks/use-size/index.js');
+
+//#region ../../packages/components/table/src/table/defaults.ts
+var defaults_default = {
+	data: {
+		type: Array,
+		default: () => []
+	},
+	size: index.useSizeProp,
+	width: [String, Number],
+	height: [String, Number],
+	maxHeight: [String, Number],
+	fit: {
+		type: Boolean,
+		default: true
+	},
+	stripe: Boolean,
+	border: Boolean,
+	rowKey: [String, Function],
+	showHeader: {
+		type: Boolean,
+		default: true
+	},
+	showSummary: Boolean,
+	sumText: String,
+	summaryMethod: Function,
+	rowClassName: [String, Function],
+	rowStyle: [Object, Function],
+	cellClassName: [String, Function],
+	cellStyle: [Object, Function],
+	headerRowClassName: [String, Function],
+	headerRowStyle: [Object, Function],
+	headerCellClassName: [String, Function],
+	headerCellStyle: [Object, Function],
+	highlightCurrentRow: Boolean,
+	currentRowKey: [String, Number],
+	emptyText: String,
+	expandRowKeys: Array,
+	defaultExpandAll: Boolean,
+	rowExpandable: { type: Function },
+	defaultSort: Object,
+	tooltipEffect: String,
+	tooltipOptions: Object,
+	spanMethod: Function,
+	selectOnIndeterminate: {
+		type: Boolean,
+		default: true
+	},
+	indent: {
+		type: Number,
+		default: 16
+	},
+	treeProps: {
+		type: Object,
+		default: () => {
+			return {
+				hasChildren: "hasChildren",
+				children: "children",
+				checkStrictly: false
+			};
+		}
+	},
+	lazy: Boolean,
+	load: Function,
+	style: {
+		type: [
+			String,
+			Object,
+			Array
+		],
+		default: () => ({})
+	},
+	className: {
+		type: String,
+		default: ""
+	},
+	tableLayout: {
+		type: String,
+		default: "fixed"
+	},
+	scrollbarAlwaysOn: Boolean,
+	flexible: Boolean,
+	showOverflowTooltip: {
+		type: [Boolean, Object],
+		default: void 0
+	},
+	tooltipFormatter: Function,
+	appendFilterPanelTo: String,
+	scrollbarTabindex: {
+		type: [Number, String],
+		default: void 0
+	},
+	allowDragLastColumn: {
+		type: Boolean,
+		default: true
+	},
+	preserveExpandedContent: Boolean,
+	nativeScrollbar: Boolean
+};
+
+exports.default = defaults_default;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.5_patch_hash_415fe9eaeb4c26121ef1304c7dfbfaa75441fcd0d7ca1a8beb1acd12_87ac520f28bb40f5a8b03aa48269c150/node_modules/element-plus/es/components/table/src/table/key-render-helper.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+
+//#region ../../packages/components/table/src/table/key-render-helper.ts
+function useKeyRender(table) {
+	let observer;
+	const initWatchDom = () => {
+		const columnsWrapper = table.vnode.el.querySelector(".hidden-columns");
+		const config = {
+			childList: true,
+			subtree: true
+		};
+		const updateOrderFns = table.store.states.updateOrderFns;
+		observer = new MutationObserver(() => {
+			updateOrderFns.forEach((fn) => fn());
+		});
+		observer.observe(columnsWrapper, config);
+	};
+	vue.onMounted(() => {
+		initWatchDom();
+	});
+	vue.onUnmounted(() => {
+		observer?.disconnect();
+	});
+}
+
+exports.default = useKeyRender;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.5_patch_hash_415fe9eaeb4c26121ef1304c7dfbfaa75441fcd0d7ca1a8beb1acd12_87ac520f28bb40f5a8b03aa48269c150/node_modules/element-plus/es/components/table/src/table/style-helper.js

@@ -0,0 +1,203 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const useFormCommonProps = require('../../../form/src/hooks/use-form-common-props.js');
+const core = require('@vueuse/core');
+const vue = require('vue');
+
+//#region ../../packages/components/table/src/table/style-helper.ts
+function useStyle(props, layout, store, table) {
+	const isHidden = vue.ref(false);
+	const renderExpanded = vue.ref(null);
+	const resizeProxyVisible = vue.ref(false);
+	const setDragVisible = (visible) => {
+		resizeProxyVisible.value = visible;
+	};
+	const resizeState = vue.ref({
+		width: null,
+		height: null,
+		headerHeight: null
+	});
+	const isGroup = vue.ref(false);
+	const scrollbarViewStyle = {
+		display: "inline-block",
+		verticalAlign: "middle"
+	};
+	const tableWidth = vue.ref();
+	const tableScrollHeight = vue.ref(0);
+	const bodyScrollHeight = vue.ref(0);
+	const headerScrollHeight = vue.ref(0);
+	const footerScrollHeight = vue.ref(0);
+	const appendScrollHeight = vue.ref(0);
+	vue.watch(() => props.height, (value) => {
+		layout.setHeight(value ?? null);
+	}, { immediate: true });
+	vue.watch(() => props.maxHeight, (value) => {
+		layout.setMaxHeight(value ?? null);
+	}, { immediate: true });
+	vue.watch(() => [props.currentRowKey, store.states.rowKey], ([currentRowKey, rowKey]) => {
+		if (!vue.unref(rowKey) || !vue.unref(currentRowKey)) return;
+		store.setCurrentRowKey(`${currentRowKey}`);
+	}, { immediate: true });
+	vue.watch(() => props.data, (data) => {
+		table.store.commit("setData", data);
+	}, {
+		immediate: true,
+		deep: true
+	});
+	vue.watchEffect(() => {
+		if (props.expandRowKeys) store.setExpandRowKeysAdapter(props.expandRowKeys);
+	});
+	const handleMouseLeave = () => {
+		table.store.commit("setHoverRow", null);
+		if (table.hoverState) table.hoverState = null;
+	};
+	const handleHeaderFooterMousewheel = (_event, data) => {
+		const { pixelX, pixelY } = data;
+		if (Math.abs(pixelX) >= Math.abs(pixelY)) table.refs.bodyWrapper.scrollLeft += data.pixelX / 5;
+	};
+	const shouldUpdateHeight = vue.computed(() => {
+		return props.height || props.maxHeight || store.states.fixedColumns.value.length > 0 || store.states.rightFixedColumns.value.length > 0;
+	});
+	const tableBodyStyles = vue.computed(() => {
+		return { width: layout.bodyWidth.value ? `${layout.bodyWidth.value}px` : "" };
+	});
+	const doLayout = () => {
+		if (shouldUpdateHeight.value) layout.updateElsHeight();
+		layout.updateColumnsWidth();
+		if (typeof window === "undefined") return;
+		requestAnimationFrame(syncPosition);
+	};
+	vue.onMounted(async () => {
+		await vue.nextTick();
+		store.updateColumns();
+		bindEvents();
+		requestAnimationFrame(doLayout);
+		const el = table.vnode.el;
+		const tableHeader = table.refs.headerWrapper;
+		if (props.flexible && el && el.parentElement) el.parentElement.style.minWidth = "0";
+		resizeState.value = {
+			width: tableWidth.value = el.offsetWidth,
+			height: el.offsetHeight,
+			headerHeight: props.showHeader && tableHeader ? tableHeader.offsetHeight : null
+		};
+		store.states.columns.value.forEach((column) => {
+			if (column.filteredValue && column.filteredValue.length) table.store.commit("filterChange", {
+				column,
+				values: column.filteredValue,
+				silent: true
+			});
+		});
+		table.$ready = true;
+	});
+	const setScrollClassByEl = (el, className) => {
+		if (!el) return;
+		const classList = Array.from(el.classList).filter((item) => !item.startsWith("is-scrolling-"));
+		classList.push(layout.scrollX.value ? className : "is-scrolling-none");
+		el.className = classList.join(" ");
+	};
+	const setScrollClass = (className) => {
+		const { tableWrapper } = table.refs;
+		setScrollClassByEl(tableWrapper, className);
+	};
+	const hasScrollClass = (className) => {
+		const { tableWrapper } = table.refs;
+		return !!(tableWrapper && tableWrapper.classList.contains(className));
+	};
+	const syncPosition = function() {
+		if (!table.refs.scrollBarRef) return;
+		if (!layout.scrollX.value) {
+			const scrollingNoneClass = "is-scrolling-none";
+			if (!hasScrollClass(scrollingNoneClass)) setScrollClass(scrollingNoneClass);
+			return;
+		}
+		const scrollContainer = table.refs.scrollBarRef.wrapRef;
+		if (!scrollContainer) return;
+		const { scrollLeft, offsetWidth, scrollWidth } = scrollContainer;
+		const { headerWrapper, footerWrapper } = table.refs;
+		if (headerWrapper) headerWrapper.scrollLeft = scrollLeft;
+		if (footerWrapper) footerWrapper.scrollLeft = scrollLeft;
+		if (scrollLeft >= scrollWidth - offsetWidth - 1) setScrollClass("is-scrolling-right");
+		else if (scrollLeft === 0) setScrollClass("is-scrolling-left");
+		else setScrollClass("is-scrolling-middle");
+	};
+	const bindEvents = () => {
+		if (!table.refs.scrollBarRef) return;
+		if (table.refs.scrollBarRef.wrapRef) core.useEventListener(table.refs.scrollBarRef.wrapRef, "scroll", syncPosition, { passive: true });
+		if (props.fit) core.useResizeObserver(table.vnode.el, resizeListener);
+		else core.useEventListener(window, "resize", resizeListener);
+		core.useResizeObserver(table.refs.tableInnerWrapper, () => {
+			resizeListener();
+			table.refs?.scrollBarRef?.update();
+		});
+	};
+	const resizeListener = () => {
+		const el = table.vnode.el;
+		if (!table.$ready || !el) return;
+		let shouldUpdateLayout = false;
+		const { width: oldWidth, height: oldHeight, headerHeight: oldHeaderHeight } = resizeState.value;
+		const width = tableWidth.value = el.offsetWidth;
+		if (oldWidth !== width) shouldUpdateLayout = true;
+		const height = el.offsetHeight;
+		if ((props.height || shouldUpdateHeight.value) && oldHeight !== height) shouldUpdateLayout = true;
+		const tableHeader = props.tableLayout === "fixed" ? table.refs.headerWrapper : table.refs.tableHeaderRef?.$el;
+		if (props.showHeader && tableHeader?.offsetHeight !== oldHeaderHeight) shouldUpdateLayout = true;
+		tableScrollHeight.value = table.refs.tableWrapper?.scrollHeight || 0;
+		headerScrollHeight.value = tableHeader?.scrollHeight || 0;
+		footerScrollHeight.value = table.refs.footerWrapper?.offsetHeight || 0;
+		appendScrollHeight.value = table.refs.appendWrapper?.offsetHeight || 0;
+		bodyScrollHeight.value = tableScrollHeight.value - headerScrollHeight.value - footerScrollHeight.value - appendScrollHeight.value;
+		if (shouldUpdateLayout) {
+			resizeState.value = {
+				width,
+				height,
+				headerHeight: props.showHeader && tableHeader?.offsetHeight || 0
+			};
+			doLayout();
+		}
+	};
+	const tableSize = useFormCommonProps.useFormSize();
+	const bodyWidth = vue.computed(() => {
+		const { bodyWidth: bodyWidth_, scrollY, gutterWidth } = layout;
+		return bodyWidth_.value ? `${bodyWidth_.value - (scrollY.value ? gutterWidth : 0)}px` : "";
+	});
+	const tableLayout = vue.computed(() => {
+		if (props.maxHeight) return "fixed";
+		return props.tableLayout;
+	});
+	return {
+		isHidden,
+		renderExpanded,
+		setDragVisible,
+		isGroup,
+		handleMouseLeave,
+		handleHeaderFooterMousewheel,
+		tableSize,
+		emptyBlockStyle: vue.computed(() => {
+			if (props.data && props.data.length) return;
+			let height = "100%";
+			if (props.height && bodyScrollHeight.value) height = `${bodyScrollHeight.value}px`;
+			const width = tableWidth.value;
+			return {
+				width: width ? `${width}px` : "",
+				height
+			};
+		}),
+		resizeProxyVisible,
+		bodyWidth,
+		resizeState,
+		doLayout,
+		tableBodyStyles,
+		tableLayout,
+		scrollbarViewStyle,
+		scrollbarStyle: vue.computed(() => {
+			if (props.height) return { height: "100%" };
+			if (props.maxHeight) if (!Number.isNaN(Number(props.maxHeight))) return { maxHeight: `${+props.maxHeight - headerScrollHeight.value - footerScrollHeight.value}px` };
+			else return { maxHeight: `calc(${props.maxHeight} - ${headerScrollHeight.value + footerScrollHeight.value}px)` };
+			return {};
+		})
+	};
+}
+
+exports.default = useStyle;