@atscript/vue-table 0.1.58

package/dist/as-table-status-DWYoJIMC.cjs

@@ -0,0 +1,724 @@
+const require_use_table_state = require("./use-table-state-MU-vuzui.cjs");
+const require_as_table_cell_value = require("./as-table-cell-value-CuxRtFn9.cjs");
+const require_as_table_header_cell = require("./as-table-header-cell-C3zeZUZo.cjs");
+let _atscript_ui = require("@atscript/ui");
+let vue = require("vue");
+let _atscript_ui_table = require("@atscript/ui-table");
+//#region src/composables/use-table-selection.ts
+/**
+* Renderer-owned cleanup for the `select` prop transition. Dropping into
+* `'none'` clears `selectedRows` so the next opt-in to multi-mode starts
+* clean; other transitions are no-ops (`'none' → 'multi'` already has an
+* empty selection, `'multi' → 'multi'` doesn't change semantics). The
+* getter is invoked once per change — NOT immediate, so the mount-time
+* default `'none'` doesn't clobber externally-seeded selections.
+*
+* Lives outside `useTableSelection` because selection mode is a renderer
+* concern (a prop, not state) — both `<AsTable>` and `<AsWindowTable>`
+* call this from their setup so the cleanup tracks the renderer's prop.
+*/
+function useSelectModeReset(state, selectGetter) {
+	(0, vue.watch)(selectGetter, (next, prev) => {
+		if (next === "none" && prev !== "none" && state.selectedRows.value.length > 0) state.selectedRows.value = [];
+	});
+}
+/**
+* Wire up selection reconciliation on results change.
+*
+* The watcher distinguishes results-replacement (query / invalidate /
+* pagination jump) from results-extension in EITHER direction (queryNext /
+* forward-merging loadRange / backward-merging loadRange) and only runs the
+* reconciliation logic on replacement. Backward extension prepends rows AND
+* decrements `resultsStart` — caught via the last-row reference identity
+* check, so scrolling upward doesn't silently mutate selection.
+*
+* Mode semantics on results-replacement:
+* - `"persist"` — no-op; the consumer's ref is untouched.
+* - `"trim"` (default) — keep the subset of selected PKs still present in the new results.
+* - `"clear"` — drop everything.
+*/
+function useTableSelection(state, opts) {
+	const mode = opts?.mode ?? "trim";
+	(0, vue.watch)([() => state.results.value, () => state.resultsStart.value], ([newResults, newResultsStart], [oldResults, oldResultsStart]) => {
+		if (mode === "persist") return;
+		if (state.selectedRows.value.length === 0) return;
+		const oldArr = oldResults ?? [];
+		const newArr = newResults;
+		const oldStart = oldResultsStart ?? 0;
+		const delta = newArr.length - oldArr.length;
+		if (delta > 0 && oldArr.length > 0) {
+			if (newResultsStart === oldStart && newArr[0] === oldArr[0]) return;
+			if (newResultsStart === oldStart - delta && newArr[newArr.length - 1] === oldArr[oldArr.length - 1]) return;
+		}
+		if (mode === "clear") {
+			state.selectedRows.value = [];
+			return;
+		}
+		const presentPks = /* @__PURE__ */ new Set();
+		for (const r of newArr) presentPks.add(state.rowValueFn(r));
+		state.selectedRows.value = (0, _atscript_ui_table.trimSelection)(state.selectedRows.value, presentPks);
+	});
+}
+//#endregion
+//#region src/composables/use-cell-resolver.ts
+/** Frozen sentinel for columns with no cell-level annotations. */
+const EMPTY_BINDINGS = Object.freeze({});
+const TABLE_FN_KEYS = {
+	staticKey: _atscript_ui.UI_TABLE_ATTR,
+	fnKey: _atscript_ui.UI_TABLE_FN_ATTR
+};
+/**
+* Per-`TableDef.type` cache of column resolution metadata. Avoids re-probing
+* per-key annotations on every cell render. The flat type tree itself is
+* already pre-built on `TableDef.flatMap`.
+*/
+const metaCache = /* @__PURE__ */ new WeakMap();
+const EMPTY_META_MAP = /* @__PURE__ */ new Map();
+function getColumnMetaMap(def) {
+	if (def.type === null || typeof def.type !== "object") return EMPTY_META_MAP;
+	let map = metaCache.get(def.type);
+	if (map) return map;
+	map = /* @__PURE__ */ new Map();
+	for (const [path, prop] of def.flatMap.entries()) {
+		if (path === "") continue;
+		const m = prop.metadata;
+		const hasFnClasses = m.has(_atscript_ui.UI_TABLE_FN_CLASSES);
+		const hasFnStyles = m.has(_atscript_ui.UI_TABLE_FN_STYLES);
+		const hasFnAttrs = m.has(_atscript_ui.UI_TABLE_FN_ATTR);
+		const hasClasses = hasFnClasses || m.has(_atscript_ui.UI_TABLE_CLASSES);
+		const hasStyles = hasFnStyles || m.has(_atscript_ui.UI_TABLE_STYLES);
+		const hasAttrs = hasFnAttrs || m.has(_atscript_ui.UI_TABLE_ATTR);
+		const hasAny = hasClasses || hasStyles || hasAttrs;
+		if (!hasAny) continue;
+		map.set(path, {
+			prop,
+			hasClasses,
+			hasStyles,
+			hasAttrs,
+			hasAnyFn: hasFnClasses || hasFnStyles || hasFnAttrs,
+			hasAny
+		});
+	}
+	metaCache.set(def.type, map);
+	return map;
+}
+/**
+* Per-row cell composable.
+*
+* Returns `{ resolve, hasAnyCellBindings }`:
+* - `resolve(column, row, rowIndex)` produces `CellBindings`. For columns with
+*   no `@ui.table.classes` / `@ui.table.styles` / `@ui.table.attr` (static or
+*   dynamic), it short-circuits to a frozen empty object — no scope build, no
+*   reactive reads, no allocations. Static-only columns reuse a cached object.
+* - `hasAnyCellBindings` is `false` when no column on the def has any of the
+*   above annotations — consumers should skip calling `resolve` entirely.
+*/
+function useCellResolver(getTableDef) {
+	const state = require_use_table_state.useTableContextOptional()?.state;
+	const hasAnyCellBindings = (0, vue.computed)(() => {
+		const def = getTableDef();
+		return !!def && getColumnMetaMap(def).size > 0;
+	});
+	const resolve = (column, row, rowIndex) => {
+		const def = getTableDef();
+		if (!def) return EMPTY_BINDINGS;
+		const colMeta = getColumnMetaMap(def).get(column.path);
+		if (!colMeta) return EMPTY_BINDINGS;
+		if (!colMeta.hasAnyFn) return colMeta.staticBindings ??= buildStaticBindings(colMeta);
+		const scope = buildScope(state, row, rowIndex);
+		const cls = colMeta.hasClasses ? (0, _atscript_ui.resolveFieldProp)(colMeta.prop, _atscript_ui.UI_TABLE_FN_CLASSES, _atscript_ui.UI_TABLE_CLASSES, scope) : void 0;
+		const style = colMeta.hasStyles ? (0, _atscript_ui.resolveFieldProp)(colMeta.prop, _atscript_ui.UI_TABLE_FN_STYLES, _atscript_ui.UI_TABLE_STYLES, scope) : void 0;
+		const attrs = colMeta.hasAttrs ? (0, _atscript_ui.resolveAttrs)(colMeta.prop, scope, TABLE_FN_KEYS) : void 0;
+		if (!attrs && cls === void 0 && style === void 0) return EMPTY_BINDINGS;
+		const out = attrs ? { ...attrs } : {};
+		if (cls !== void 0) out.class = cls;
+		if (style !== void 0) out.style = style;
+		return out;
+	};
+	return {
+		resolve,
+		hasAnyCellBindings
+	};
+}
+function buildStaticBindings(colMeta) {
+	const cls = colMeta.hasClasses ? (0, _atscript_ui.getFieldMeta)(colMeta.prop, _atscript_ui.UI_TABLE_CLASSES) : void 0;
+	const style = colMeta.hasStyles ? (0, _atscript_ui.getFieldMeta)(colMeta.prop, _atscript_ui.UI_TABLE_STYLES) : void 0;
+	const attrs = colMeta.hasAttrs ? (0, _atscript_ui.parseStaticAttrs)((0, _atscript_ui.getFieldMeta)(colMeta.prop, _atscript_ui.UI_TABLE_ATTR)) : void 0;
+	if (!attrs && cls === void 0 && style === void 0) return EMPTY_BINDINGS;
+	const out = attrs ? { ...attrs } : {};
+	if (cls !== void 0) out.class = cls;
+	if (style !== void 0) out.style = style;
+	return out;
+}
+function buildScope(state, row, rowIndex) {
+	return {
+		row,
+		ctx: {
+			searchTerm: state?.searchTerm.value ?? "",
+			filters: state?.filters.value ?? {},
+			sorters: state?.sorters.value ?? [],
+			rowIndex
+		}
+	};
+}
+//#endregion
+//#region src/composables/use-cell-components.ts
+/**
+* Resolves the cell component for each column once per column, keyed by
+* `column.path`. Mirrors the form's resolution order in `as-field.vue`:
+*   1. `@ui.table.component "name"` → `ctx.components[name]`
+*   2. `column.type` → `ctx.types[type]`
+*   3. fallback → `AsTableCellValue`
+*
+* Hoisted out of the per-cell render path because the answer is identical for
+* every row in a given column — a 50×10 table avoids ~500 redundant lookups.
+*/
+function useCellComponents(getColumns) {
+	const ctx = require_use_table_state.useTableContextOptional();
+	return (0, vue.computed)(() => {
+		const out = {};
+		for (const col of getColumns()) {
+			let resolved;
+			if (col.component) resolved = ctx?.components?.[col.component];
+			resolved ??= ctx?.types?.[col.type] ?? require_as_table_cell_value.as_table_cell_value_default;
+			out[col.path] = resolved;
+		}
+		return out;
+	});
+}
+//#endregion
+//#region src/composables/use-raf-batch.ts
+/**
+* Coalesce a high-frequency stream of values into one rAF-tick callback.
+* Pointermove / wheel can fire at >120Hz; without batching, each native event
+* fans out reactive updates and re-runs downstream computeds + watchers.
+*
+* `schedule(value)` overwrites the pending value and arms a rAF if none is in
+* flight. `flushNow()` runs the callback synchronously with whatever is pending
+* (used at gesture-end so the final value isn't dropped). Auto-cancels on
+* scope dispose.
+*/
+function useRafBatch(onFlush) {
+	let pending = null;
+	let hasPending = false;
+	let rafId = 0;
+	function flush() {
+		rafId = 0;
+		if (!hasPending) return;
+		const value = pending;
+		pending = null;
+		hasPending = false;
+		onFlush(value);
+	}
+	function schedule(value) {
+		pending = value;
+		hasPending = true;
+		if (rafId !== 0) return;
+		rafId = requestAnimationFrame(flush);
+	}
+	function flushNow() {
+		if (rafId !== 0) {
+			cancelAnimationFrame(rafId);
+			rafId = 0;
+		}
+		flush();
+	}
+	function cancel() {
+		if (rafId !== 0) {
+			cancelAnimationFrame(rafId);
+			rafId = 0;
+		}
+		pending = null;
+		hasPending = false;
+	}
+	(0, vue.onBeforeUnmount)(cancel);
+	return {
+		schedule,
+		flushNow,
+		cancel
+	};
+}
+//#endregion
+//#region src/composables/use-column-header-drag-resize.ts
+function pathOf(event) {
+	return event.currentTarget?.dataset.columnPath ?? null;
+}
+function thFromHandleEvent(event) {
+	const th = event.currentTarget?.closest("th");
+	const path = th?.dataset.columnPath;
+	if (!th || !path) return null;
+	return {
+		th,
+		path
+	};
+}
+function useColumnHeaderDragResize(opts) {
+	const dragSourcePath = (0, vue.ref)(null);
+	const dropTarget = (0, vue.ref)(null);
+	const resizingPath = (0, vue.ref)(null);
+	let resizeStartX = 0;
+	let resizeStartWidth = 0;
+	const resizeBatch = useRafBatch(({ path, width }) => opts.onResize(path, width));
+	function onHeaderDragStart(event) {
+		if (!opts.reorderable()) return;
+		if (resizingPath.value !== null) {
+			event.preventDefault();
+			return;
+		}
+		const path = pathOf(event);
+		if (!path) return;
+		dragSourcePath.value = path;
+		if (event.dataTransfer) {
+			event.dataTransfer.effectAllowed = "move";
+			event.dataTransfer.setData("text/plain", path);
+		}
+	}
+	function onHeaderDragOver(event) {
+		if (!opts.reorderable() || dragSourcePath.value === null) return;
+		const path = pathOf(event);
+		if (!path) return;
+		event.preventDefault();
+		if (event.dataTransfer) event.dataTransfer.dropEffect = "move";
+		const rect = event.currentTarget.getBoundingClientRect();
+		const position = event.clientX - rect.left < rect.width / 2 ? "before" : "after";
+		if (dropTarget.value?.path !== path || dropTarget.value?.position !== position) dropTarget.value = {
+			path,
+			position
+		};
+	}
+	function onHeaderDrop(event) {
+		if (!opts.reorderable()) return;
+		event.preventDefault();
+		const path = pathOf(event);
+		const source = dragSourcePath.value;
+		const target = dropTarget.value;
+		if (path && source && target && target.path === path && source !== target.path) opts.onReorder(source, target.path, target.position);
+		dragSourcePath.value = null;
+		dropTarget.value = null;
+	}
+	function onHeaderDragEnd() {
+		dragSourcePath.value = null;
+		dropTarget.value = null;
+	}
+	function onResizeHandlePointerDown(event) {
+		if (!opts.resizable()) return;
+		const found = thFromHandleEvent(event);
+		if (!found) return;
+		resizingPath.value = found.path;
+		resizeStartX = event.clientX;
+		resizeStartWidth = found.th.getBoundingClientRect().width;
+		event.currentTarget.setPointerCapture?.(event.pointerId);
+	}
+	function onResizeHandlePointerMove(event) {
+		if (!resizingPath.value) return;
+		const next = Math.round(Math.max(resizeStartWidth + (event.clientX - resizeStartX), opts.columnMinWidth()));
+		resizeBatch.schedule({
+			path: resizingPath.value,
+			width: `${next}px`
+		});
+	}
+	function onResizeHandleEnd() {
+		resizingPath.value = null;
+		resizeBatch.flushNow();
+	}
+	function onResizeHandleDoubleClick(event) {
+		if (!opts.resizable() || !opts.onAutoFit) return;
+		const found = thFromHandleEvent(event);
+		if (!found) return;
+		opts.onAutoFit(found.th, found.path);
+	}
+	function widthStyle(col) {
+		const entry = opts.columnWidths()[col.path];
+		if (entry) return { width: entry.w };
+		if (col.width) return { width: col.width };
+	}
+	function thClasses(path) {
+		const reorder = opts.reorderable();
+		const resize = opts.resizable();
+		if (!reorder && !resize) return {};
+		return {
+			"as-th-reorderable": reorder,
+			"as-th-dragging": reorder && dragSourcePath.value === path,
+			"as-th-drop-indicator-before": reorder && dropTarget.value?.path === path && dropTarget.value?.position === "before",
+			"as-th-drop-indicator-after": reorder && dropTarget.value?.path === path && dropTarget.value?.position === "after",
+			"as-th-resizing": resize && resizingPath.value === path
+		};
+	}
+	return {
+		onHeaderDragStart,
+		onHeaderDragOver,
+		onHeaderDrop,
+		onHeaderDragEnd,
+		onResizeHandlePointerDown,
+		onResizeHandlePointerMove,
+		onResizeHandleEnd,
+		onResizeHandleDoubleClick,
+		thClasses,
+		widthStyle
+	};
+}
+//#endregion
+//#region src/components/internal/as-table-header.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1$1 = {
+	key: 0,
+	class: "as-th-select"
+};
+const _hoisted_2$1 = ["aria-checked"];
+const _hoisted_3$1 = {
+	key: 0,
+	class: "as-table-checkbox-tick",
+	"aria-hidden": "true"
+};
+const _hoisted_4$1 = {
+	key: 1,
+	class: "as-table-checkbox-dash"
+};
+const _hoisted_5$1 = [
+	"data-column-path",
+	"draggable",
+	"aria-label",
+	"onDragstart",
+	"onDragover",
+	"onDrop",
+	"onDragend"
+];
+const _hoisted_6$1 = {
+	key: 1,
+	class: "as-th-filler"
+};
+//#endregion
+//#region src/components/internal/as-table-header.vue
+var as_table_header_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "as-table-header",
+	props: {
+		columns: {
+			type: Array,
+			required: true
+		},
+		sorters: {
+			type: Array,
+			required: true
+		},
+		filters: {
+			type: Object,
+			required: false
+		},
+		columnMenu: {
+			type: Object,
+			required: false
+		},
+		columnWidths: {
+			type: Object,
+			required: true
+		},
+		reorderable: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		resizable: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		columnMinWidth: {
+			type: Number,
+			required: false,
+			default: 48
+		},
+		hasSelectColumn: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		selectAllState: {
+			type: String,
+			required: false
+		},
+		withFiller: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		enableAutoFit: {
+			type: Boolean,
+			required: false,
+			default: false
+		}
+	},
+	emits: [
+		"sort",
+		"hide",
+		"filter",
+		"filters-off",
+		"reset-width",
+		"reorder",
+		"resize",
+		"select-all-toggle"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const sortMap = (0, vue.computed)(() => {
+			const map = {};
+			for (const s of props.sorters) map[s.field] = s.direction;
+			return map;
+		});
+		const { onHeaderDragStart, onHeaderDragOver, onHeaderDrop, onHeaderDragEnd, onResizeHandlePointerDown, onResizeHandlePointerMove, onResizeHandleEnd, onResizeHandleDoubleClick, thClasses, widthStyle } = useColumnHeaderDragResize({
+			reorderable: () => props.reorderable,
+			resizable: () => props.resizable,
+			columnMinWidth: () => props.columnMinWidth,
+			columnWidths: () => props.columnWidths,
+			onReorder: (from, to, position) => emit("reorder", from, to, position),
+			onResize: (path, width) => emit("resize", path, width),
+			onAutoFit: props.enableAutoFit ? (th, path) => {
+				const table = th.closest("table");
+				if (!table) return;
+				const measured = measureNaturalColumnWidth(th, table);
+				if (measured > 0) {
+					emit("resize", path, `${Math.max(Math.ceil(measured), props.columnMinWidth)}px`);
+					return;
+				}
+				let fallback = th.scrollWidth;
+				const colIndex = th.cellIndex;
+				for (const tr of table.querySelectorAll("tbody tr")) {
+					const cell = tr.children[colIndex];
+					if (cell) fallback = Math.max(fallback, cell.scrollWidth);
+				}
+				emit("resize", path, `${Math.max(fallback, props.columnMinWidth)}px`);
+			} : void 0
+		});
+		function measureNaturalColumnWidth(th, table) {
+			const origTableLayout = table.style.tableLayout;
+			const origTableWidth = table.style.width;
+			const origTableMinWidth = table.style.minWidth;
+			const origThWidth = th.style.width;
+			table.style.tableLayout = "auto";
+			table.style.minWidth = "0";
+			table.style.width = "max-content";
+			th.style.width = "max-content";
+			const measured = th.offsetWidth;
+			th.style.width = origThWidth;
+			table.style.width = origTableWidth;
+			table.style.minWidth = origTableMinWidth;
+			table.style.tableLayout = origTableLayout;
+			return measured;
+		}
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createElementBlock)("thead", null, [(0, vue.createElementVNode)("tr", null, [
+				__props.hasSelectColumn ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("th", _hoisted_1$1, [__props.selectAllState ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", {
+					key: 0,
+					class: (0, vue.normalizeClass)(["as-table-checkbox", {
+						"as-table-checkbox-checked": __props.selectAllState === "all",
+						"as-table-checkbox-indeterminate": __props.selectAllState === "some"
+					}]),
+					role: "checkbox",
+					tabindex: "0",
+					"aria-checked": __props.selectAllState === "none" ? "false" : __props.selectAllState === "all" ? "true" : "mixed",
+					onClick: _cache[0] || (_cache[0] = ($event) => emit("select-all-toggle", __props.selectAllState))
+				}, [__props.selectAllState === "all" ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", _hoisted_3$1)) : __props.selectAllState === "some" ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("span", _hoisted_4$1)) : (0, vue.createCommentVNode)("v-if", true)], 10, _hoisted_2$1)) : (0, vue.createCommentVNode)("v-if", true)])) : (0, vue.createCommentVNode)("v-if", true),
+				((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(__props.columns, (col) => {
+					return (0, vue.openBlock)(), (0, vue.createElementBlock)("th", {
+						key: col.path,
+						"data-column-path": col.path,
+						draggable: __props.reorderable && !col.fixed || void 0,
+						class: (0, vue.normalizeClass)([(0, vue.unref)(thClasses)(col.path), col.fixed ? "as-th-fixed" : void 0]),
+						style: (0, vue.normalizeStyle)((0, vue.unref)(widthStyle)(col)),
+						"aria-label": col.fixed && col.path === (0, vue.unref)("__actions") ? "Actions" : void 0,
+						onDragstart: ($event) => col.fixed ? void 0 : (0, vue.unref)(onHeaderDragStart)($event),
+						onDragover: ($event) => col.fixed ? void 0 : (0, vue.unref)(onHeaderDragOver)($event),
+						onDrop: ($event) => col.fixed ? void 0 : (0, vue.unref)(onHeaderDrop)($event),
+						onDragend: ($event) => col.fixed ? void 0 : (0, vue.unref)(onHeaderDragEnd)()
+					}, [!col.fixed ? (0, vue.renderSlot)(_ctx.$slots, `header-${col.path}`, {
+						key: 0,
+						column: col
+					}, () => [(0, vue.createVNode)(require_as_table_header_cell.as_table_header_cell_default, {
+						column: col,
+						"sort-direction": sortMap.value[col.path] ?? null,
+						filters: __props.filters?.[col.path],
+						"column-menu": __props.columnMenu,
+						"width-entry": __props.columnWidths[col.path],
+						onSort: _cache[1] || (_cache[1] = (c, d) => emit("sort", c, d)),
+						onHide: _cache[2] || (_cache[2] = (c) => emit("hide", c)),
+						onFilter: _cache[3] || (_cache[3] = (c) => emit("filter", c)),
+						onFiltersOff: _cache[4] || (_cache[4] = (c) => emit("filters-off", c)),
+						onResetWidth: _cache[5] || (_cache[5] = (c) => emit("reset-width", c))
+					}, null, 8, [
+						"column",
+						"sort-direction",
+						"filters",
+						"column-menu",
+						"width-entry"
+					])]) : (0, vue.createCommentVNode)("v-if", true), __props.resizable && !col.fixed ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
+						key: 1,
+						class: "as-th-resize-handle",
+						draggable: "false",
+						onDragstart: _cache[6] || (_cache[6] = (0, vue.withModifiers)(() => {}, ["prevent", "stop"])),
+						onPointerdown: _cache[7] || (_cache[7] = (0, vue.withModifiers)((...args) => (0, vue.unref)(onResizeHandlePointerDown) && (0, vue.unref)(onResizeHandlePointerDown)(...args), ["stop"])),
+						onPointermove: _cache[8] || (_cache[8] = (...args) => (0, vue.unref)(onResizeHandlePointerMove) && (0, vue.unref)(onResizeHandlePointerMove)(...args)),
+						onPointerup: _cache[9] || (_cache[9] = (...args) => (0, vue.unref)(onResizeHandleEnd) && (0, vue.unref)(onResizeHandleEnd)(...args)),
+						onPointercancel: _cache[10] || (_cache[10] = (...args) => (0, vue.unref)(onResizeHandleEnd) && (0, vue.unref)(onResizeHandleEnd)(...args)),
+						onDblclick: _cache[11] || (_cache[11] = (0, vue.withModifiers)((...args) => (0, vue.unref)(onResizeHandleDoubleClick) && (0, vue.unref)(onResizeHandleDoubleClick)(...args), ["stop"]))
+					}, null, 32)) : (0, vue.createCommentVNode)("v-if", true)], 46, _hoisted_5$1);
+				}), 128)),
+				__props.withFiller ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("th", _hoisted_6$1)) : (0, vue.createCommentVNode)("v-if", true)
+			])]);
+		};
+	}
+});
+//#endregion
+//#region src/components/internal/as-table-status.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = {
+	key: 0,
+	class: "as-table-error"
+};
+const _hoisted_2 = { class: "as-vh-empty" };
+const _hoisted_3 = { class: "as-vh-empty-body" };
+const _hoisted_4 = {
+	key: 1,
+	class: "as-table-empty"
+};
+const _hoisted_5 = { class: "as-vh-empty" };
+const _hoisted_6 = {
+	key: 0,
+	class: "as-vh-empty-body"
+};
+const _hoisted_7 = { class: "as-vh-empty-code" };
+const _hoisted_8 = {
+	key: 1,
+	class: "as-vh-empty-body"
+};
+const _hoisted_9 = {
+	key: 2,
+	class: "as-vh-empty-body"
+};
+//#endregion
+//#region src/components/internal/as-table-status.vue
+var as_table_status_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "as-table-status",
+	props: {
+		queryError: {
+			type: null,
+			required: true
+		},
+		isEmpty: {
+			type: Boolean,
+			required: true
+		},
+		querying: {
+			type: Boolean,
+			required: true
+		},
+		columns: {
+			type: Array,
+			required: true
+		},
+		searchTerm: {
+			type: String,
+			required: false
+		},
+		hasActiveFilters: {
+			type: Boolean,
+			required: true
+		},
+		onClearFilters: {
+			type: Function,
+			required: false
+		},
+		onRetry: {
+			type: Function,
+			required: false
+		}
+	},
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return __props.queryError ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_1, [(0, vue.renderSlot)(_ctx.$slots, "error", {
+				error: __props.queryError,
+				retry: __props.onRetry
+			}, () => [(0, vue.createElementVNode)("div", _hoisted_2, [
+				_cache[3] || (_cache[3] = (0, vue.createElementVNode)("span", {
+					class: "as-vh-error-icon i-as-warning",
+					"aria-hidden": "true"
+				}, null, -1)),
+				_cache[4] || (_cache[4] = (0, vue.createElementVNode)("p", { class: "as-vh-empty-title" }, "Failed to load values", -1)),
+				(0, vue.createElementVNode)("p", _hoisted_3, (0, vue.toDisplayString)(__props.queryError.message), 1),
+				__props.onRetry ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("button", {
+					key: 0,
+					type: "button",
+					class: "as-vh-empty-clear",
+					onClick: _cache[0] || (_cache[0] = (...args) => __props.onRetry && __props.onRetry(...args))
+				}, [..._cache[2] || (_cache[2] = [(0, vue.createElementVNode)("span", {
+					class: "i-as-refresh",
+					"aria-hidden": "true"
+				}, null, -1), (0, vue.createTextVNode)(" Retry ", -1)])])) : (0, vue.createCommentVNode)("v-if", true)
+			])])])) : __props.isEmpty && !__props.querying && __props.columns.length > 0 ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", _hoisted_4, [(0, vue.renderSlot)(_ctx.$slots, "empty", {
+				searchTerm: __props.searchTerm,
+				hasActiveFilters: __props.hasActiveFilters,
+				onClearFilters: __props.onClearFilters
+			}, () => [(0, vue.createElementVNode)("div", _hoisted_5, [
+				_cache[8] || (_cache[8] = (0, vue.createElementVNode)("span", {
+					class: "as-vh-empty-icon i-as-search",
+					"aria-hidden": "true"
+				}, null, -1)),
+				_cache[9] || (_cache[9] = (0, vue.createElementVNode)("p", { class: "as-vh-empty-title" }, "No matching values", -1)),
+				__props.searchTerm ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("p", _hoisted_6, [
+					_cache[5] || (_cache[5] = (0, vue.createTextVNode)(" No entries match ", -1)),
+					(0, vue.createElementVNode)("span", _hoisted_7, "\"" + (0, vue.toDisplayString)(__props.searchTerm) + "\"", 1),
+					_cache[6] || (_cache[6] = (0, vue.createTextVNode)(". Try a different search. ", -1))
+				])) : __props.hasActiveFilters ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("p", _hoisted_8, " No entries match the current filters. ")) : ((0, vue.openBlock)(), (0, vue.createElementBlock)("p", _hoisted_9, "No entries available")),
+				(__props.searchTerm || __props.hasActiveFilters) && __props.onClearFilters ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("button", {
+					key: 3,
+					type: "button",
+					class: "as-vh-empty-clear",
+					onClick: _cache[1] || (_cache[1] = (...args) => __props.onClearFilters && __props.onClearFilters(...args))
+				}, [..._cache[7] || (_cache[7] = [(0, vue.createElementVNode)("span", {
+					class: "i-as-refresh",
+					"aria-hidden": "true"
+				}, null, -1), (0, vue.createTextVNode)(" Clear filters ", -1)])])) : (0, vue.createCommentVNode)("v-if", true)
+			])])])) : (0, vue.createCommentVNode)("v-if", true);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "as_table_header_default", {
+	enumerable: true,
+	get: function() {
+		return as_table_header_default;
+	}
+});
+Object.defineProperty(exports, "as_table_status_default", {
+	enumerable: true,
+	get: function() {
+		return as_table_status_default;
+	}
+});
+Object.defineProperty(exports, "useCellComponents", {
+	enumerable: true,
+	get: function() {
+		return useCellComponents;
+	}
+});
+Object.defineProperty(exports, "useCellResolver", {
+	enumerable: true,
+	get: function() {
+		return useCellResolver;
+	}
+});
+Object.defineProperty(exports, "useRafBatch", {
+	enumerable: true,
+	get: function() {
+		return useRafBatch;
+	}
+});
+Object.defineProperty(exports, "useSelectModeReset", {
+	enumerable: true,
+	get: function() {
+		return useSelectModeReset;
+	}
+});
+Object.defineProperty(exports, "useTableSelection", {
+	enumerable: true,
+	get: function() {
+		return useTableSelection;
+	}
+});