@atscript/vue-table 0.1.97 → 0.1.98

package/dist/use-table-CRsFMyJb.mjs

@@ -0,0 +1,440 @@
+import { n as createTableState, r as provideTableContext, s as DEFAULT_AVAILABLE_ASPECTS } from "./use-table-state-CuZ2OXoY.mjs";
+import { n as useTableSelection } from "./use-table-selection-C84z4OZy.mjs";
+import { createTableDef, getMetaEntry, resetMetaCache } from "@atscript/ui";
+import { computed, inject, isRef, ref, shallowRef, watch } from "vue";
+import { PresetsClient, STANDARD_PRESET_ID, debounce, deserializeDraft, isAuthError, isEmptyDraft, isSystemPresetId, resolveSystemPresets, serializeDraft, stableStringify } from "@atscript/ui-table";
+//#region src/composables/as-presets-app.ts
+/**
+* App-wide injection key for the presets system. The host app calls
+* `app.provide(AS_PRESETS_APP, '<your-app>')` once at boot; every
+* `<AsTableRoot>`, `usePresets`, and `useAppPrefs` call below it pulls the
+* value via `inject(AS_PRESETS_APP)` unless an explicit `app` option
+* overrides it.
+*
+* The string identifies the application namespace on the server side —
+* one Moost backend can serve many apps; rows are scoped by `(app,
+* tableKey)`.
+*/
+const AS_PRESETS_APP = Symbol("AS_PRESETS_APP");
+/**
+* Resolve the app name with these precedence rules:
+*
+* 1. `explicit` argument (composable option) — wins.
+* 2. `inject(AS_PRESETS_APP)` from the Vue tree.
+* 3. Throws — composable can't run without an app namespace.
+*
+* Throws a clear error when neither is available so misconfiguration
+* surfaces at setup time, not when the first network round-trip fails.
+*/
+function injectPresetsApp(explicit) {
+	if (explicit && explicit.length > 0) return explicit;
+	const fromProvide = inject(AS_PRESETS_APP, void 0);
+	if (fromProvide && fromProvide.length > 0) return fromProvide;
+	throw new Error("[vue-table] AS_PRESETS_APP not provided. Call `app.provide(AS_PRESETS_APP, '<your-app>')` once at boot, or pass `app` to the composable.");
+}
+//#endregion
+//#region src/composables/use-local-draft.ts
+const DEFAULT_DEBOUNCE_MS = 300;
+/**
+* localStorage overlay manager for table presets. One overlay per
+* `(app, tableKey)`; switching presets clears it (caller's responsibility
+* — this composable only tracks state, not which preset is active).
+*/
+function useLocalDraft(opts) {
+	const key = `as-table-draft:${opts.app}:${opts.tableKey}`;
+	const debounceMs = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+	const storage = resolveStorage(opts.storage);
+	function isEnabled() {
+		if (typeof opts.enabled === "boolean") return opts.enabled;
+		if (isRef(opts.enabled)) return Boolean(opts.enabled.value);
+		return false;
+	}
+	function readDraft() {
+		if (!storage) return null;
+		try {
+			const raw = storage.getItem(key);
+			if (!raw) return null;
+			const parsed = JSON.parse(raw);
+			if (!parsed || typeof parsed !== "object") return null;
+			return parsed;
+		} catch (err) {
+			console.warn("[vue-table] useLocalDraft: corrupted localStorage entry, ignoring", err);
+			return null;
+		}
+	}
+	function writeDraft(draft) {
+		if (!storage) return;
+		try {
+			storage.setItem(key, JSON.stringify(draft));
+		} catch (err) {
+			console.warn("[vue-table] useLocalDraft: localStorage write failed", err);
+		}
+	}
+	function clear() {
+		if (!storage) return;
+		try {
+			storage.removeItem(key);
+		} catch {}
+	}
+	function hydrate(applied) {
+		if (!isEnabled()) return applied;
+		const draft = readDraft();
+		if (!draft || isEmptyDraft(draft)) return applied;
+		const overlay = deserializeDraft(draft, opts.availableAspects);
+		return {
+			...applied,
+			...overlay
+		};
+	}
+	function watchAndPersist(currentSnapshot, activePresetSnapshot) {
+		let lastDraftSerialized = "";
+		let lastPresetRef = null;
+		let lastPresetSerialized = "";
+		function flush(current, preset) {
+			if (!isEnabled()) return;
+			const draft = serializeDraft(current, opts.availableAspects);
+			if (isEmptyDraft(draft)) {
+				clear();
+				lastDraftSerialized = "";
+				return;
+			}
+			const draftSerialized = stableStringify(draft);
+			if (preset !== lastPresetRef) {
+				lastPresetRef = preset;
+				lastPresetSerialized = stableStringify(serializeDraft(preset, opts.availableAspects));
+			}
+			if (draftSerialized === lastPresetSerialized) {
+				clear();
+				lastDraftSerialized = "";
+				return;
+			}
+			if (draftSerialized === lastDraftSerialized) return;
+			lastDraftSerialized = draftSerialized;
+			writeDraft(draft);
+		}
+		const flushDebounced = debounce(((current, preset) => flush(current, preset)), debounceMs);
+		const stop = watch(() => [currentSnapshot(), activePresetSnapshot()], ([current, preset]) => flushDebounced(current, preset), { flush: "post" });
+		return () => {
+			flushDebounced.cancel();
+			stop();
+		};
+	}
+	return {
+		hydrate,
+		watchAndPersist,
+		clear,
+		readDraft
+	};
+}
+function resolveStorage(provided) {
+	if (provided !== void 0) return provided;
+	try {
+		return globalThis.localStorage ?? null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/composables/use-presets.ts
+/**
+* Public dev-facing composable for table presets. Powers `<AsPresetPicker>`
+* internally and is exported for devs who want to wire bespoke surfaces.
+*
+* Stateful: holds reactive `presets` / `userConf` / `capabilities` and
+* supports optimistic mutators that re-list after each successful write.
+*
+* Active-preset selection (`activePresetId`) is **owned by the caller** —
+* the composable provides the ref but doesn't auto-resolve it on mount;
+* that's the table-state's responsibility (Slice 4) since it depends on
+* `userConf.defaultPresetId` resolution + Standard fallback.
+*/
+function usePresets(opts) {
+	const app = injectPresetsApp(opts.app);
+	if (!opts.tableKey) throw new Error("[vue-table] usePresets: `tableKey` is required");
+	const client = new PresetsClient({
+		url: opts.url,
+		app,
+		tableKey: opts.tableKey,
+		clientFactory: opts.clientFactory
+	});
+	const systemPresetsResolved = computed(() => resolveSystemPresets(opts.systemPresets));
+	const presets = shallowRef([]);
+	const userConf = shallowRef(null);
+	const capabilities = ref(null);
+	const loading = ref(false);
+	const error = ref(null);
+	const denied = ref(false);
+	const activePresetId = ref(null);
+	const available = computed(() => !denied.value);
+	const presetsById = computed(() => {
+		const map = /* @__PURE__ */ new Map();
+		for (const row of presets.value) map.set(row.id, row);
+		return map;
+	});
+	const systemPresetsById = computed(() => {
+		const map = /* @__PURE__ */ new Map();
+		for (const sp of systemPresetsResolved.value) map.set(sp.id, sp);
+		return map;
+	});
+	const activePreset = computed(() => {
+		const id = activePresetId.value;
+		if (!id) return null;
+		if (isSystemPresetId(id)) {
+			const entry = systemPresetsById.value.get(id);
+			return entry ? {
+				kind: "system",
+				entry
+			} : null;
+		}
+		const entry = presetsById.value.get(id);
+		return entry ? {
+			kind: "stored",
+			entry
+		} : null;
+	});
+	const currentUser = computed(() => {
+		const fromCaps = capabilities.value?.userId;
+		if (typeof fromCaps === "string" && fromCaps.length > 0) return fromCaps;
+		for (const row of presets.value) if (row.public !== true && typeof row.user === "string" && row.user.length > 0) return row.user;
+		return null;
+	});
+	function isOwned(id) {
+		if (isSystemPresetId(id)) return false;
+		const row = presetsById.value.get(id);
+		if (!row) return false;
+		if (row.public !== true) return true;
+		const me = currentUser.value;
+		return me !== null && row.user === me;
+	}
+	/**
+	* @param opts.capabilities — set `false` for refresh-after-mutation calls
+	*   (fav-toggle, save, rename, delete, public-toggle, set-default) where
+	*   role-derived capabilities can't have changed. Default `true`, used
+	*   only on the initial mount load.
+	*/
+	let batchDepth = 0;
+	let reloadPending = false;
+	async function maybeReloadAfterMutation() {
+		if (batchDepth > 0) {
+			reloadPending = true;
+			return;
+		}
+		await reload({ capabilities: false });
+	}
+	async function batch(fn) {
+		batchDepth++;
+		try {
+			return await fn();
+		} finally {
+			batchDepth--;
+			if (batchDepth === 0 && reloadPending) {
+				reloadPending = false;
+				await reload({ capabilities: false });
+			}
+		}
+	}
+	async function reload(opts = {}) {
+		loading.value = true;
+		error.value = null;
+		try {
+			const result = await client.list(opts);
+			if (result.denied) {
+				denied.value = true;
+				presets.value = [];
+				userConf.value = null;
+				capabilities.value = null;
+				return;
+			}
+			denied.value = false;
+			presets.value = result.presets;
+			userConf.value = result.userConf;
+			if (result.capabilities !== void 0) capabilities.value = result.capabilities;
+		} catch (err) {
+			if (isAuthError(err)) {
+				denied.value = true;
+				presets.value = [];
+				userConf.value = null;
+				capabilities.value = null;
+				return;
+			}
+			error.value = err;
+			console.warn("[vue-table] usePresets load failed:", err);
+		} finally {
+			loading.value = false;
+		}
+	}
+	async function savePreset(snapshot) {
+		const id = activePresetId.value;
+		if (!id) throw new Error("[vue-table] usePresets.savePreset: no active preset");
+		if (isSystemPresetId(id)) throw new Error("[vue-table] usePresets.savePreset: system presets cannot be overwritten");
+		const row = presetsById.value.get(id);
+		const label = row?.label ?? (row?.data)?.label ?? "";
+		if (!label) throw new Error("[vue-table] usePresets.savePreset: existing preset has no label");
+		await client.savePreset(id, label, snapshot);
+		await maybeReloadAfterMutation();
+	}
+	async function savePresetAs(label, snapshot, saveOpts = {}) {
+		const result = await client.savePresetAs(label, snapshot, saveOpts);
+		await maybeReloadAfterMutation();
+		activePresetId.value = result.id;
+		return result.id;
+	}
+	async function renamePreset(id, label) {
+		if (isSystemPresetId(id)) throw new Error("[vue-table] usePresets.renamePreset: system presets cannot be renamed");
+		await client.renamePreset(id, label);
+		await maybeReloadAfterMutation();
+	}
+	async function deletePreset(id) {
+		if (isSystemPresetId(id)) throw new Error("[vue-table] usePresets.deletePreset: system presets cannot be deleted");
+		await client.deletePreset(id);
+		if (activePresetId.value === id) activePresetId.value = STANDARD_PRESET_ID;
+		await maybeReloadAfterMutation();
+	}
+	async function togglePublic(id) {
+		if (isSystemPresetId(id)) throw new Error("[vue-table] usePresets.togglePublic: system presets are not public");
+		const row = presetsById.value.get(id);
+		if (!row) return;
+		await client.setPublic(id, row.public !== true);
+		await maybeReloadAfterMutation();
+	}
+	async function setDefault(id) {
+		const user = currentUser.value ?? void 0;
+		await client.upsertUserConf(userConf.value, { defaultPresetId: id ?? void 0 }, user);
+		await maybeReloadAfterMutation();
+	}
+	async function toggleFav(id) {
+		const current = (userConf.value?.data)?.favPresetIds;
+		const set = new Set(current ?? []);
+		if (set.has(id)) set.delete(id);
+		else set.add(id);
+		await setFavorites([...set]);
+	}
+	async function setFavorites(ids) {
+		const user = currentUser.value ?? void 0;
+		await client.upsertUserConf(userConf.value, { favPresetIds: ids }, user);
+		if (userConf.value) userConf.value = {
+			...userConf.value,
+			data: {
+				...userConf.value.data,
+				favPresetIds: ids
+			}
+		};
+		await maybeReloadAfterMutation();
+	}
+	if (opts.autoLoad !== false) reload();
+	return {
+		presets,
+		presetsById,
+		userConf,
+		capabilities,
+		systemPresets: systemPresetsResolved,
+		systemPresetsById,
+		available,
+		loading,
+		error,
+		currentUser,
+		activePresetId,
+		activePreset,
+		isOwned,
+		reload,
+		batch,
+		savePreset,
+		savePresetAs,
+		renamePreset,
+		deletePreset,
+		togglePublic,
+		setDefault,
+		toggleFav,
+		setFavorites
+	};
+}
+//#endregion
+//#region src/composables/use-table.ts
+/** Thin alias over `resetMetaCache` — retained so existing test code keeps working. */
+function clearTableCache() {
+	resetMetaCache();
+}
+/**
+* Main entry composable for table setup.
+*
+* @param url — Table endpoint URL (e.g. "/db/tables/products")
+*/
+function useTable(url, opts) {
+	const entry = getMetaEntry(url, opts?.clientFactory);
+	if (!entry.tableDef) entry.tableDef = Promise.all([entry.meta, entry.type]).then(([meta, type]) => createTableDef(meta, type));
+	const { client } = entry;
+	const defPromise = entry.tableDef;
+	const preset = opts?.preset;
+	const presetsHandle = preset ? usePresets({
+		url: preset.url,
+		tableKey: preset.tableKey,
+		app: preset.app,
+		clientFactory: opts?.clientFactory,
+		systemPresets: preset.systemPresets
+	}) : null;
+	const draftHandle = preset ? useLocalDraft({
+		app: injectPresetsApp(preset.app),
+		tableKey: preset.tableKey,
+		enabled: preset.persistDrafts ?? false,
+		availableAspects: preset.aspects ?? DEFAULT_AVAILABLE_ASPECTS
+	}) : null;
+	const { state, internals } = createTableState({
+		client,
+		limit: opts?.limit,
+		selection: {
+			rowValueFn: opts?.rowValueFn,
+			selectedRows: opts?.selectedRows
+		},
+		model: {
+			filterFields: opts?.filterFields,
+			columnNames: opts?.columnNames,
+			columnWidths: opts?.columnWidths,
+			sorters: opts?.sorters
+		},
+		query: {
+			fn: opts?.queryFn,
+			forceFilters: opts?.forceFilters,
+			forceSorters: opts?.forceSorters,
+			alwaysSelected: opts?.alwaysSelected,
+			blockQuery: opts?.blockQuery,
+			queryOnMount: opts?.queryOnMount,
+			urlQueryReady: opts?.urlQueryReady,
+			onUrlQueryChange: opts?.onUrlQueryChange,
+			urlQuerySync: opts?.urlQuerySync
+		},
+		window: {
+			blockSize: opts?.blockSize,
+			dragReleaseDebounceMs: opts?.dragReleaseDebounceMs
+		},
+		actions: {
+			refreshOnAction: opts?.refreshOnAction,
+			onResolved: opts?.onActionResolved
+		},
+		preset: {
+			presetsHandle,
+			draftHandle,
+			availableAspects: preset?.aspects,
+			persistDrafts: preset?.persistDrafts ?? false
+		}
+	});
+	useTableSelection(state, { mode: opts?.selectionPersistence ?? "trim" });
+	if (opts?.provideContext !== false) provideTableContext({
+		state,
+		client,
+		controls: opts?.controls ?? {},
+		types: opts?.types,
+		components: opts?.components,
+		formTypes: opts?.formTypes,
+		formComponents: opts?.formComponents
+	});
+	defPromise.then((def) => {
+		internals.init(def);
+	}).catch((err) => {
+		state.metadataError.value = err instanceof Error ? err : new Error(String(err));
+	}).finally(() => {
+		state.loadingMetadata.value = false;
+	});
+	return state;
+}
+//#endregion
+export { AS_PRESETS_APP as a, useLocalDraft as i, useTable as n, injectPresetsApp as o, usePresets as r, clearTableCache as t };

package/dist/{use-table-column-handlers-CGYAY2xH.cjs → use-table-column-handlers-BgC4gUJV.cjs}

@@ -1,17 +1,4 @@
-let vue = require("vue");
 let _atscript_ui_table = require("@atscript/ui-table");
-//#region src/composables/use-has-emit-listener.ts
-/**
-* Returns true when the parent component bound a v-on listener for `emitName`
-* (e.g. `onMainAction` for `@main-action`). Reads `inst.vnode.props` — the
-* same property Vue uses to dispatch emit listeners. Non-reactive: a parent
-* remount via `v-if` re-evaluates at the new mount.
-*/
-function useHasEmitListener(emitName) {
-	const inst = (0, vue.getCurrentInstance)();
-	return (0, vue.computed)(() => !!inst?.vnode.props?.[emitName]);
-}
-//#endregion
 //#region src/composables/use-table-column-handlers.ts
 /**
 * Pure pass-through handlers shared between the pagination renderer
@@ -51,12 +38,6 @@ function useTableColumnHandlers(state) {
 	};
 }
 //#endregion
-Object.defineProperty(exports, "useHasEmitListener", {
-	enumerable: true,
-	get: function() {
-		return useHasEmitListener;
-	}
-});
 Object.defineProperty(exports, "useTableColumnHandlers", {
 	enumerable: true,
 	get: function() {

package/dist/{use-table-column-handlers-t6xi1yCE.mjs → use-table-column-handlers-cm0GxR2u.mjs}

@@ -1,17 +1,4 @@
-import { computed, getCurrentInstance } from "vue";
 import { reorderColumnNames } from "@atscript/ui-table";
-//#region src/composables/use-has-emit-listener.ts
-/**
-* Returns true when the parent component bound a v-on listener for `emitName`
-* (e.g. `onMainAction` for `@main-action`). Reads `inst.vnode.props` — the
-* same property Vue uses to dispatch emit listeners. Non-reactive: a parent
-* remount via `v-if` re-evaluates at the new mount.
-*/
-function useHasEmitListener(emitName) {
-	const inst = getCurrentInstance();
-	return computed(() => !!inst?.vnode.props?.[emitName]);
-}
-//#endregion
 //#region src/composables/use-table-column-handlers.ts
 /**
 * Pure pass-through handlers shared between the pagination renderer
@@ -51,4 +38,4 @@ function useTableColumnHandlers(state) {
 	};
 }
 //#endregion
-export { useHasEmitListener as n, useTableColumnHandlers as t };
+export { useTableColumnHandlers as t };

package/dist/use-table-component-BbETnUuy.mjs

@@ -0,0 +1,12 @@
+import { o as useTableContextOptional } from "./use-table-state-CuZ2OXoY.mjs";
+//#region src/composables/use-table-component.ts
+/**
+* Resolve a single skin-slot component from the injected `controls` map,
+* falling back to the default. Safe to call outside a table context (e.g.
+* a default mounted standalone in tests) — the fallback is returned.
+*/
+function useTableComponent(key, fallback) {
+	return useTableContextOptional()?.controls[key] ?? fallback;
+}
+//#endregion
+export { useTableComponent as t };

package/dist/use-table-component-CirEOQ_P.cjs

@@ -0,0 +1,17 @@
+const require_use_table_state = require("./use-table-state-DFQ30m-j.cjs");
+//#region src/composables/use-table-component.ts
+/**
+* Resolve a single skin-slot component from the injected `controls` map,
+* falling back to the default. Safe to call outside a table context (e.g.
+* a default mounted standalone in tests) — the fallback is returned.
+*/
+function useTableComponent(key, fallback) {
+	return require_use_table_state.useTableContextOptional()?.controls[key] ?? fallback;
+}
+//#endregion
+Object.defineProperty(exports, "useTableComponent", {
+	enumerable: true,
+	get: function() {
+		return useTableComponent;
+	}
+});

package/dist/use-table-nav-bridge-Bh1tpG0X.cjs

@@ -0,0 +1,57 @@
+const require_use_table_state = require("./use-table-state-DFQ30m-j.cjs");
+//#region src/composables/use-table-nav-bridge.ts
+function isPassthroughKey(event) {
+	const key = event.key;
+	const meta = event.metaKey;
+	const ctrl = event.ctrlKey;
+	const alt = event.altKey;
+	if (key === " ") return true;
+	if (key.length === 1 && !meta && !ctrl && !alt) return true;
+	if ((key === "Home" || key === "End") && !meta && !ctrl && !alt) return true;
+	return false;
+}
+/**
+* Construct a keyboard-bridge for an external `<input>` to drive table nav
+* without losing focus. Without args, injects the nearest `<as-table-root>`
+* context's state. With an explicit `state`, binds to that state. With
+* `opts.enterAction`, the returned bridge's `onKeydown` defaults to that
+* enter-action (per-call options still win).
+*
+* Each call returns a fresh bridge object — callers that need stable
+* identity should bind once at setup and reuse the binding.
+*/
+function useTableNavBridge(state, opts) {
+	let target = state;
+	if (!target) {
+		const ctx = require_use_table_state.useTableContextOptional();
+		if (!ctx) throw new Error("[vue-table] useTableNavBridge() called outside of <as-table-root>.");
+		target = ctx.state;
+	}
+	const bound = target;
+	const defaultEnterAction = opts?.enterAction;
+	const modeOpt = opts?.mode;
+	const readMode = () => {
+		if (typeof modeOpt === "function") return modeOpt();
+		return modeOpt ?? "none";
+	};
+	function onKeydown(event, callOpts) {
+		if (isPassthroughKey(event)) return;
+		bound.handleNavKey(event, {
+			enterAction: callOpts?.enterAction ?? defaultEnterAction,
+			mode: callOpts?.mode ?? readMode()
+		});
+	}
+	return {
+		onKeydown,
+		activeIndex: bound.activeIndex,
+		setActive: bound.setActive,
+		clearActive: bound.clearActive
+	};
+}
+//#endregion
+Object.defineProperty(exports, "useTableNavBridge", {
+	enumerable: true,
+	get: function() {
+		return useTableNavBridge;
+	}
+});

package/dist/use-table-nav-bridge-i8AjtjIt.mjs

@@ -0,0 +1,52 @@
+import { o as useTableContextOptional } from "./use-table-state-CuZ2OXoY.mjs";
+//#region src/composables/use-table-nav-bridge.ts
+function isPassthroughKey(event) {
+	const key = event.key;
+	const meta = event.metaKey;
+	const ctrl = event.ctrlKey;
+	const alt = event.altKey;
+	if (key === " ") return true;
+	if (key.length === 1 && !meta && !ctrl && !alt) return true;
+	if ((key === "Home" || key === "End") && !meta && !ctrl && !alt) return true;
+	return false;
+}
+/**
+* Construct a keyboard-bridge for an external `<input>` to drive table nav
+* without losing focus. Without args, injects the nearest `<as-table-root>`
+* context's state. With an explicit `state`, binds to that state. With
+* `opts.enterAction`, the returned bridge's `onKeydown` defaults to that
+* enter-action (per-call options still win).
+*
+* Each call returns a fresh bridge object — callers that need stable
+* identity should bind once at setup and reuse the binding.
+*/
+function useTableNavBridge(state, opts) {
+	let target = state;
+	if (!target) {
+		const ctx = useTableContextOptional();
+		if (!ctx) throw new Error("[vue-table] useTableNavBridge() called outside of <as-table-root>.");
+		target = ctx.state;
+	}
+	const bound = target;
+	const defaultEnterAction = opts?.enterAction;
+	const modeOpt = opts?.mode;
+	const readMode = () => {
+		if (typeof modeOpt === "function") return modeOpt();
+		return modeOpt ?? "none";
+	};
+	function onKeydown(event, callOpts) {
+		if (isPassthroughKey(event)) return;
+		bound.handleNavKey(event, {
+			enterAction: callOpts?.enterAction ?? defaultEnterAction,
+			mode: callOpts?.mode ?? readMode()
+		});
+	}
+	return {
+		onKeydown,
+		activeIndex: bound.activeIndex,
+		setActive: bound.setActive,
+		clearActive: bound.clearActive
+	};
+}
+//#endregion
+export { useTableNavBridge as t };

package/dist/use-table-selection-C84z4OZy.mjs

@@ -0,0 +1,59 @@
+import { watch } from "vue";
+import { trimSelection } from "@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) {
+	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";
+	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 = trimSelection(state.selectedRows.value, presentPks);
+	});
+}
+//#endregion
+export { useTableSelection as n, useSelectModeReset as t };