@atscript/vue-table 0.1.58

package/dist/index.mjs

@@ -0,0 +1,505 @@
+import { a as useTableContext, d as extractIdentifier, g as ROW_ACTIONS_TYPE, n as createTableState, o as useTableContextOptional, t as createStaticTableState } from "./use-table-state-C4JbonEZ.mjs";
+import { s as useTableSelection } from "./as-table-status-BjRGGuhC.mjs";
+import { a as useLocalDraft, i as usePresets, n as clearTableCache, o as AS_PRESETS_APP, r as useTable, s as injectPresetsApp, t as as_filter_field_default } from "./as-filter-field-Bqvu2ASN.mjs";
+import { n as useTableNavBridge, t as as_filter_dialog_default } from "./as-filter-dialog-C0HMpUPT.mjs";
+import "./use-table-column-handlers-t6xi1yCE.mjs";
+import { t as getCellValue } from "./get-cell-value-DiH84HKL.mjs";
+import "./as-cell-json-popover-DUq25I0L.mjs";
+import { t as as_cell_array_default } from "./as-cell-array-DOQKR6t5.mjs";
+import { t as as_cell_date_default } from "./as-cell-date-Cq49RHmL.mjs";
+import { n as useCellLocale, t as provideCellLocale } from "./use-cell-locale-1uQaFTLQ.mjs";
+import { t as as_cell_json_default } from "./as-cell-json-BynWIs1d.mjs";
+import { t as as_cell_number_default } from "./as-cell-number-Bc1C97Vg.mjs";
+import { t as formatCellValue } from "./format-cell-B2xMDYO9.mjs";
+import { t as as_cell_union_default } from "./as-cell-union-C1w3B38J.mjs";
+import { t as as_column_menu_default } from "./as-column-menu-DCfhorMP.mjs";
+import { t as as_config_dialog_default } from "./as-config-dialog-vRklaKbi.mjs";
+import { t as as_confirm_dialog_default } from "./as-confirm-dialog-BLh3Ju4-.mjs";
+import { t as as_filter_input_default } from "./as-filter-input-P1i0CW2-.mjs";
+import { t as as_table_cell_value_default } from "./as-table-cell-value-B1CiJYFn.mjs";
+import { t as as_table_header_cell_default } from "./as-table-header-cell-CBn_ioCe.mjs";
+import { t as as_window_table_default } from "./as-window-table-CKIfo3M_.mjs";
+import "./as-table-base-D0k4k7k_.mjs";
+import { t as as_filters_default } from "./as-filters-Bxa9ZEMm.mjs";
+import "./preset-aspect-display-BYeiSgcc.mjs";
+import { t as as_preset_dialog_default } from "./as-preset-dialog-BdDRgwf_.mjs";
+import "./as-action-menu-content-CXsdPn42.mjs";
+import { t as as_row_actions_default } from "./as-row-actions-CeWBBGqh.mjs";
+import { t as as_table_root_default } from "./as-table-root-gG7pTIdD.mjs";
+import { t as as_table_default } from "./as-table-Cnw2fOqZ.mjs";
+import { t as as_table_actions_default } from "./as-table-actions-BpMiNFni.mjs";
+import { t as as_preset_picker_default } from "./as-preset-picker-BQbNEiy9.mjs";
+import { getDefaultClientFactory, resetDefaultClientFactory, setDefaultClientFactory } from "@atscript/ui";
+import { computed, effectScope, ref, shallowRef } from "vue";
+import { AppPrefsClient, PRESET_ASPECTS, STANDARD_PRESET_ID, SYSTEM_PRESET_PREFIX, columnFilterType, conditionsForType, defaultCondition, isAuthError, isFilled, isSystemPresetId, resolveSystemPresets } from "@atscript/ui-table";
+import { StorageSerializers, useEventBus, useStorage } from "@vueuse/core";
+//#region src/composables/use-table-filter.ts
+/**
+* Per-field filter state composable.
+*
+* Creates a working copy of filter conditions (cancel-safe dialog model).
+* Call `apply()` to commit, `reset()` to revert, `clear()` to remove.
+*
+* Accepts `state` directly rather than injecting — safe to call outside `setup`.
+*/
+function useTableFilter(column, state) {
+	const filterType = columnFilterType(column.type);
+	const availableConditions = conditionsForType(filterType, column.nullable);
+	const defCondition = defaultCondition(filterType);
+	function cloneConditions() {
+		const existing = state.filters.value[column.path];
+		if (existing && existing.length > 0) return existing.map((c) => ({
+			type: c.type,
+			value: [...c.value]
+		}));
+		return [{
+			type: defCondition,
+			value: []
+		}];
+	}
+	const conditions = ref(cloneConditions());
+	const filledCount = computed(() => conditions.value.filter(isFilled).length);
+	function addCondition() {
+		conditions.value = [...conditions.value, {
+			type: defCondition,
+			value: []
+		}];
+	}
+	function removeCondition(index) {
+		conditions.value = conditions.value.filter((_, i) => i !== index);
+		if (conditions.value.length === 0) conditions.value = [{
+			type: defCondition,
+			value: []
+		}];
+	}
+	function updateCondition(index, update) {
+		conditions.value = conditions.value.map((c, i) => i === index ? {
+			...c,
+			...update
+		} : c);
+	}
+	function apply() {
+		state.setFieldFilter(column.path, conditions.value);
+	}
+	function clear() {
+		state.removeFieldFilter(column.path);
+		conditions.value = [{
+			type: defCondition,
+			value: []
+		}];
+	}
+	function reset() {
+		conditions.value = cloneConditions();
+	}
+	return {
+		filterType,
+		availableConditions,
+		defaultCondition: defCondition,
+		conditions,
+		filledCount,
+		addCondition,
+		removeCondition,
+		updateCondition,
+		apply,
+		clear,
+		reset
+	};
+}
+//#endregion
+//#region src/composables/use-table-search.ts
+/**
+* Convenience composable for wiring a search input to the table.
+* Must be called inside an `<AsTableRoot>` subtree.
+*
+* Returns the reactive `searchTerm` ref and an `onSearchInput` handler.
+* The central filter/search watcher debounces the auto-query.
+*/
+function useTableSearch() {
+	const { state } = useTableContext();
+	function onSearchInput(event) {
+		state.searchTerm.value = event.target.value;
+	}
+	return {
+		searchTerm: state.searchTerm,
+		onSearchInput
+	};
+}
+//#endregion
+//#region src/composables/use-table-actions.ts
+/**
+* Inject the table-actions namespace from the closest `<AsTableRoot>` ancestor.
+* Returns `state.actions` directly — no wrapping. Throws when called outside
+* the provider tree (delegated to `useTableContext`).
+*
+* Useful for consumers that want the model without the chrome (custom
+* toolbars, headless action buttons, programmatic invoke).
+*/
+function useTableActions() {
+	return useTableContext().state.actions;
+}
+//#endregion
+//#region src/composables/use-table-url-query.ts
+/**
+* Split a uniqu URL string on top-level `&` separators, respecting
+* single-quoted string literals (`name='foo&bar'` is one segment, not two).
+* Within a quote, `\'` escapes a literal apostrophe per @uniqu/url's encoder.
+* Empty segments (from leading/trailing/double `&`) are dropped.
+*/
+function splitSegments(urlString) {
+	if (!urlString) return [];
+	const out = [];
+	let start = 0;
+	let inQuote = false;
+	const push = (end) => {
+		if (end > start) out.push(urlString.slice(start, end));
+	};
+	for (let i = 0; i < urlString.length; i++) {
+		const c = urlString[i];
+		if (c === "\\" && inQuote) {
+			i++;
+			continue;
+		}
+		if (c === "'") inQuote = !inQuote;
+		else if (c === "&" && !inQuote) {
+			push(i);
+			start = i + 1;
+		}
+	}
+	push(urlString.length);
+	return out;
+}
+const KEY_CHAR = /[A-Za-z0-9_.$-]/;
+/**
+* Index of `=` if every char before it is URL-key-safe. Returns -1 when any
+* non-key char (uniqu operator, whitespace, etc.) appears first — those
+* segments must round-trip as a single bare key because vue-router's `query`
+* record has no encoding for non-`=` separators.
+*/
+function findCleanEq(segment) {
+	for (let i = 0; i < segment.length; i++) {
+		const c = segment[i];
+		if (c === "=") return i > 0 ? i : -1;
+		if (!KEY_CHAR.test(c)) return -1;
+	}
+	return -1;
+}
+/**
+* Bridge `<AsTableRoot v-model:url-query>` to vue-router. Uses **type-only**
+* imports of `Router` and `RouteLocationNormalizedLoaded` — no runtime
+* dependency on `vue-router` is added to `@atscript/vue-table`. Consumers
+* pass in their already-resolved `useRoute()` and `useRouter()` instances.
+*
+* Scope: **owns the whole query string**. The getter returns the entire
+* `route.query` serialized; the setter replaces `route.query` wholesale.
+* Apps that need the table to coexist with non-table query params should
+* write their own `computed` instead — that pattern is small and keeps the
+* library's contract crisp.
+*
+* @example
+* ```vue
+* <script setup>
+* import { useRoute, useRouter } from 'vue-router';
+* import { useTableUrlQuery } from '@atscript/vue-table';
+* const urlQuery = useTableUrlQuery(useRoute(), useRouter());
+* <\/script>
+* <template>
+*   <AsTableRoot v-model:url-query="urlQuery" url="/db/products" .../>
+* </template>
+* ```
+*/
+function useTableUrlQuery(route, router, opts = {}) {
+	const navigate = (opts.mode ?? "replace") === "push" ? router.push.bind(router) : router.replace.bind(router);
+	return computed({
+		get: () => {
+			const q = route.query;
+			const parts = [];
+			for (const key in q) {
+				const v = q[key];
+				if (Array.isArray(v)) for (const item of v) parts.push(item == null ? key : `${key}=${item}`);
+				else if (v == null) parts.push(key);
+				else parts.push(`${key}=${v}`);
+			}
+			return parts.join("&");
+		},
+		set: (urlString) => {
+			const query = {};
+			for (const segment of splitSegments(urlString)) {
+				const eqIdx = findCleanEq(segment);
+				if (eqIdx > 0) query[segment.slice(0, eqIdx)] = segment.slice(eqIdx + 1);
+				else query[segment] = null;
+			}
+			navigate({ query });
+		}
+	});
+}
+//#endregion
+//#region src/composables/use-app-prefs.ts
+const APP_PREFS_BUS = Symbol("as-app-prefs");
+const CACHE_PREFIX = "as-app-prefs";
+const REGISTRY = /* @__PURE__ */ new Map();
+function instanceKey(app, url) {
+	return `${app}|${url}`;
+}
+/**
+* Public dev-facing composable for app-wide user preferences. Independent
+* of presets / tables — devs can use it on any settings surface to read
+* and write `appearance`, `language`, `density`, `customJson` etc. for
+* `(currentUser, app)`.
+*
+* Multiple calls with the same `(app, url)` share one underlying instance,
+* so duplicate widgets (sidebar + page header + /preferences) make a single
+* `/query?type=appConf` request total.
+*
+* @example
+* ```ts
+* const { prefs, save } = useAppPrefs({ url: "/db/_presets" })
+* // prefs.value.appearance is reactive in templates
+* await save({ appearance: "dark" })
+* ```
+*/
+function useAppPrefs(opts) {
+	const app = injectPresetsApp(opts.app);
+	const key = instanceKey(app, opts.url);
+	const existing = REGISTRY.get(key);
+	if (existing) {
+		const requested = opts.cache !== false;
+		if (requested !== existing.cacheEnabled) console.warn(`[vue-table] useAppPrefs("${app}", "${opts.url}"): cache=${requested} ignored — first caller registered cache=${existing.cacheEnabled}.`);
+		return existing.public;
+	}
+	const instance = createInstance(app, opts);
+	REGISTRY.set(key, instance);
+	return instance.public;
+}
+function createInstance(app, opts) {
+	const scope = effectScope(true);
+	return scope.run(() => {
+		const cacheEnabled = opts.cache !== false;
+		const client = new AppPrefsClient({
+			url: opts.url,
+			app,
+			clientFactory: opts.clientFactory
+		});
+		const cacheKey = `${CACHE_PREFIX}:${app}`;
+		const cache = cacheEnabled ? useStorage(cacheKey, null, void 0, {
+			listenToStorageChanges: true,
+			serializer: StorageSerializers.object,
+			flush: "sync"
+		}) : ref(null);
+		function clearCache() {
+			cache.value = null;
+			if (cacheEnabled) try {
+				globalThis.localStorage?.removeItem(cacheKey);
+			} catch {}
+		}
+		const prefs = computed({
+			get: () => cache.value ?? {},
+			set: (value) => {
+				cache.value = value;
+			}
+		});
+		const existing = shallowRef(null);
+		const loading = ref(false);
+		const error = ref(null);
+		const denied = ref(false);
+		const available = computed(() => !denied.value);
+		const channel = createChannel(app);
+		async function reload() {
+			loading.value = true;
+			error.value = null;
+			try {
+				const result = await client.load();
+				if (result.denied) {
+					denied.value = true;
+					clearCache();
+					existing.value = null;
+					return;
+				}
+				denied.value = false;
+				cache.value = { ...result.prefs };
+				existing.value = result.row;
+			} catch (err) {
+				if (isAuthError(err)) {
+					denied.value = true;
+					clearCache();
+					existing.value = null;
+					return;
+				}
+				error.value = err;
+				console.warn("[vue-table] useAppPrefs load failed:", err);
+			} finally {
+				loading.value = false;
+			}
+		}
+		async function save(patch) {
+			const prev = { ...prefs.value };
+			cache.value = {
+				...prev,
+				...patch
+			};
+			try {
+				const id = await client.save(existing.value, patch);
+				if (!existing.value && id) existing.value = {
+					id,
+					type: "appConf",
+					app,
+					user: "",
+					data: { ...prefs.value },
+					createdAt: 0,
+					updatedAt: 0
+				};
+				const snapshot = { ...prefs.value };
+				bus.emit({
+					app,
+					prefs: snapshot,
+					row: existing.value
+				});
+				channel?.postMessage({
+					type: "save",
+					prefs: snapshot,
+					row: existing.value
+				});
+			} catch (err) {
+				cache.value = prev;
+				throw err;
+			}
+		}
+		function reset() {
+			clearCache();
+			existing.value = null;
+			error.value = null;
+			denied.value = false;
+			bus.emit({
+				app,
+				reset: true
+			});
+			channel?.postMessage({ type: "reset" });
+		}
+		const bus = useEventBus(APP_PREFS_BUS);
+		bus.on((payload) => {
+			if (payload.app !== app) return;
+			if ("reset" in payload) {
+				clearCache();
+				existing.value = null;
+				return;
+			}
+			cache.value = { ...payload.prefs };
+			if (payload.row && !existing.value) existing.value = payload.row;
+		});
+		channel?.addEventListener("message", (e) => {
+			const msg = e.data;
+			if (!msg || typeof msg !== "object") return;
+			if (msg.type === "reset") {
+				clearCache();
+				existing.value = null;
+				return;
+			}
+			if (msg.type === "save") {
+				cache.value = { ...msg.prefs };
+				if (msg.row && !existing.value) existing.value = msg.row;
+			}
+		});
+		if (opts.autoLoad !== false && typeof window !== "undefined") reload();
+		return {
+			cacheEnabled,
+			public: {
+				prefs,
+				loading,
+				error,
+				available,
+				reload,
+				save,
+				reset
+			},
+			dispose() {
+				channel?.close();
+				scope.stop();
+			}
+		};
+	});
+}
+function createChannel(app) {
+	if (typeof window === "undefined") return null;
+	if (typeof BroadcastChannel !== "function") return null;
+	try {
+		return new BroadcastChannel(`as-app-prefs:${app}`);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/composables/use-table-component.ts
+/** Resolve a single skin-slot component from the injected `controls` map, falling back to the default. */
+function useTableComponent(key, fallback) {
+	const { controls } = useTableContext();
+	return controls[key] ?? fallback;
+}
+//#endregion
+//#region src/composables/create-default-controls.ts
+/**
+* Returns a fresh skin-slot map pre-filled with all built-in defaults.
+*
+* Spread or assign additional entries to override specific pieces:
+* ```ts
+* const controls = { ...createDefaultControls(), filterDialog: MyFilterDialog }
+* ```
+*
+* `actionFormDialog` is intentionally not seeded — the table root
+* lazy-mounts it only when an `@InputForm` action is detected. To override
+* or eager-load, import from `@atscript/vue-table/as-action-form-dialog`
+* and assign it as the `actionFormDialog` entry on this map.
+*/
+function createDefaultControls() {
+	return {
+		headerCell: as_table_header_cell_default,
+		columnMenu: as_column_menu_default,
+		filterDialog: as_filter_dialog_default,
+		filterInput: as_filter_input_default,
+		filterField: as_filter_field_default,
+		configDialog: as_config_dialog_default,
+		confirmDialog: as_confirm_dialog_default,
+		rowActions: as_row_actions_default
+	};
+}
+//#endregion
+//#region src/composables/create-default-cell-types.ts
+/**
+* Returns a fresh cell-type-to-component map pre-filled with the built-in
+* defaults. Spread to extend or override:
+* ```ts
+* const types = { ...createDefaultCellTypes(), status: StatusBadgeCell }
+* ```
+*/
+function createDefaultCellTypes() {
+	return {
+		text: as_table_cell_value_default,
+		number: as_cell_number_default,
+		boolean: as_table_cell_value_default,
+		date: as_cell_date_default,
+		datetime: as_cell_date_default,
+		relative: as_cell_date_default,
+		array: as_cell_array_default,
+		object: as_cell_json_default,
+		union: as_cell_union_default,
+		enum: as_table_cell_value_default,
+		ref: as_table_cell_value_default,
+		[ROW_ACTIONS_TYPE]: as_row_actions_default
+	};
+}
+//#endregion
+//#region src/utils/column-width.ts
+const DEFAULT_WIDTHS = {
+	boolean: "5em",
+	number: "10em",
+	date: "13em",
+	datetime: "16em",
+	relative: "11em",
+	text: "15em",
+	array: "18em",
+	object: "18em"
+};
+/** Returns column width from annotation or type-based default. */
+function getColumnWidth(column) {
+	return column.width || DEFAULT_WIDTHS[column.type] || "15em";
+}
+//#endregion
+export { AS_PRESETS_APP, as_cell_array_default as AsCellArray, as_cell_date_default as AsCellDate, as_cell_json_default as AsCellJson, as_cell_number_default as AsCellNumber, as_column_menu_default as AsColumnMenu, as_config_dialog_default as AsConfigDialog, as_filter_dialog_default as AsFilterDialog, as_filter_field_default as AsFilterField, as_filter_input_default as AsFilterInput, as_filters_default as AsFilters, as_preset_dialog_default as AsPresetDialog, as_preset_picker_default as AsPresetPicker, as_row_actions_default as AsRowActions, as_table_default as AsTable, as_table_actions_default as AsTableActions, as_table_cell_value_default as AsTableCellValue, as_table_header_cell_default as AsTableHeaderCell, as_table_root_default as AsTableRoot, as_window_table_default as AsWindowTable, PRESET_ASPECTS, STANDARD_PRESET_ID, SYSTEM_PRESET_PREFIX, clearTableCache, createDefaultCellTypes, createDefaultControls, createStaticTableState, createTableState, extractIdentifier, formatCellValue, getCellValue, getColumnWidth, getDefaultClientFactory, injectPresetsApp, isSystemPresetId, provideCellLocale, resetDefaultClientFactory, resolveSystemPresets, setDefaultClientFactory, useAppPrefs, useCellLocale, useLocalDraft, usePresets, useTable, useTableActions, useTableComponent, useTableContext, useTableContextOptional, useTableFilter, useTableNavBridge, useTableSearch, useTableSelection, useTableUrlQuery };

package/dist/preset-aspect-display-BYeiSgcc.mjs

@@ -0,0 +1,43 @@
+import { derivePresetAspects } from "@atscript/ui-table";
+//#region src/composables/preset-aspect-display.ts
+const ASPECT_LABELS = {
+	columns: "Displayed Columns",
+	filters: "Displayed Filters",
+	filterOps: "Filter conditions",
+	sorters: "Sorters",
+	itemsPerPage: "Page size"
+};
+const ASPECT_ICONS = {
+	columns: "i-as-columns",
+	filters: "i-as-filter",
+	filterOps: "i-as-filter-ops",
+	sorters: "i-as-sorters",
+	itemsPerPage: "i-as-pin"
+};
+/**
+* Resolve the aspects a stored preset claims. Prefers the server-stamped
+* `aspects` column (cheap), falls back to deriving from `data.content` for
+* older rows or first paint after save before reload settles.
+*/
+function aspectsOf(row, availableAspects) {
+	if (Array.isArray(row.aspects) && row.aspects.length > 0) return row.aspects.filter((a) => availableAspects.includes(a));
+	const wire = row.data?.content;
+	if (!wire) return [];
+	return derivePresetAspects(wire).filter((a) => availableAspects.includes(a));
+}
+function readPresetLabel(row) {
+	return row.label ?? row.data?.label ?? row.id;
+}
+/**
+* Display name for the row's owner. `userLabel` (server-stamped via the
+* host's `getUserLabel` hook) is preferred so the UI shows "Alice" rather
+* than `usr_abc123`. `fallback` is returned when no name is available —
+* picker uses `""`, dialog uses `"—"`.
+*/
+function ownerNameOf(row, fallback = "") {
+	if (typeof row.userLabel === "string" && row.userLabel.length > 0) return row.userLabel;
+	if (typeof row.user === "string" && row.user.length > 0) return row.user;
+	return fallback;
+}
+//#endregion
+export { readPresetLabel as a, ownerNameOf as i, ASPECT_LABELS as n, aspectsOf as r, ASPECT_ICONS as t };

package/dist/preset-aspect-display-y8aal_EF.cjs

@@ -0,0 +1,72 @@
+let _atscript_ui_table = require("@atscript/ui-table");
+//#region src/composables/preset-aspect-display.ts
+const ASPECT_LABELS = {
+	columns: "Displayed Columns",
+	filters: "Displayed Filters",
+	filterOps: "Filter conditions",
+	sorters: "Sorters",
+	itemsPerPage: "Page size"
+};
+const ASPECT_ICONS = {
+	columns: "i-as-columns",
+	filters: "i-as-filter",
+	filterOps: "i-as-filter-ops",
+	sorters: "i-as-sorters",
+	itemsPerPage: "i-as-pin"
+};
+/**
+* Resolve the aspects a stored preset claims. Prefers the server-stamped
+* `aspects` column (cheap), falls back to deriving from `data.content` for
+* older rows or first paint after save before reload settles.
+*/
+function aspectsOf(row, availableAspects) {
+	if (Array.isArray(row.aspects) && row.aspects.length > 0) return row.aspects.filter((a) => availableAspects.includes(a));
+	const wire = row.data?.content;
+	if (!wire) return [];
+	return (0, _atscript_ui_table.derivePresetAspects)(wire).filter((a) => availableAspects.includes(a));
+}
+function readPresetLabel(row) {
+	return row.label ?? row.data?.label ?? row.id;
+}
+/**
+* Display name for the row's owner. `userLabel` (server-stamped via the
+* host's `getUserLabel` hook) is preferred so the UI shows "Alice" rather
+* than `usr_abc123`. `fallback` is returned when no name is available —
+* picker uses `""`, dialog uses `"—"`.
+*/
+function ownerNameOf(row, fallback = "") {
+	if (typeof row.userLabel === "string" && row.userLabel.length > 0) return row.userLabel;
+	if (typeof row.user === "string" && row.user.length > 0) return row.user;
+	return fallback;
+}
+//#endregion
+Object.defineProperty(exports, "ASPECT_ICONS", {
+	enumerable: true,
+	get: function() {
+		return ASPECT_ICONS;
+	}
+});
+Object.defineProperty(exports, "ASPECT_LABELS", {
+	enumerable: true,
+	get: function() {
+		return ASPECT_LABELS;
+	}
+});
+Object.defineProperty(exports, "aspectsOf", {
+	enumerable: true,
+	get: function() {
+		return aspectsOf;
+	}
+});
+Object.defineProperty(exports, "ownerNameOf", {
+	enumerable: true,
+	get: function() {
+		return ownerNameOf;
+	}
+});
+Object.defineProperty(exports, "readPresetLabel", {
+	enumerable: true,
+	get: function() {
+		return readPresetLabel;
+	}
+});