@atscript/vue-table 0.1.146 → 0.1.148

package/dist/{types-BEZ4_erB.d.mts → intent-scope-CvD4YOvf.d.mts}

@@ -1,37 +1,9 @@
 import { ColumnDef, PaginationControl, SortControl, TableDef } from "@atscript/ui";
 import { Component, ComputedRef, MaybeRefOrGetter, Ref, ShallowRef } from "vue";
-import { AsPresetEntryRow, AspectMask, ColumnWidthsMap, ConfigTab, DroppedFields, FieldFilters, PresetAspect, PresetCapabilities, PresetSnapshot, SelectionMode, SystemPreset, SystemPresetInput, TableStateMethods } from "@atscript/ui-table";
-import { ClientError, PageResult, TDbActionInfo, TDbActionProcessor, TDbDeleteResult } from "@atscript/db-client";
+import { AsPresetEntryRow, AspectMask, ColumnWidthsMap, ConfigTab, DroppedFields, FieldFilters, PresetAspect, PresetCapabilities, PresetSnapshot, SelectionMode, SelectionQuery, SystemPreset, SystemPresetInput, TableStateMethods } from "@atscript/ui-table";
+import { ClientError, PageResult, TDbActionInfo, TDbActionProcessor, TDbActionTargetSummary, TDbDeleteResult, TDbQueryTarget } from "@atscript/db-client";
 import { FilterExpr, Uniquery } from "@uniqu/core";
 
-//#region src/composables/state/intent-scope.d.ts
-/**
- * Per-action verdict of a gate: `true` keeps the action as is, `false` drops
- * it (hidden), a non-empty string keeps it DISABLED with that string as the
- * reason (`""` counts as `true`).
- */
-type ActionVerdict = boolean | string;
-type ActionGate = (a: TVueTableActionInfo) => ActionVerdict;
-interface ActionBuckets {
-  default: TVueTableActionInfo | undefined;
-  others: TVueTableActionInfo[];
-  rows: TVueTableActionInfo[];
-}
-/**
- * Build the identifier object to forward to `client.action` / `client.remove`.
- *
- * Per `@atscript/db-client` invariant #11, identifier bodies are object-only
- * — never bare scalars, even for single-field PK tables. This helper accepts:
- * - a row-shaped object (default `rowValueFn`) → picks `preferredId` fields;
- * - a scalar value when `preferredId` has exactly one field (consumers that
- *   override `rowValueFn` to return the PK scalar) → wraps it.
- *
- * Returns `undefined` when no `preferredId` is declared, the source is
- * `null`/`undefined`, or a scalar can't be paired with a single-field
- * identifier.
- */
-declare function extractIdentifier(source: unknown, preferredId: readonly string[]): Record<string, unknown> | undefined;
-//#endregion
 //#region src/composables/state/row-actions-config.d.ts
 /**
  * A {@link RowActionsConfig} compiled into the two passes a surface runs per
@@ -117,6 +89,65 @@ interface InvokeOpts {
    * Since 0.1.134.
    */
   row?: Record<string, unknown>;
+  /**
+   * Run a `'rows'` action on every row matching this query instead of on
+   * `pk` (pass `pk` as `undefined`): `client.actionOnQuery`. The action's
+   * `/meta` entry must carry `queryTarget`. Since 0.1.147.
+   */
+  target?: ActionQueryTarget;
+  /**
+   * With `target`: the match count the user confirmed. The server answers
+   * `TARGET_CHANGED` when the query matches a different number of rows by
+   * the time it runs. Since 0.1.147.
+   */
+  expectCount?: number;
+  /**
+   * With `target` + `expectCount`: asked once with the new count when the
+   * server answers `TARGET_CHANGED`. Resolve `true` to run again on the new
+   * count; `false` settles the action as that error. Since 0.1.147.
+   */
+  confirmTargetChange?: (matched: number) => Promise<boolean>;
+}
+/**
+ * "Every row matching this query, minus `exclude`" — the target of a
+ * query-targeted action run (`InvokeOpts.target`). The `filter` / `search`
+ * / `index` of the table's query, never its sorting or paging. Since 0.1.147.
+ */
+type ActionQueryTarget = Pick<TDbQueryTarget, "filter" | "search" | "index" | "exclude" | "maxRows">;
+/**
+ * A symbolic selection of every row matching the table's query (the "Select
+ * all N matching" banner), held in `state.querySelection`. Since 0.1.147.
+ */
+interface QuerySelection {
+  /** The filter / search / index the selection was made over. */
+  query: SelectionQuery;
+  /** `selectionSignature(query)` — a change of the live one drops the selection. */
+  signature: string;
+  /** `rowValueFn` values the user unticked after selecting all. */
+  excluded: unknown[];
+  /** Rows the query matched (`totalCount`), refreshed on same-scope refetches. */
+  total: number;
+}
+/**
+ * The selection as one value (`state.selection`): explicit row values, or
+ * every row matching a query minus the excluded ones. `count` is what the
+ * selection covers in both modes. Since 0.1.147.
+ */
+type TableSelection = {
+  mode: "ids";
+  ids: unknown[];
+  count: number;
+} | {
+  mode: "query";
+  query: SelectionQuery;
+  excluded: unknown[];
+  total: number;
+  count: number;
+};
+/** Why the table dropped a selection on its own (`selection-reset`). Since 0.1.147. */
+interface SelectionResetEvent {
+  /** `"scope"` — the filter, search or index changed under a query selection. */
+  reason: "scope";
 }
 /**
  * A row action the APP owns — it has no server counterpart, so the backend
@@ -185,6 +216,15 @@ type ActionResult = {
   kind: "backend";
   data: unknown;
   message?: string;
+  /**
+   * A query-targeted run (`InvokeOpts.target`): how many rows the query
+   * matched, and the handler's `TDbActionTargetSummary` when it returned
+   * one (a delegated action always does). Since 0.1.147.
+   */
+  target?: {
+    matched: number;
+    summary?: TDbActionTargetSummary;
+  };
 } | {
   ok: true;
   kind: "navigate";
@@ -235,6 +275,14 @@ interface TableActionsState {
    * `{ id: '...' }`.
    */
   invoke: (action: TVueTableActionInfo, pk?: Record<string, unknown> | Record<string, unknown>[], opts?: InvokeOpts) => Promise<ActionResult>;
+  /**
+   * How many rows a query-targeted run of `action` would cover right now
+   * (`client.countActionTarget` — a dry run, the handler does not run).
+   * Resolves `undefined` when the count failed; that failure is settled as
+   * the action's error result (`lastResult` + the `@action` emit), like an
+   * invoke. Since 0.1.147.
+   */
+  countTarget: (action: TVueTableActionInfo, target: ActionQueryTarget, event?: KeyboardEvent | MouseEvent) => Promise<number | undefined>;
   /** Set of action names with an in-flight invoke. */
   invoking: ShallowRef<Set<string>>;
   /** Latest result keyed by action name. */
@@ -305,6 +353,11 @@ interface ActionFormRequest {
   /** Identifier objects for the targeted rows (used by `$1`/`$N` substitution in dialog copy). */
   identifiers: Record<string, unknown>[];
   preferredId: readonly string[];
+  /**
+   * A query-targeted run: how many rows it covers (`identifiers` is empty
+   * then). The dialog shows it in the title. Since 0.1.147.
+   */
+  count?: number;
   /** Internal — the dialog never calls this directly; use accept/dismiss. */
   resolve: (input: unknown) => void;
 }
@@ -533,6 +586,19 @@ interface ReactiveTableState extends TableStateMethods {
    * when present, otherwise type+`@expect.maxLen`-derived (see `computeDefaultColumnWidth`).
    */
   columnWidths: Ref<ColumnWidthsMap>;
+  /**
+   * The app-authored `forceFilters` scope, read live. For chrome such as a
+   * "scoped to ..." badge. Since 0.1.148.
+   */
+  forceFilters: ComputedRef<FilterExpr | undefined>;
+  /** The app-authored `forceSorters`, read live (empty when none). Since 0.1.148. */
+  forceSorters: ComputedRef<SortControl[]>;
+  /**
+   * The IANA time zone the table reads dates in (`undefined` = the browser's):
+   * the `timeZone` option, else the cell locale's. Date filters, their chips
+   * and their inputs all follow it. Since 0.1.148.
+   */
+  timeZone: ComputedRef<string | undefined>;
   filterFields: ShallowRef<string[]>;
   filters: ShallowRef<FieldFilters>;
   /**
@@ -693,15 +759,62 @@ interface ReactiveTableState extends TableStateMethods {
   deselectAll: (rows: readonly Record<string, unknown>[]) => void;
   /**
    * The header checkbox's action over `rows`: deselect them when every
-   * eligible one is selected, otherwise select them. Since 0.1.142.
+   * eligible one is selected, otherwise select them. In a query selection
+   * a fully selected `rows` ends it. `indexOf` as in `selectAll` (since
+   * 0.1.147). Since 0.1.142.
    */
-  toggleAll: (rows: readonly Record<string, unknown>[]) => void;
+  toggleAll: (rows: readonly Record<string, unknown>[], indexOf?: (position: number) => number) => void;
   /**
    * Empty the selection — every pk, whether or not its row is loaded or
    * eligible. The header checkbox only ever acts on loaded rows; this is the
-   * real clear. Since 0.1.142.
+   * real clear. Ends a query selection too. Since 0.1.142.
    */
   clearSelection: () => void;
+  /**
+   * The symbolic "every row matching the query" selection, or `null` while
+   * the selection is the explicit `selectedRows` (bound by
+   * `v-model:query-selection` on `<AsTableRoot>`). While set, `selectedRows`
+   * is empty, row toggles edit `excluded`, `isPkSelected` is "not excluded"
+   * and `selectedCount` is `total − excluded.length`. Dropped (with a
+   * `selection-reset` `{ reason: "scope" }`) as soon as the filter, search
+   * or index changes — sorting, columns, paging and scrolling keep it. A
+   * successful query-targeted action clears it. Since 0.1.147.
+   */
+  querySelection: Ref<QuerySelection | null>;
+  /** The selection as one value, in either mode — see {@link TableSelection}. Since 0.1.147. */
+  selection: ComputedRef<TableSelection>;
+  /**
+   * Opt-in for selecting every row matching the query — writable ref owned
+   * by `<AsTableRoot>`'s `select-all-matching` prop (default `false`).
+   * Since 0.1.147.
+   */
+  allowSelectAllMatching: Ref<boolean>;
+  /**
+   * The renderer's `select` mode — writable ref pushed by `<AsTable>` /
+   * `<AsWindowTable>` (default `"none"`). Since 0.1.147.
+   */
+  selectMode: Ref<SelectionMode>;
+  /**
+   * `rowValueFn` values of the LOADED rows the `rowSelectable` predicate
+   * lets through — the set "all rows on this page" covers (every cached row
+   * in window mode). Since 0.1.147.
+   */
+  loadedEligiblePks: ComputedRef<unknown[]>;
+  /** How many of `loadedEligiblePks` are selected. Since 0.1.147. */
+  loadedSelectedCount: ComputedRef<number>;
+  /**
+   * Whether "Select all N matching" can be offered: `allowSelectAllMatching`
+   * ∧ `selectMode === "multi"` ∧ a server-backed table (no custom query
+   * function, not local mode) ∧ more matching rows than loaded ones
+   * ∧ at least one `'rows'` action that takes a query target. Since 0.1.147.
+   */
+  canSelectAllMatching: ComputedRef<boolean>;
+  /**
+   * Select every row matching the current query (filter, search, index —
+   * force filters and custom filter conditions included). A no-op unless
+   * {@link canSelectAllMatching}. Since 0.1.147.
+   */
+  selectAllMatching: () => void;
   /** Column currently open in the filter dialog (null when closed). */
   filterDialogColumn: Ref<ColumnDef | null>;
   /** Absolute index of the keyboard-active row. -1 = nothing active. */
@@ -793,7 +906,8 @@ interface ReactiveTableState extends TableStateMethods {
    */
   requestActionInput: (action: TVueTableActionInfo, ctx: {
     identifiers: Record<string, unknown>[];
-    preferredId: readonly string[];
+    preferredId: readonly string[]; /** A query-targeted run's row count (since 0.1.147). */
+    count?: number;
   }) => Promise<unknown>;
   /** Resolve the active form request with `input`. Internal — used by the dialog. */
   acceptActionForm: (input: unknown) => void;
@@ -1012,4 +1126,70 @@ interface PresetSurface {
   lastError: Ref<Error | null>;
 }
 //#endregion
-export { TableNavBridge as A, RowSelectableVerdict as C, TAsTableControls as D, TAsCellTypeComponents as E, extractIdentifier as M, TVueTableActionInfo as O, RowSelectableHook as S, SelectOn as T, RowActionsConfig as _, ConfirmOptions as a, RowDeleteOpt as b, InvokeOpts as c, NavKeyOptions as d, PresetConfig as f, RowActionsColumnPlacement as g, ResolvedRowActions as h, ConfigTab as i, resolveRowActions as j, TableActionsState as k, LocalRowAction as l, ReactiveTableState as m, ApplyUrlQueryOptions as n, DroppedFieldsReport as o, QueryErrorKind as p, ColumnMenuConfig as r, EnterAction as s, ActionResult as t, MainActionRequest as u, RowAttrsHook as v, SelectAllState as w, RowHookContext as x, RowClassHook as y };
+//#region src/composables/state/intent-scope.d.ts
+/**
+ * Per-action verdict of a gate: `true` keeps the action as is, `false` drops
+ * it (hidden), a non-empty string keeps it DISABLED with that string as the
+ * reason (`""` counts as `true`).
+ */
+type ActionVerdict = boolean | string;
+type ActionGate = (a: TVueTableActionInfo) => ActionVerdict;
+interface ActionBuckets {
+  default: TVueTableActionInfo | undefined;
+  others: TVueTableActionInfo[];
+  rows: TVueTableActionInfo[];
+}
+/** Disabled reason of a non-query-target action in a query selection. Since 0.1.147. */
+declare const QUERY_TARGET_UNSUPPORTED_REASON = "Not available for all matching rows \u2014 select rows individually";
+/**
+ * The gate a query selection ("every row matching the query") puts on the
+ * `'rows'` actions: enabled iff the action takes a query target
+ * (`queryTarget`) of at least `count` rows; otherwise kept DISABLED with the
+ * reason ({@link QUERY_TARGET_UNSUPPORTED_REASON}, or "At most {max} rows").
+ * The loaded rows' `$actions` are deliberately not consulted — a sample of
+ * the matching rows cannot speak for the rest; the server gates every row
+ * when the action runs. Since 0.1.147.
+ */
+declare function queryTargetGate(count: number): ActionGate;
+/**
+ * The fields an action identifier is built from — `tableDef.identifierFields`
+ * (`preferredId` plus every delegated action's `idMap` path), falling back to
+ * `preferredId` for a hand-built `TableDef` without it. Since 0.1.147.
+ */
+declare function identifierFieldsOf(def: TableDef | null | undefined): readonly string[];
+/**
+ * Build the identifier object to forward to `client.action` / `client.remove`.
+ *
+ * Per `@atscript/db-client` invariant #11, identifier bodies are object-only
+ * — never bare scalars, even for single-field PK tables. This helper accepts:
+ * - a row-shaped object (default `rowValueFn`) → picks the `fields` (a dot
+ *   path keeps the row's nesting: `ref.key` → `{ ref: { key } }`);
+ * - a scalar value when `fields` has exactly one entry (consumers that
+ *   override `rowValueFn` to return the PK scalar) → wraps it.
+ *
+ * `fields` is usually `identifierFields` (see {@link identifierFieldsOf}), so
+ * the identifier carries what a delegated action maps from; each action then
+ * takes the part it needs ({@link actionIdentifiers}).
+ *
+ * Returns `undefined` when `fields` is empty, the source is
+ * `null`/`undefined`, or a scalar can't be paired with a single field.
+ */
+declare function extractIdentifier(source: unknown, fields: readonly string[]): Record<string, unknown> | undefined;
+/**
+ * The identifiers `action` is sent, from the table's identifiers (built
+ * from `identifierFields`): a delegated action (`idMap`) keeps exactly its
+ * map's paths — the client maps them to the owner's identification — any
+ * other action exactly the `preferredId` fields, the identification the
+ * server validates. No fields → no identifiers. Identifiers already in that
+ * shape come back as the same array. Since 0.1.147.
+ */
+declare function actionIdentifiers(action: Pick<TVueTableActionInfo, "idMap">, ids: Record<string, unknown>[], preferredId: readonly string[]): Record<string, unknown>[];
+/**
+ * The query a query selection targets, with the excluded rows' identifiers
+ * (built from `identifierFields`) — see `PromptCtx.target`. Since 0.1.147.
+ */
+type PromptTarget = SelectionQuery & {
+  exclude: Record<string, unknown>[];
+};
+//#endregion
+export { RowSelectableHook as A, TableSelection as B, ResolvedRowActions as C, RowClassHook as D, RowAttrsHook as E, TAsCellTypeComponents as F, TAsTableControls as I, TVueTableActionInfo as L, SelectAllState as M, SelectOn as N, RowDeleteOpt as O, SelectionResetEvent as P, TableActionsState as R, ReactiveTableState as S, RowActionsConfig as T, resolveRowActions as V, MainActionRequest as _, identifierFieldsOf as a, QueryErrorKind as b, ActionResult as c, ConfigTab as d, ConfirmOptions as f, LocalRowAction as g, InvokeOpts as h, extractIdentifier as i, RowSelectableVerdict as j, RowHookContext as k, ApplyUrlQueryOptions as l, EnterAction as m, QUERY_TARGET_UNSUPPORTED_REASON as n, queryTargetGate as o, DroppedFieldsReport as p, actionIdentifiers as r, ActionQueryTarget as s, PromptTarget as t, ColumnMenuConfig as u, NavKeyOptions as v, RowActionsColumnPlacement as w, QuerySelection as x, PresetConfig as y, TableNavBridge as z };

package/dist/use-condition-format-5LcuInDy.mjs

@@ -0,0 +1,34 @@
+import { n as useCellLocale } from "./use-cell-locale-BTJZ6UcP.mjs";
+import { computed } from "vue";
+import { formatColumnCondition, formatColumnValue, formatFilterCondition } from "@atscript/ui-table";
+//#region src/composables/use-condition-format.ts
+/**
+* Chip wording for filter conditions, in the table's time zone and the cell
+* locale: "Last 7 days", "on Oct 5, 2026", "after Oct 5, 2026, 14:30" on date
+* columns, the operator symbols elsewhere. Reads reactive sources, so call the
+* returned functions inside `computed` / templates.
+*
+* Call in `setup` (it injects the cell locale).
+*/
+function useConditionFormat(state) {
+	const { locale } = useCellLocale();
+	const opts = () => ({
+		locale: locale.value,
+		timeZone: state.timeZone.value
+	});
+	const columns = computed(() => new Map(state.allColumns.value.map((c) => [c.path, c])));
+	return {
+		formatCondition(column, cond) {
+			return column ? formatColumnCondition(column, cond, opts()) : formatFilterCondition(cond);
+		},
+		formatValue(path, value) {
+			const column = columns.value.get(path);
+			return column ? formatColumnValue(column, value, opts()) : void 0;
+		},
+		labelOf(path) {
+			return columns.value.get(path)?.label;
+		}
+	};
+}
+//#endregion
+export { useConditionFormat as t };

package/dist/use-condition-format-DrgfX6xL.cjs

@@ -0,0 +1,39 @@
+const require_use_cell_locale = require("./use-cell-locale-Dv514-Al.cjs");
+let vue = require("vue");
+let _atscript_ui_table = require("@atscript/ui-table");
+//#region src/composables/use-condition-format.ts
+/**
+* Chip wording for filter conditions, in the table's time zone and the cell
+* locale: "Last 7 days", "on Oct 5, 2026", "after Oct 5, 2026, 14:30" on date
+* columns, the operator symbols elsewhere. Reads reactive sources, so call the
+* returned functions inside `computed` / templates.
+*
+* Call in `setup` (it injects the cell locale).
+*/
+function useConditionFormat(state) {
+	const { locale } = require_use_cell_locale.useCellLocale();
+	const opts = () => ({
+		locale: locale.value,
+		timeZone: state.timeZone.value
+	});
+	const columns = (0, vue.computed)(() => new Map(state.allColumns.value.map((c) => [c.path, c])));
+	return {
+		formatCondition(column, cond) {
+			return column ? (0, _atscript_ui_table.formatColumnCondition)(column, cond, opts()) : (0, _atscript_ui_table.formatFilterCondition)(cond);
+		},
+		formatValue(path, value) {
+			const column = columns.value.get(path);
+			return column ? (0, _atscript_ui_table.formatColumnValue)(column, value, opts()) : void 0;
+		},
+		labelOf(path) {
+			return columns.value.get(path)?.label;
+		}
+	};
+}
+//#endregion
+Object.defineProperty(exports, "useConditionFormat", {
+	enumerable: true,
+	get: function() {
+		return useConditionFormat;
+	}
+});

package/dist/{use-table-BTsNGBVx.mjs → use-table-BYNBpLJt.mjs}

@@ -1,7 +1,8 @@
-import { l as DEFAULT_AVAILABLE_ASPECTS, n as createTableState, r as provideTableContext } from "./use-table-state-DuY-Mf8e.mjs";
-import { n as useTableSelection } from "./use-table-selection-ULbKT2xW.mjs";
+import { l as DEFAULT_AVAILABLE_ASPECTS, n as createTableState, r as provideTableContext } from "./use-table-state-CIoWhwTD.mjs";
+import { n as useTableSelection } from "./use-table-selection-CdaOPo1d.mjs";
+import { n as useCellLocale } from "./use-cell-locale-BTJZ6UcP.mjs";
 import { createTableDef, getMetaEntry, resetMetaCache } from "@atscript/ui";
-import { computed, inject, isRef, ref, shallowRef, toValue, watch } from "vue";
+import { computed, getCurrentInstance, inject, isRef, ref, shallowRef, toValue, watch } from "vue";
 import { PresetsClient, STANDARD_PRESET_ID, debounce, deserializeDraft, isEmptyDraft, isSystemPresetId, isUnavailableError, resolveSystemPresets, serializeDraft, stableStringify } from "@atscript/ui-table";
 //#region src/composables/as-presets-app.ts
 /**
@@ -33,6 +34,23 @@ function injectPresetsApp(explicit) {
 	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/utils/week-start.ts
+/**
+* The first day of the week for a locale, `1` = Monday … `7` = Sunday, from
+* `Intl.Locale#getWeekInfo` where the runtime has it; `undefined` otherwise
+* (callers then default to Monday).
+*/
+function weekStartOf(locale) {
+	if (!locale) return void 0;
+	try {
+		const l = new Intl.Locale(locale);
+		const day = (l.getWeekInfo?.() ?? l.weekInfo)?.firstDay;
+		return typeof day === "number" && day >= 1 && day <= 7 ? day : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
 //#region src/composables/use-local-draft.ts
 const DEFAULT_DEBOUNCE_MS = 300;
 /**
@@ -395,6 +413,7 @@ function useTable(url, opts) {
 	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 cellLocale = getCurrentInstance() ? useCellLocale() : void 0;
 	const preset = opts?.preset;
 	const presetsHandle = preset ? usePresets({
 		url: preset.url,
@@ -415,7 +434,9 @@ function useTable(url, opts) {
 		limit: opts?.limit,
 		selection: {
 			rowValueFn: opts?.rowValueFn,
-			selectedRows: opts?.selectedRows
+			selectedRows: opts?.selectedRows,
+			querySelection: opts?.querySelection,
+			onSelectionReset: opts?.onSelectionReset
 		},
 		model: {
 			filterFields: opts?.filterFields,
@@ -429,6 +450,8 @@ function useTable(url, opts) {
 			forceFilters: opts?.forceFilters,
 			forceSorters: opts?.forceSorters,
 			alwaysSelected: opts?.alwaysSelected,
+			timeZone: () => toValue(opts?.timeZone) ?? cellLocale?.timezone.value,
+			weekStart: () => toValue(opts?.weekStart) ?? weekStartOf(cellLocale?.locale.value),
 			blockQuery: opts?.blockQuery,
 			queryOnMount: opts?.queryOnMount,
 			ignoreSortersWhenSearched: typeof opts?.ignoreSortersWhenSearched === "boolean" ? opts.ignoreSortersWhenSearched : void 0,

package/dist/{use-table-W0KmaJ6L.cjs → use-table-C9qI-TL6.cjs}

@@ -1,5 +1,6 @@
-const require_use_table_state = require("./use-table-state-Ddr2UZzB.cjs");
-const require_use_table_selection = require("./use-table-selection-DtCV3rhu.cjs");
+const require_use_table_state = require("./use-table-state-BQchKxUr.cjs");
+const require_use_table_selection = require("./use-table-selection-Cs7-gjHg.cjs");
+const require_use_cell_locale = require("./use-cell-locale-Dv514-Al.cjs");
 let _atscript_ui = require("@atscript/ui");
 let vue = require("vue");
 let _atscript_ui_table = require("@atscript/ui-table");
@@ -33,6 +34,23 @@ function injectPresetsApp(explicit) {
 	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/utils/week-start.ts
+/**
+* The first day of the week for a locale, `1` = Monday … `7` = Sunday, from
+* `Intl.Locale#getWeekInfo` where the runtime has it; `undefined` otherwise
+* (callers then default to Monday).
+*/
+function weekStartOf(locale) {
+	if (!locale) return void 0;
+	try {
+		const l = new Intl.Locale(locale);
+		const day = (l.getWeekInfo?.() ?? l.weekInfo)?.firstDay;
+		return typeof day === "number" && day >= 1 && day <= 7 ? day : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
 //#region src/composables/use-local-draft.ts
 const DEFAULT_DEBOUNCE_MS = 300;
 /**
@@ -395,6 +413,7 @@ function useTable(url, opts) {
 	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 cellLocale = (0, vue.getCurrentInstance)() ? require_use_cell_locale.useCellLocale() : void 0;
 	const preset = opts?.preset;
 	const presetsHandle = preset ? usePresets({
 		url: preset.url,
@@ -415,7 +434,9 @@ function useTable(url, opts) {
 		limit: opts?.limit,
 		selection: {
 			rowValueFn: opts?.rowValueFn,
-			selectedRows: opts?.selectedRows
+			selectedRows: opts?.selectedRows,
+			querySelection: opts?.querySelection,
+			onSelectionReset: opts?.onSelectionReset
 		},
 		model: {
 			filterFields: opts?.filterFields,
@@ -429,6 +450,8 @@ function useTable(url, opts) {
 			forceFilters: opts?.forceFilters,
 			forceSorters: opts?.forceSorters,
 			alwaysSelected: opts?.alwaysSelected,
+			timeZone: () => (0, vue.toValue)(opts?.timeZone) ?? cellLocale?.timezone.value,
+			weekStart: () => (0, vue.toValue)(opts?.weekStart) ?? weekStartOf(cellLocale?.locale.value),
 			blockQuery: opts?.blockQuery,
 			queryOnMount: opts?.queryOnMount,
 			ignoreSortersWhenSearched: typeof opts?.ignoreSortersWhenSearched === "boolean" ? opts.ignoreSortersWhenSearched : void 0,

package/dist/{use-table-component-BvAC82_c.cjs → use-table-component-CsdvdGJT.cjs}

@@ -1,4 +1,4 @@
-const require_use_table_state = require("./use-table-state-Ddr2UZzB.cjs");
+const require_use_table_state = require("./use-table-state-BQchKxUr.cjs");
 //#region src/composables/use-table-component.ts
 /**
 * Resolve a single skin-slot component from the injected `controls` map,

package/dist/{use-table-component-DRMXTk9M.mjs → use-table-component-Dy397695.mjs}

@@ -1,4 +1,4 @@
-import { o as useTableContextOptional } from "./use-table-state-DuY-Mf8e.mjs";
+import { o as useTableContextOptional } from "./use-table-state-CIoWhwTD.mjs";
 //#region src/composables/use-table-component.ts
 /**
 * Resolve a single skin-slot component from the injected `controls` map,

package/dist/{use-table-nav-bridge-Bw0NFDSf.mjs → use-table-nav-bridge-CJBERyPB.mjs}

@@ -1,4 +1,4 @@
-import { o as useTableContextOptional } from "./use-table-state-DuY-Mf8e.mjs";
+import { o as useTableContextOptional } from "./use-table-state-CIoWhwTD.mjs";
 //#region src/composables/use-table-nav-bridge.ts
 function isPassthroughKey(event) {
 	const key = event.key;

package/dist/{use-table-nav-bridge-CPI1tql6.cjs → use-table-nav-bridge-Gm4ZfOjJ.cjs}

@@ -1,4 +1,4 @@
-const require_use_table_state = require("./use-table-state-Ddr2UZzB.cjs");
+const require_use_table_state = require("./use-table-state-BQchKxUr.cjs");
 //#region src/composables/use-table-nav-bridge.ts
 function isPassthroughKey(event) {
 	const key = event.key;

package/dist/{use-table-selection-ULbKT2xW.mjs → use-table-selection-CdaOPo1d.mjs}

@@ -7,7 +7,9 @@ import { trimSelection } from "@atscript/ui-table";
 * 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.
+* default `'none'` doesn't clobber externally-seeded selections. Also pushes
+* the mode into `state.selectMode` (immediately), and dropping into `'none'`
+* ends a query selection too.
 *
 * Lives outside `useTableSelection` because selection mode is a renderer
 * concern (a prop, not state) — both `<AsTable>` and `<AsWindowTable>`
@@ -15,8 +17,11 @@ import { trimSelection } from "@atscript/ui-table";
 */
 function useSelectModeReset(state, selectGetter) {
 	watch(selectGetter, (next, prev) => {
-		if (next === "none" && prev !== "none" && state.selectedRows.value.length > 0) state.selectedRows.value = [];
-	});
+		state.selectMode.value = next;
+		if (prev === void 0) return;
+		if (next === "none" && prev !== "none") state.clearSelection();
+		else if (next !== "multi" && state.querySelection.value) state.querySelection.value = null;
+	}, { immediate: true });
 }
 /**
 * Wire up selection reconciliation on results change.

package/dist/{use-table-selection-DtCV3rhu.cjs → use-table-selection-Cs7-gjHg.cjs}

@@ -7,7 +7,9 @@ let _atscript_ui_table = require("@atscript/ui-table");
 * 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.
+* default `'none'` doesn't clobber externally-seeded selections. Also pushes
+* the mode into `state.selectMode` (immediately), and dropping into `'none'`
+* ends a query selection too.
 *
 * Lives outside `useTableSelection` because selection mode is a renderer
 * concern (a prop, not state) — both `<AsTable>` and `<AsWindowTable>`
@@ -15,8 +17,11 @@ let _atscript_ui_table = require("@atscript/ui-table");
 */
 function useSelectModeReset(state, selectGetter) {
 	(0, vue.watch)(selectGetter, (next, prev) => {
-		if (next === "none" && prev !== "none" && state.selectedRows.value.length > 0) state.selectedRows.value = [];
-	});
+		state.selectMode.value = next;
+		if (prev === void 0) return;
+		if (next === "none" && prev !== "none") state.clearSelection();
+		else if (next !== "multi" && state.querySelection.value) state.querySelection.value = null;
+	}, { immediate: true });
 }
 /**
 * Wire up selection reconciliation on results change.