@atscript/vue-table 0.1.97 → 0.1.98

package/dist/use-table-CLsp2mAu.cjs

@@ -0,0 +1,475 @@
+const require_use_table_state = require("./use-table-state-DFQ30m-j.cjs");
+const require_use_table_selection = require("./use-table-selection-Cmiu1h4S.cjs");
+let _atscript_ui = require("@atscript/ui");
+let vue = require("vue");
+let _atscript_ui_table = require("@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 = (0, vue.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 ((0, vue.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 || (0, _atscript_ui_table.isEmptyDraft)(draft)) return applied;
+		const overlay = (0, _atscript_ui_table.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 = (0, _atscript_ui_table.serializeDraft)(current, opts.availableAspects);
+			if ((0, _atscript_ui_table.isEmptyDraft)(draft)) {
+				clear();
+				lastDraftSerialized = "";
+				return;
+			}
+			const draftSerialized = (0, _atscript_ui_table.stableStringify)(draft);
+			if (preset !== lastPresetRef) {
+				lastPresetRef = preset;
+				lastPresetSerialized = (0, _atscript_ui_table.stableStringify)((0, _atscript_ui_table.serializeDraft)(preset, opts.availableAspects));
+			}
+			if (draftSerialized === lastPresetSerialized) {
+				clear();
+				lastDraftSerialized = "";
+				return;
+			}
+			if (draftSerialized === lastDraftSerialized) return;
+			lastDraftSerialized = draftSerialized;
+			writeDraft(draft);
+		}
+		const flushDebounced = (0, _atscript_ui_table.debounce)(((current, preset) => flush(current, preset)), debounceMs);
+		const stop = (0, vue.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 _atscript_ui_table.PresetsClient({
+		url: opts.url,
+		app,
+		tableKey: opts.tableKey,
+		clientFactory: opts.clientFactory
+	});
+	const systemPresetsResolved = (0, vue.computed)(() => (0, _atscript_ui_table.resolveSystemPresets)(opts.systemPresets));
+	const presets = (0, vue.shallowRef)([]);
+	const userConf = (0, vue.shallowRef)(null);
+	const capabilities = (0, vue.ref)(null);
+	const loading = (0, vue.ref)(false);
+	const error = (0, vue.ref)(null);
+	const denied = (0, vue.ref)(false);
+	const activePresetId = (0, vue.ref)(null);
+	const available = (0, vue.computed)(() => !denied.value);
+	const presetsById = (0, vue.computed)(() => {
+		const map = /* @__PURE__ */ new Map();
+		for (const row of presets.value) map.set(row.id, row);
+		return map;
+	});
+	const systemPresetsById = (0, vue.computed)(() => {
+		const map = /* @__PURE__ */ new Map();
+		for (const sp of systemPresetsResolved.value) map.set(sp.id, sp);
+		return map;
+	});
+	const activePreset = (0, vue.computed)(() => {
+		const id = activePresetId.value;
+		if (!id) return null;
+		if ((0, _atscript_ui_table.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 = (0, vue.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 ((0, _atscript_ui_table.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 ((0, _atscript_ui_table.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 ((0, _atscript_ui_table.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 ((0, _atscript_ui_table.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 ((0, _atscript_ui_table.isSystemPresetId)(id)) throw new Error("[vue-table] usePresets.deletePreset: system presets cannot be deleted");
+		await client.deletePreset(id);
+		if (activePresetId.value === id) activePresetId.value = _atscript_ui_table.STANDARD_PRESET_ID;
+		await maybeReloadAfterMutation();
+	}
+	async function togglePublic(id) {
+		if ((0, _atscript_ui_table.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() {
+	(0, _atscript_ui.resetMetaCache)();
+}
+/**
+* Main entry composable for table setup.
+*
+* @param url — Table endpoint URL (e.g. "/db/tables/products")
+*/
+function useTable(url, opts) {
+	const entry = (0, _atscript_ui.getMetaEntry)(url, opts?.clientFactory);
+	if (!entry.tableDef) entry.tableDef = Promise.all([entry.meta, entry.type]).then(([meta, type]) => (0, _atscript_ui.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 ?? require_use_table_state.DEFAULT_AVAILABLE_ASPECTS
+	}) : null;
+	const { state, internals } = require_use_table_state.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
+		}
+	});
+	require_use_table_selection.useTableSelection(state, { mode: opts?.selectionPersistence ?? "trim" });
+	if (opts?.provideContext !== false) require_use_table_state.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
+Object.defineProperty(exports, "AS_PRESETS_APP", {
+	enumerable: true,
+	get: function() {
+		return AS_PRESETS_APP;
+	}
+});
+Object.defineProperty(exports, "clearTableCache", {
+	enumerable: true,
+	get: function() {
+		return clearTableCache;
+	}
+});
+Object.defineProperty(exports, "injectPresetsApp", {
+	enumerable: true,
+	get: function() {
+		return injectPresetsApp;
+	}
+});
+Object.defineProperty(exports, "useLocalDraft", {
+	enumerable: true,
+	get: function() {
+		return useLocalDraft;
+	}
+});
+Object.defineProperty(exports, "usePresets", {
+	enumerable: true,
+	get: function() {
+		return usePresets;
+	}
+});
+Object.defineProperty(exports, "useTable", {
+	enumerable: true,
+	get: function() {
+		return useTable;
+	}
+});