@wow-two-beta/ui-vue 0.0.5 → 0.0.6

package/dist/foundation/selection/index.js

@@ -1,7 +1,9 @@
+import { E as ExactNumber } from "../../chunks/ExactNumber-CboRl3_0.js";
 import { Temporal } from "temporal-polyfill";
-import { c as compareStrings } from "../../chunks/Compare-Du6p-OX1.js";
-import { toValue, shallowRef, computed } from "vue";
-import { u as useControlled } from "../../chunks/useControlled-B6M4kTLn.js";
+import { c as compareStrings } from "../../chunks/Compare-C5NGppdh.js";
+import { shallowRef, computed, toValue } from "vue";
+import { u as useControlled } from "../../chunks/UseControlled-BQneb7BW.js";
+import { u } from "../../chunks/UseTypeahead-C-y7nBo2.js";
 function readField(item, field, accessors) {
   const accessor = accessors?.[field];
   if (accessor) return accessor(item);
@@ -149,19 +151,21 @@ const SortDirection = {
 };
 function compareValues(a, b, options = {}) {
   if (Object.is(a, b)) return 0;
+  if (ExactNumber.isExactNumber(a) && ExactNumber.isExactNumber(b)) {
+    const comparison = a.compare(b);
+    if (comparison.ok) return comparison.value;
+    throw new TypeError("Exact numeric values could not be compared");
+  }
   if (typeof a === "number" && typeof b === "number") return a - b;
   if (typeof a === "bigint" && typeof b === "bigint") return a < b ? -1 : a > b ? 1 : 0;
   if (typeof a === "boolean" && typeof b === "boolean") return Number(a) - Number(b);
-  if (a instanceof Temporal.PlainDate && b instanceof Temporal.PlainDate)
-    return Temporal.PlainDate.compare(a, b);
-  if (a instanceof Temporal.PlainTime && b instanceof Temporal.PlainTime)
-    return Temporal.PlainTime.compare(a, b);
+  if (a instanceof Temporal.PlainDate && b instanceof Temporal.PlainDate) return Temporal.PlainDate.compare(a, b);
+  if (a instanceof Temporal.PlainTime && b instanceof Temporal.PlainTime) return Temporal.PlainTime.compare(a, b);
   if (a instanceof Temporal.PlainDateTime && b instanceof Temporal.PlainDateTime)
     return Temporal.PlainDateTime.compare(a, b);
   if (a instanceof Temporal.ZonedDateTime && b instanceof Temporal.ZonedDateTime)
     return Temporal.ZonedDateTime.compare(a, b);
-  if (a instanceof Temporal.Instant && b instanceof Temporal.Instant)
-    return Temporal.Instant.compare(a, b);
+  if (a instanceof Temporal.Instant && b instanceof Temporal.Instant) return Temporal.Instant.compare(a, b);
   if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();
   if (typeof a === "string" && typeof b === "string") return compareStrings(a, b, options.locale);
   return compareStrings(String(a), String(b), options.locale);
@@ -238,6 +242,7 @@ function valuesEqual(a, b, isCaseSensitive, locale) {
     return foldText(a, isCaseSensitive, locale) === foldText(b, isCaseSensitive, locale);
   }
   if (Object.is(a, b)) return true;
+  if (ExactNumber.isExactNumber(a) && ExactNumber.isExactNumber(b)) return compareValues(a, b, { locale }) === 0;
   if (isDateLike(a) && isDateLike(b)) return compareValues(a, b, { locale }) === 0;
   return false;
 }
@@ -249,20 +254,14 @@ function matchesFilter(item, filter, accessors, options = {}) {
     case FilterOperator.Equals:
       return valuesEqual(fieldValue, filter.value, isCaseSensitive, locale);
     case FilterOperator.In:
-      return filter.value.some(
-        (candidate) => valuesEqual(fieldValue, candidate, isCaseSensitive, locale)
-      );
+      return filter.value.some((candidate) => valuesEqual(fieldValue, candidate, isCaseSensitive, locale));
     case FilterOperator.Contains: {
       if (isNullish(fieldValue) || isNullish(filter.value)) return false;
-      return foldText(fieldValue, isCaseSensitive, locale).includes(
-        foldText(filter.value, isCaseSensitive, locale)
-      );
+      return foldText(fieldValue, isCaseSensitive, locale).includes(foldText(filter.value, isCaseSensitive, locale));
     }
     case FilterOperator.StartsWith: {
       if (isNullish(fieldValue) || isNullish(filter.value)) return false;
-      return foldText(fieldValue, isCaseSensitive, locale).startsWith(
-        foldText(filter.value, isCaseSensitive, locale)
-      );
+      return foldText(fieldValue, isCaseSensitive, locale).startsWith(foldText(filter.value, isCaseSensitive, locale));
     }
     case FilterOperator.GreaterThan: {
       if (isNullish(fieldValue) || isNullish(filter.value)) return false;
@@ -290,18 +289,16 @@ function applyFilters(items, filters, accessors, options = {}) {
   if (filters.length === 0) return items;
   return items.filter(filterPredicate(filters, accessors, options));
 }
-const NO_KEYS = Object.freeze([]);
+const NoKeys = Object.freeze([]);
 function useSelection(options = {}) {
   const { mode, selectedKeys: controlledKeys, defaultSelectedKeys, onSelectionChange } = options;
   const { value: keys, setValue: setKeys } = useControlled({
     controlled: () => toValue(controlledKeys),
-    default: () => toValue(defaultSelectedKeys) ?? NO_KEYS,
+    default: () => toValue(defaultSelectedKeys) ?? NoKeys,
     onChange: onSelectionChange
   });
   const anchor = shallowRef(null);
-  const state = computed(
-    () => createSelection(toValue(mode) ?? SelectionMode.Multiple, keys.value, anchor.value)
-  );
+  const state = computed(() => createSelection(toValue(mode) ?? SelectionMode.Multiple, keys.value, anchor.value));
   const commit = (next) => {
     if (next === state.value) return;
     anchor.value = next.anchor;
@@ -325,29 +322,29 @@ function useSelection(options = {}) {
     extend: (target, orderedKeys, rangeOptions) => commit(extendSelection(state.value, target, orderedKeys, rangeOptions))
   };
 }
-const NO_SORT = Object.freeze([]);
+const NoSort = Object.freeze([]);
 function useSort(options = {}) {
   const { sort, defaultSort, onSortChange, isMulti } = options;
   const { value: descriptors, setValue: setDescriptors } = useControlled({
     controlled: () => toValue(sort),
-    default: () => toValue(defaultSort) ?? NO_SORT,
+    default: () => toValue(defaultSort) ?? NoSort,
     onChange: onSortChange
   });
   return {
     descriptors: computed(() => descriptors.value),
     toggle: (field) => setDescriptors(toggleSort(descriptors.value, field, { isMulti: toValue(isMulti) ?? false })),
     setSort: setDescriptors,
-    clear: () => setDescriptors(NO_SORT),
+    clear: () => setDescriptors(NoSort),
     directionFor: (field) => sortDirectionFor(descriptors.value, field),
     indexFor: (field) => sortIndexFor(descriptors.value, field)
   };
 }
-const NO_FILTERS = Object.freeze([]);
+const NoFilters = Object.freeze([]);
 function useFilters(options = {}) {
   const { filters: controlledFilters, defaultFilters, onFiltersChange } = options;
   const { value: filters, setValue: setFilters } = useControlled({
     controlled: () => toValue(controlledFilters),
-    default: () => toValue(defaultFilters) ?? NO_FILTERS,
+    default: () => toValue(defaultFilters) ?? NoFilters,
     onChange: onFiltersChange
   });
   const setFilter = (filter) => {
@@ -365,7 +362,7 @@ function useFilters(options = {}) {
     setFilters,
     setFilter,
     removeFilter,
-    clear: () => setFilters(NO_FILTERS),
+    clear: () => setFilters(NoFilters),
     filterFor: (field) => filters.value.find((candidate) => candidate.field === field)
   };
 }
@@ -402,6 +399,7 @@ export {
   toggleSort,
   useFilters,
   useSelection,
-  useSort
+  useSort,
+  u as useTypeahead
 };
 //# sourceMappingURL=index.js.map

package/dist/foundation/selection/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/foundation/selection/Field.ts","../../../src/foundation/selection/Selection.ts","../../../src/foundation/selection/Sort.ts","../../../src/foundation/selection/Filter.ts","../../../src/foundation/selection/UseSelection.ts","../../../src/foundation/selection/UseSort.ts","../../../src/foundation/selection/UseFilters.ts"],"sourcesContent":["// The one field-reading seam shared by the sort and filter models. Both answer the same question —\n// \"given an item and a field name, what value do I compare?\" — so the vocabulary lives here rather than\n// being defined twice and drifting.\n//\n// Accessors are OPTIONAL by design: the overwhelmingly common table column sorts on a plain property, so\n// `readField` falls back to a direct property read when no accessor is registered for the field. That\n// keeps the zero-config call (`applySort(rows, [{ field: 'name', direction: 'asc' }])`) working while\n// still letting a computed column (`fullName`, `total`) register a real accessor.\n//\n// The map is `Partial` on purpose: with `noUncheckedIndexedAccess` a `Partial<Record<TField, F>>` lookup\n// is `F | undefined` for BOTH a `string` field type and a literal union, so the guard below type-checks\n// identically either way — no cast, no `any`.\n\n/** Represents the value extraction for one field of an item — the unit a comparator or predicate reads. */\nexport type FieldAccessor<T> = (item: T) => unknown;\n\n/**\n * Represents the field-name → accessor registry handed to {@link readField}, `applySort`, and `applyFilters`.\n * Every entry is optional; a field with no entry falls back to a plain property read.\n */\nexport type FieldAccessors<T, TField extends string = string> = Partial<\n  Readonly<Record<TField, FieldAccessor<T>>>\n>;\n\n/**\n * Reads one field off an item: the registered accessor when present, otherwise the item's own property of\n * that name. Returns `undefined` for a non-object item with no accessor — which the sort model treats as\n * nullish (sorts last) and the filter model treats as \"matches nothing but a nullish `equals`\".\n */\nexport function readField<T, TField extends string>(\n  item: T,\n  field: TField,\n  accessors?: FieldAccessors<T, TField>,\n): unknown {\n  const accessor: FieldAccessor<T> | undefined = accessors?.[field];\n  if (accessor) return accessor(item);\n  if (typeof item === 'object' && item !== null) {\n    return (item as Record<string, unknown>)[field];\n  }\n  return undefined;\n}\n\n/**\n * Reports whether a value is absent for comparison purposes — `null`, `undefined`, or `NaN`.\n *\n * `NaN` counts as nullish deliberately: it is the one number that makes `a - b` return `NaN`, which would\n * make a comparator non-transitive and leave the sorted order engine-defined. Folding it in with the\n * nullish values gives it a documented home (last) instead.\n */\nexport function isNullish(value: unknown): boolean {\n  return value === null || value === undefined || (typeof value === 'number' && Number.isNaN(value));\n}\n\n/** Represents the locale seam shared by the sort and filter entry points. Omit to use the host default. */\nexport interface LocaleOptions {\n  /** The BCP 47 locale driving string collation (sort) and case folding (filter). Defaults to the host locale. */\n  locale?: string;\n}\n\n/**\n * Coerces any value to text for the filter model's text operators. Symbols are handled explicitly because\n * `String(symbol)` throws, and a filter must never throw on unexpected row data.\n */\nexport function toText(value: unknown): string {\n  if (typeof value === 'string') return value;\n  if (typeof value === 'symbol') return value.toString();\n  return String(value);\n}\n","// Selection — the canonical model behind every selectable surface (DataTable rows, Listbox options, tree\n// nodes, transfer lists). Pure and immutable: every op takes a state and returns a state, never mutates,\n// and returns the SAME reference when the op changed nothing — so a memoized consumer can skip work on an\n// inert click without a deep compare.\n//\n// Why a `Set` plus a separate anchor rather than one array of keys: membership is the hot path (one test\n// per rendered row), and the anchor is selection *history*, not selection *content* — a shift-click must\n// know where the last plain click landed, and that has to survive ops that don't touch the key set.\n//\n// Why `mode` lives IN the state instead of being a per-call argument: the invariants then hold\n// structurally. `none` makes every mutating op inert and `single` caps the set at one key no matter which\n// op a caller reaches for, so a single-select list cannot accumulate keys by calling the wrong function.\n//\n// The set-shaped ops (`selectAll`, `invert`, `toggleAll`, `selectionStatus`) all take an explicit key list\n// rather than reading some ambient \"all rows\". That list is the caller's CURRENT FILTERED PAGE, which is\n// the whole point: a header checkbox on a filtered table must mean \"all matching rows\", and selections\n// made outside the current filter must survive it.\n\n/** Represents the identity of a selectable item — the value a surface keys its rows/options by. */\nexport type SelectionKey = string | number;\n\n/** Defines how many items a surface allows to be selected at once. */\nexport const SelectionMode = {\n  /** Refers to a non-selectable surface — every mutating op is inert. */\n  None: 'none',\n  /** Refers to at most one selected item — selecting replaces rather than accumulates. */\n  Single: 'single',\n  /** Refers to any number of selected items, including ranges. */\n  Multiple: 'multiple',\n} as const;\n\nexport type SelectionMode = (typeof SelectionMode)[keyof typeof SelectionMode];\n\n/** Defines the tri-state a header checkbox renders for a key set. */\nexport const SelectionStatus = {\n  /** Refers to none of the given keys being selected — an unchecked box. */\n  None: 'none',\n  /** Refers to a partial selection — an indeterminate box. */\n  Some: 'some',\n  /** Refers to every given key being selected — a checked box. */\n  All: 'all',\n} as const;\n\nexport type SelectionStatus = (typeof SelectionStatus)[keyof typeof SelectionStatus];\n\n/** Represents an immutable selection snapshot. Build with {@link createSelection}; never construct by hand. */\nexport interface SelectionState<TKey extends SelectionKey> {\n  /** The mode enforced by every op on this state. */\n  readonly mode: SelectionMode;\n  /** The selected keys, in the order they were added. */\n  readonly keys: ReadonlySet<TKey>;\n  /** The last plainly-interacted key — the fixed end of a subsequent range extension, or `null`. */\n  readonly anchor: TKey | null;\n}\n\n/** Options accepted by the range ops. */\nexport interface SelectRangeOptions {\n  /**\n   * The union behaviour. `true` (default) merges the range into the existing selection — the checkbox-list\n   * shift-click every data grid in this SDK wants. `false` replaces the selection with the range alone,\n   * matching a file-manager style list.\n   */\n  isAdditive?: boolean;\n}\n\n/** Reports whether two key sets hold the same members — the identity check behind the no-op short circuit. */\nfunction areKeySetsEqual<TKey extends SelectionKey>(\n  a: ReadonlySet<TKey>,\n  b: ReadonlySet<TKey>,\n): boolean {\n  if (a === b) return true;\n  if (a.size !== b.size) return false;\n  for (const key of a) if (!b.has(key)) return false;\n  return true;\n}\n\n/** Builds the next state, collapsing to the previous reference when nothing actually changed. */\nfunction withSelection<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  keys: ReadonlySet<TKey>,\n  anchor: TKey | null,\n): SelectionState<TKey> {\n  if (anchor === state.anchor && areKeySetsEqual(state.keys, keys)) return state;\n  return { mode: state.mode, keys, anchor };\n}\n\n/**\n * Creates a selection state, normalising the seed to the mode: `none` drops every key, `single` keeps only\n * the first. Also the way to re-mode an existing state — `createSelection('single', state.keys)`.\n *\n * @param mode The selection mode to enforce. Defaults to `'multiple'`.\n * @param keys The initially selected keys, in priority order.\n * @param anchor The initial range anchor. Defaults to `null`.\n */\nexport function createSelection<TKey extends SelectionKey>(\n  mode: SelectionMode = SelectionMode.Multiple,\n  keys: Iterable<TKey> = [],\n  anchor: TKey | null = null,\n): SelectionState<TKey> {\n  if (mode === SelectionMode.None) return { mode, keys: new Set<TKey>(), anchor: null };\n  const seeded = new Set<TKey>(keys);\n  if (mode === SelectionMode.Single && seeded.size > 1) {\n    const first = [...seeded].at(0);\n    return {\n      mode,\n      keys: first === undefined ? new Set<TKey>() : new Set<TKey>([first]),\n      anchor,\n    };\n  }\n  return { mode, keys: seeded, anchor };\n}\n\n/** Reports whether a key is currently selected. */\nexport function isSelected<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  key: TKey,\n): boolean {\n  return state.keys.has(key);\n}\n\n/** The number of selected keys. */\nexport function selectionCount<TKey extends SelectionKey>(state: SelectionState<TKey>): number {\n  return state.keys.size;\n}\n\n/** The selected keys as an array, in insertion order — the shape a controlled `onSelectionChange` emits. */\nexport function selectedKeys<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n): readonly TKey[] {\n  return [...state.keys];\n}\n\n/**\n * Selects a key and moves the anchor to it. In `single` mode this REPLACES the selection rather than\n * accumulating; in `none` mode it is inert.\n */\nexport function select<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  key: TKey,\n): SelectionState<TKey> {\n  if (state.mode === SelectionMode.None) return state;\n  if (state.mode === SelectionMode.Single) return withSelection(state, new Set([key]), key);\n  const next = new Set(state.keys);\n  next.add(key);\n  return withSelection(state, next, key);\n}\n\n/**\n * Deselects a key and moves the anchor to it. Inert in `none` mode, and inert when the key was not\n * selected — an unselected key carries no interaction to anchor on.\n */\nexport function deselect<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  key: TKey,\n): SelectionState<TKey> {\n  if (state.mode === SelectionMode.None || !state.keys.has(key)) return state;\n  const next = new Set(state.keys);\n  next.delete(key);\n  return withSelection(state, next, key);\n}\n\n/**\n * Flips one key's membership and moves the anchor to it — the plain click. In `single` mode, toggling the\n * selected key clears the selection and toggling any other key replaces it.\n */\nexport function toggle<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  key: TKey,\n): SelectionState<TKey> {\n  if (state.mode === SelectionMode.None) return state;\n  return state.keys.has(key) ? deselect(state, key) : select(state, key);\n}\n\n/**\n * Adds every given key to the selection, leaving the anchor and any selection OUTSIDE the given keys\n * untouched — so \"select all\" on a filtered table keeps rows selected under other filters.\n *\n * Inert in `none` and `single` modes: \"all\" has no meaning on a surface that holds at most one key.\n */\nexport function selectAll<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  keys: Iterable<TKey>,\n): SelectionState<TKey> {\n  if (state.mode !== SelectionMode.Multiple) return state;\n  const next = new Set(state.keys);\n  for (const key of keys) next.add(key);\n  return withSelection(state, next, state.anchor);\n}\n\n/** Empties the selection and drops the anchor — with nothing selected there is no range to extend from. */\nexport function clear<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n): SelectionState<TKey> {\n  if (state.keys.size === 0 && state.anchor === null) return state;\n  return { mode: state.mode, keys: new Set<TKey>(), anchor: null };\n}\n\n/**\n * Flips the membership of every given key. Keys selected OUTSIDE the given set are left alone, so\n * inverting a filtered page inverts exactly that page.\n *\n * Inert in `none` and `single` modes.\n */\nexport function invert<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  keys: Iterable<TKey>,\n): SelectionState<TKey> {\n  if (state.mode !== SelectionMode.Multiple) return state;\n  const next = new Set(state.keys);\n  for (const key of keys) {\n    if (next.has(key)) next.delete(key);\n    else next.add(key);\n  }\n  return withSelection(state, next, state.anchor);\n}\n\n/**\n * The header-checkbox click: selects every given key unless all of them are already selected, in which\n * case it deselects them. Selections outside the given keys survive either way.\n *\n * Inert in `none` and `single` modes, and on an empty key list.\n */\nexport function toggleAll<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  keys: Iterable<TKey>,\n): SelectionState<TKey> {\n  if (state.mode !== SelectionMode.Multiple) return state;\n  const scope = [...keys];\n  if (scope.length === 0) return state;\n  if (selectionStatus(state, scope) === SelectionStatus.All) {\n    const next = new Set(state.keys);\n    for (const key of scope) next.delete(key);\n    return withSelection(state, next, state.anchor);\n  }\n  return selectAll(state, scope);\n}\n\n/**\n * The tri-state a header checkbox renders for the given keys: `'all'` when every one is selected,\n * `'none'` when none is, `'some'` otherwise. An empty key list is `'none'` — there is nothing to check.\n */\nexport function selectionStatus<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  keys: Iterable<TKey>,\n): SelectionStatus {\n  let total = 0;\n  let hit = 0;\n  for (const key of keys) {\n    total += 1;\n    if (state.keys.has(key)) hit += 1;\n  }\n  if (total === 0 || hit === 0) return SelectionStatus.None;\n  return hit === total ? SelectionStatus.All : SelectionStatus.Some;\n}\n\n/**\n * Selects the contiguous run between two keys — the shift-click. `orderedKeys` is the surface's CURRENT\n * visual order (already sorted and filtered), which is what makes the range mean what the user sees.\n *\n * The anchor is left AT `anchor`, not moved to `target`: successive shift-clicks must all measure from the\n * same fixed end, so dragging a range back and forth grows and shrinks it instead of walking it away.\n *\n * Degenerate cases, all documented rather than thrown: `none` mode is inert; `single` mode collapses to\n * {@link select} on `target`; a `target` missing from `orderedKeys` is inert; an `anchor` missing from\n * `orderedKeys` falls back to selecting `target` alone.\n */\nexport function selectRange<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  anchor: TKey,\n  target: TKey,\n  orderedKeys: readonly TKey[],\n  options: SelectRangeOptions = {},\n): SelectionState<TKey> {\n  if (state.mode === SelectionMode.None) return state;\n  if (state.mode === SelectionMode.Single) return select(state, target);\n\n  const targetIndex = orderedKeys.indexOf(target);\n  if (targetIndex === -1) return state;\n\n  const anchorIndex = orderedKeys.indexOf(anchor);\n  if (anchorIndex === -1) return withSelection(state, new Set([target]), target);\n\n  const start = Math.min(anchorIndex, targetIndex);\n  const end = Math.max(anchorIndex, targetIndex);\n  const run = orderedKeys.slice(start, end + 1);\n\n  const isAdditive = options.isAdditive ?? true;\n  const next = isAdditive ? new Set(state.keys) : new Set<TKey>();\n  for (const key of run) next.add(key);\n  return withSelection(state, next, anchor);\n}\n\n/**\n * The shift-click as a surface actually calls it: extends from the state's own anchor to `target`. With no\n * anchor yet (nothing has been plainly clicked), the target itself becomes the anchor and the range is the\n * single row — which is exactly what a shift-click on a fresh list should do.\n */\nexport function extendSelection<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  target: TKey,\n  orderedKeys: readonly TKey[],\n  options: SelectRangeOptions = {},\n): SelectionState<TKey> {\n  return selectRange(state, state.anchor ?? target, target, orderedKeys, options);\n}\n","// Sort — the canonical descriptor list + comparator behind every sortable surface. A list of\n// `SortDescriptor`s rather than one `{ field, direction }` because multi-field sort is the same model with\n// more entries: precedence IS array order, so a header click that appends a field reads the same as one\n// that replaces it.\n//\n// Two rules are load-bearing and neither is guessable from the types, so they are stated here and tested:\n//\n//   1. NULLISH SORTS LAST IN BOTH DIRECTIONS. The direction flip is applied to the value comparison only,\n//      never to the nullish check. A blank cell is an absence, not a smallest-value — flipping to `desc`\n//      to see the biggest revenue must not float every revenue-less row to the top. (This is where the\n//      model deliberately differs from the ad-hoc comparator in `presentation` DataTable, which negates\n//      the whole result and therefore floats nullish to the top on `desc`.)\n//   2. THE CYCLE IS `asc → desc → none`. A third click clears the field rather than returning to `asc`, so\n//      \"unsorted\" stays reachable by clicking — otherwise a user who sorts a table can never get back to\n//      the server's natural order.\n//\n// String comparison goes through `foundation/utils`' `compareStrings` — the SDK's one cached, numeric-aware\n// `Intl.Collator`. There is no second collator in this slice, deliberately: text ordering must not differ\n// between a DataTable header and a headless `applySort` call.\n\nimport { Temporal } from 'temporal-polyfill';\n\nimport { compareStrings } from '../utils/Compare';\nimport { isNullish, readField, type FieldAccessors, type LocaleOptions } from './Field';\n\n/** Defines the ordering applied to a sorted field. */\nexport const SortDirection = {\n  /** Refers to ascending order — smallest/earliest/`false` first. */\n  Asc: 'asc',\n  /** Refers to descending order — largest/latest/`true` first. */\n  Desc: 'desc',\n} as const;\n\nexport type SortDirection = (typeof SortDirection)[keyof typeof SortDirection];\n\n/** Represents one field of an ordering. A list of these is the whole sort state; array order is precedence. */\nexport interface SortDescriptor<TField extends string = string> {\n  /** The field name, resolved through the accessor registry or read as a plain property. */\n  readonly field: TField;\n  /** The direction applied to this field. */\n  readonly direction: SortDirection;\n}\n\n/** Options accepted by {@link toggleSort}. */\nexport interface ToggleSortOptions {\n  /**\n   * The multi-field behaviour. `false` (default) keeps at most one sorted field — a click on a new field\n   * replaces the ordering. `true` appends the new field after the existing ones, so precedence follows\n   * click order (the shift-click-a-second-header behaviour).\n   */\n  isMulti?: boolean;\n}\n\n/**\n * Compares two non-nullish values with the SDK's default ordering, direction-agnostic (callers negate).\n * Handles, in order: numbers, bigints, booleans (`false` before `true`), the `Temporal` types, native\n * `Date`, strings, and finally anything else via its text form.\n *\n * Nullish handling is deliberately NOT here — {@link applySort} applies it outside the direction flip so\n * absent values sort last in both directions. Calling this with a nullish value falls through to the text\n * comparison, which is not the documented ordering.\n */\nexport function compareValues(a: unknown, b: unknown, options: LocaleOptions = {}): number {\n  if (Object.is(a, b)) return 0;\n  if (typeof a === 'number' && typeof b === 'number') return a - b;\n  if (typeof a === 'bigint' && typeof b === 'bigint') return a < b ? -1 : a > b ? 1 : 0;\n  if (typeof a === 'boolean' && typeof b === 'boolean') return Number(a) - Number(b);\n  if (a instanceof Temporal.PlainDate && b instanceof Temporal.PlainDate)\n    return Temporal.PlainDate.compare(a, b);\n  if (a instanceof Temporal.PlainTime && b instanceof Temporal.PlainTime)\n    return Temporal.PlainTime.compare(a, b);\n  if (a instanceof Temporal.PlainDateTime && b instanceof Temporal.PlainDateTime)\n    return Temporal.PlainDateTime.compare(a, b);\n  if (a instanceof Temporal.ZonedDateTime && b instanceof Temporal.ZonedDateTime)\n    return Temporal.ZonedDateTime.compare(a, b);\n  if (a instanceof Temporal.Instant && b instanceof Temporal.Instant)\n    return Temporal.Instant.compare(a, b);\n  // Native `Date` stays supported: a consumer's row data is arbitrary, and a `Date` in a column must not\n  // silently degrade to a string comparison of its locale form.\n  if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();\n  if (typeof a === 'string' && typeof b === 'string') return compareStrings(a, b, options.locale);\n  return compareStrings(String(a), String(b), options.locale);\n}\n\n/** The direction currently applied to a field, or `null` when the field is unsorted. */\nexport function sortDirectionFor<TField extends string>(\n  descriptors: readonly SortDescriptor<TField>[],\n  field: TField,\n): SortDirection | null {\n  return descriptors.find((descriptor) => descriptor.field === field)?.direction ?? null;\n}\n\n/**\n * The 0-based precedence of a field in the ordering, or `-1` when unsorted — the number a multi-sort header\n * renders as its \"1 / 2 / 3\" badge (add one for display).\n */\nexport function sortIndexFor<TField extends string>(\n  descriptors: readonly SortDescriptor<TField>[],\n  field: TField,\n): number {\n  return descriptors.findIndex((descriptor) => descriptor.field === field);\n}\n\n/**\n * Advances one field through the `asc → desc → none` cycle and returns the next descriptor list.\n *\n * Single-field (default): the result is `[{ field, 'asc' }]`, `[{ field, 'desc' }]`, or `[]`. Clicking a\n * different field restarts that field's cycle at `asc` and drops the previous one.\n *\n * Multi-field (`{ isMulti: true }`): the field keeps its position while cycling `asc → desc`, and the third\n * click removes it, leaving the other fields' precedence intact. A field not yet in the list is appended.\n */\nexport function toggleSort<TField extends string>(\n  descriptors: readonly SortDescriptor<TField>[],\n  field: TField,\n  options: ToggleSortOptions = {},\n): readonly SortDescriptor<TField>[] {\n  const current = sortDirectionFor(descriptors, field);\n  const isMulti = options.isMulti ?? false;\n\n  if (!isMulti) {\n    if (current === SortDirection.Asc) return [{ field, direction: SortDirection.Desc }];\n    if (current === SortDirection.Desc) return [];\n    return [{ field, direction: SortDirection.Asc }];\n  }\n\n  if (current === null) return [...descriptors, { field, direction: SortDirection.Asc }];\n  if (current === SortDirection.Desc) {\n    return descriptors.filter((descriptor) => descriptor.field !== field);\n  }\n  return descriptors.map((descriptor) =>\n    descriptor.field === field ? { field, direction: SortDirection.Desc } : descriptor,\n  );\n}\n\n/**\n * Builds the comparator an ordering describes — exported so a virtualised or server-side surface can feed\n * it to its own machinery instead of materialising a sorted array.\n *\n * Fields are consulted in array order and the first non-zero result wins. Within each field: absent values\n * (`null` / `undefined` / `NaN`) sort last regardless of direction, then {@link compareValues} decides and\n * the direction is applied to that result only.\n */\nexport function sortComparator<T, TField extends string = string>(\n  descriptors: readonly SortDescriptor<TField>[],\n  accessors?: FieldAccessors<T, TField>,\n  options: LocaleOptions = {},\n): (a: T, b: T) => number {\n  return (a, b) => {\n    for (const descriptor of descriptors) {\n      const left = readField(a, descriptor.field, accessors);\n      const right = readField(b, descriptor.field, accessors);\n\n      const isLeftNullish = isNullish(left);\n      const isRightNullish = isNullish(right);\n      if (isLeftNullish || isRightNullish) {\n        if (isLeftNullish && isRightNullish) continue;\n        return isLeftNullish ? 1 : -1;\n      }\n\n      const result = compareValues(left, right, options);\n      if (result !== 0) return descriptor.direction === SortDirection.Desc ? -result : result;\n    }\n    return 0;\n  };\n}\n\n/**\n * Sorts a list by an ordering, without mutating the input. Returns the input array itself when there is\n * nothing to order, so an unsorted render costs no copy.\n *\n * The sort is stable (`Array.prototype.sort` has been stable since ES2019), which is what makes multi-field\n * ordering composable: equal rows keep the order the previous field — or the server — put them in.\n */\nexport function applySort<T, TField extends string = string>(\n  items: ReadonlyArray<T>,\n  descriptors: readonly SortDescriptor<TField>[],\n  accessors?: FieldAccessors<T, TField>,\n  options: LocaleOptions = {},\n): ReadonlyArray<T> {\n  if (descriptors.length === 0) return items;\n  return [...items].sort(sortComparator(descriptors, accessors, options));\n}\n","// Filter — predicate composition over a small, CLOSED operator set. Seven operators, no `or`, no nesting,\n// no expression tree: this is deliberately not a query language. A filter bar, a column filter menu, and a\n// faceted sidebar all reduce to \"field, operator, value, AND-ed together\", and every product that has\n// needed more has needed a *server* query, not a richer client model. Growing this into a DSL would put a\n// second, weaker query engine in the client and invite it to drift from the backend's.\n//\n// Operator semantics, all of which are choices rather than derivations:\n//   - `equals`      — no cross-type coercion; `'2'` does not equal `2`. Strings compare case-folded.\n//   - `contains`    — substring of the value's text form.\n//   - `startsWith`  — prefix of the value's text form.\n//   - `gt` / `lt`   — strict, via the sort model's `compareValues` (numbers, dates, Temporal, text).\n//   - `between`     — INCLUSIVE on both bounds; reversed bounds are normalised rather than matching nothing.\n//   - `in`          — membership, entry-wise `equals`.\n//\n// Text operators are CASE-INSENSITIVE by default (`isCaseSensitive: true` opts out) because a filter box is\n// a human typing, not a key lookup.\n//\n// Case folding here uses `toLocaleLowerCase`, not the collator that `Sort` uses. That split is intentional:\n// `contains`/`startsWith` need substring semantics, which a collator cannot express, and having `equals`\n// silently follow collator rules would make `'2'` match `'02'` under numeric collation. Ordering is a\n// collator's job; matching is not.\n//\n// An absent field value (`null` / `undefined` / `NaN`) matches ONLY a nullish `equals` (or an `in` list\n// containing one). Every other operator rejects it — there is no ordering or substring of an absence.\n\nimport { Temporal } from 'temporal-polyfill';\n\nimport {\n  isNullish,\n  readField,\n  toText,\n  type FieldAccessors,\n  type LocaleOptions,\n} from './Field';\nimport { compareValues } from './Sort';\n\n/** Defines the closed set of comparisons a filter may express. */\nexport const FilterOperator = {\n  /** Refers to exact equality — case-folded for strings, no cross-type coercion. */\n  Equals: 'equals',\n  /** Refers to a substring match on the value's text form. */\n  Contains: 'contains',\n  /** Refers to a prefix match on the value's text form. */\n  StartsWith: 'startsWith',\n  /** Refers to a strictly-greater-than comparison. */\n  GreaterThan: 'gt',\n  /** Refers to a strictly-less-than comparison. */\n  LessThan: 'lt',\n  /** Refers to an inclusive range check between two bounds. */\n  Between: 'between',\n  /** Refers to membership in a fixed list of values. */\n  In: 'in',\n} as const;\n\nexport type FilterOperator = (typeof FilterOperator)[keyof typeof FilterOperator];\n\n/** The fields every filter carries, whatever its operator. */\ninterface FilterBase<TField extends string> {\n  /** The field name, resolved through the accessor registry or read as a plain property. */\n  readonly field: TField;\n  /** The case sensitivity of string comparison. Defaults to `false` — text operators fold case. */\n  readonly isCaseSensitive?: boolean;\n}\n\n/** Represents a filter whose operator takes a single comparison value. */\nexport interface ValueFilter<TField extends string = string> extends FilterBase<TField> {\n  /** The comparison applied to the field. */\n  readonly op: 'equals' | 'contains' | 'startsWith' | 'gt' | 'lt';\n  /** The value compared against the field. */\n  readonly value: unknown;\n}\n\n/** Represents an inclusive range filter. Bounds may be given in either order. */\nexport interface BetweenFilter<TField extends string = string> extends FilterBase<TField> {\n  /** The comparison applied to the field. */\n  readonly op: 'between';\n  /** The inclusive `[low, high]` bounds — normalised when reversed. */\n  readonly value: readonly [unknown, unknown];\n}\n\n/** Represents a membership filter over a fixed candidate list. */\nexport interface InFilter<TField extends string = string> extends FilterBase<TField> {\n  /** The comparison applied to the field. */\n  readonly op: 'in';\n  /** The candidate values; the field matches when it equals any of them. */\n  readonly value: readonly unknown[];\n}\n\n/**\n * Represents one filter clause. A discriminated union rather than `{ field, op, value: unknown }` so the\n * value shape each operator requires — a 2-tuple for `between`, an array for `in` — is checked at the call\n * site instead of failing at match time.\n */\nexport type FilterDescriptor<TField extends string = string> =\n  | ValueFilter<TField>\n  | BetweenFilter<TField>\n  | InFilter<TField>;\n\n/** Reports whether a value is a date-like instance, which compares by value rather than identity. */\nfunction isDateLike(value: unknown): boolean {\n  return (\n    value instanceof Date ||\n    value instanceof Temporal.PlainDate ||\n    value instanceof Temporal.PlainTime ||\n    value instanceof Temporal.PlainDateTime ||\n    value instanceof Temporal.ZonedDateTime ||\n    value instanceof Temporal.Instant\n  );\n}\n\n/** Folds a value to its comparable text form, lower-casing unless the filter asked for case sensitivity. */\nfunction foldText(value: unknown, isCaseSensitive: boolean, locale?: string): string {\n  const text = toText(value);\n  return isCaseSensitive ? text : text.toLocaleLowerCase(locale);\n}\n\n/** The equality behind `equals` and `in` — case-folded for strings, by value for dates, else identity. */\nfunction valuesEqual(\n  a: unknown,\n  b: unknown,\n  isCaseSensitive: boolean,\n  locale: string | undefined,\n): boolean {\n  if (isNullish(a) || isNullish(b)) return isNullish(a) && isNullish(b);\n  if (typeof a === 'string' && typeof b === 'string') {\n    return foldText(a, isCaseSensitive, locale) === foldText(b, isCaseSensitive, locale);\n  }\n  if (Object.is(a, b)) return true;\n  if (isDateLike(a) && isDateLike(b)) return compareValues(a, b, { locale }) === 0;\n  return false;\n}\n\n/**\n * Reports whether one item satisfies one filter clause. Exported for the surfaces that test a single row —\n * an optimistic insert deciding whether the new row belongs in the current view, for instance.\n */\nexport function matchesFilter<T, TField extends string = string>(\n  item: T,\n  filter: FilterDescriptor<TField>,\n  accessors?: FieldAccessors<T, TField>,\n  options: LocaleOptions = {},\n): boolean {\n  const locale = options.locale;\n  const isCaseSensitive = filter.isCaseSensitive ?? false;\n  const fieldValue = readField(item, filter.field, accessors);\n\n  switch (filter.op) {\n    case FilterOperator.Equals:\n      return valuesEqual(fieldValue, filter.value, isCaseSensitive, locale);\n\n    case FilterOperator.In:\n      return filter.value.some((candidate) =>\n        valuesEqual(fieldValue, candidate, isCaseSensitive, locale),\n      );\n\n    case FilterOperator.Contains: {\n      if (isNullish(fieldValue) || isNullish(filter.value)) return false;\n      return foldText(fieldValue, isCaseSensitive, locale).includes(\n        foldText(filter.value, isCaseSensitive, locale),\n      );\n    }\n\n    case FilterOperator.StartsWith: {\n      if (isNullish(fieldValue) || isNullish(filter.value)) return false;\n      return foldText(fieldValue, isCaseSensitive, locale).startsWith(\n        foldText(filter.value, isCaseSensitive, locale),\n      );\n    }\n\n    case FilterOperator.GreaterThan: {\n      if (isNullish(fieldValue) || isNullish(filter.value)) return false;\n      return compareValues(fieldValue, filter.value, { locale }) > 0;\n    }\n\n    case FilterOperator.LessThan: {\n      if (isNullish(fieldValue) || isNullish(filter.value)) return false;\n      return compareValues(fieldValue, filter.value, { locale }) < 0;\n    }\n\n    case FilterOperator.Between: {\n      const [first, second] = filter.value;\n      if (isNullish(fieldValue) || isNullish(first) || isNullish(second)) return false;\n      // Normalise reversed bounds: a two-ended range input can be filled in either order, and silently\n      // matching nothing reads as a broken filter rather than a swapped one.\n      const isReversed = compareValues(first, second, { locale }) > 0;\n      const low = isReversed ? second : first;\n      const high = isReversed ? first : second;\n      return (\n        compareValues(fieldValue, low, { locale }) >= 0 &&\n        compareValues(fieldValue, high, { locale }) <= 0\n      );\n    }\n  }\n\n  return false;\n}\n\n/**\n * Builds the AND-ed predicate a filter list describes — exported so a virtualised or streaming surface can\n * test rows as they arrive instead of materialising a filtered array.\n */\nexport function filterPredicate<T, TField extends string = string>(\n  filters: readonly FilterDescriptor<TField>[],\n  accessors?: FieldAccessors<T, TField>,\n  options: LocaleOptions = {},\n): (item: T) => boolean {\n  return (item) => filters.every((filter) => matchesFilter(item, filter, accessors, options));\n}\n\n/**\n * Keeps the items matching every filter. Clauses combine with AND — two clauses on the same field narrow\n * each other (the `between` of a `gt` and an `lt`), they do not union.\n *\n * Returns the input array itself when there is nothing to filter, so an unfiltered render costs no copy.\n */\nexport function applyFilters<T, TField extends string = string>(\n  items: ReadonlyArray<T>,\n  filters: readonly FilterDescriptor<TField>[],\n  accessors?: FieldAccessors<T, TField>,\n  options: LocaleOptions = {},\n): ReadonlyArray<T> {\n  if (filters.length === 0) return items;\n  return items.filter(filterPredicate(filters, accessors, options));\n}\n","// The Vue seam over the pure selection model — state ownership only. Every op here is `commit(pureOp(...))`;\n// no selection logic lives in this file, so a headless caller and a component behave identically.\n//\n// Controlled value = the KEY ARRAY, not the whole `SelectionState`. A consumer that controls selection wants\n// to own \"what is selected\" (it round-trips to a URL, a form, a server); it does not want to own the anchor,\n// which is interaction history with no meaning outside this composable. So the keys flow through\n// `useControlled` while the anchor stays internal — which is what makes shift-click keep working on a fully\n// controlled list, where a naive implementation loses the anchor whenever the parent republishes its keys.\n//\n// The mode is applied by re-deriving the state through `createSelection` in a `computed`, so a controlled\n// parent that hands `['a','b']` to a `single`-mode list gets the model's normalisation rather than an invalid\n// state.\n//\n// `commit` short-circuits on reference equality: the pure ops return the same state for a no-op, so an inert\n// click (a `none`-mode row, deselecting an unselected key) fires no `onSelectionChange` at all.\n\nimport { computed, shallowRef, toValue, type ComputedRef, type MaybeRefOrGetter } from 'vue';\n\nimport { useControlled } from '../hooks/useControlled';\n\nimport {\n  clear,\n  createSelection,\n  deselect,\n  extendSelection,\n  invert,\n  select,\n  selectAll,\n  selectRange,\n  selectedKeys,\n  selectionStatus,\n  toggle,\n  toggleAll,\n  SelectionMode,\n  type SelectionKey,\n  type SelectionState,\n  type SelectionStatus,\n  type SelectRangeOptions,\n} from './Selection';\n\n/** The stable empty seed — a module constant so an uncontrolled composable never re-seeds from a fresh literal. */\nconst NO_KEYS: readonly never[] = Object.freeze([]);\n\n/** Options accepted by {@link useSelection}. All are optional; the default is an uncontrolled multi-select. */\nexport interface UseSelectionOptions<TKey extends SelectionKey> {\n  /** The selection mode. Defaults to `'multiple'`. */\n  mode?: MaybeRefOrGetter<SelectionMode | undefined>;\n  /** The controlled selected keys. Pass to own the selection; omit for uncontrolled. */\n  selectedKeys?: MaybeRefOrGetter<ReadonlyArray<TKey> | undefined>;\n  /** The initial selected keys when uncontrolled. Read once; ignored while `selectedKeys` is passed. */\n  defaultSelectedKeys?: MaybeRefOrGetter<ReadonlyArray<TKey> | undefined>;\n  /** Fires with the next key list whenever the selection actually changes. */\n  onSelectionChange?: (keys: readonly TKey[]) => void;\n}\n\n/** The selection state and bound operations returned by {@link useSelection}. */\nexport interface SelectionControls<TKey extends SelectionKey> {\n  /** The current immutable snapshot — pass to the pure model for anything not covered here. */\n  readonly state: ComputedRef<SelectionState<TKey>>;\n  /** The selected keys in insertion order. */\n  readonly keys: ComputedRef<readonly TKey[]>;\n  /** The mode in force. */\n  readonly mode: ComputedRef<SelectionMode>;\n  /** The number of selected keys. */\n  readonly count: ComputedRef<number>;\n  /** Reports whether a key is selected. */\n  readonly isSelected: (key: TKey) => boolean;\n  /** The tri-state for a header checkbox over the given (usually filtered) keys. */\n  readonly status: (keys: Iterable<TKey>) => SelectionStatus;\n  /** Selects a key and anchors on it. */\n  readonly select: (key: TKey) => void;\n  /** Deselects a key and anchors on it. */\n  readonly deselect: (key: TKey) => void;\n  /** Flips a key and anchors on it — the plain click. */\n  readonly toggle: (key: TKey) => void;\n  /** Adds every given key to the selection. */\n  readonly selectAll: (keys: Iterable<TKey>) => void;\n  /** Empties the selection and drops the anchor. */\n  readonly clear: () => void;\n  /** Flips every given key, leaving keys outside the set alone. */\n  readonly invert: (keys: Iterable<TKey>) => void;\n  /** The header-checkbox click over the given keys. */\n  readonly toggleAll: (keys: Iterable<TKey>) => void;\n  /** Selects the run between an explicit anchor and a target, in the surface's visual order. */\n  readonly selectRange: (\n    anchor: TKey,\n    target: TKey,\n    orderedKeys: readonly TKey[],\n    options?: SelectRangeOptions,\n  ) => void;\n  /** The shift-click — extends from the tracked anchor to the target. */\n  readonly extend: (target: TKey, orderedKeys: readonly TKey[], options?: SelectRangeOptions) => void;\n}\n\n/**\n * Binds the selection model to reactive state, controlled or uncontrolled.\n *\n * Controlled when `selectedKeys` resolves to a defined value: the composable never stores keys, it only calls\n * `onSelectionChange` with the next list. Uncontrolled otherwise, seeded from `defaultSelectedKeys`, with\n * `onSelectionChange` still firing so a consumer can observe without owning.\n */\nexport function useSelection<TKey extends SelectionKey>(\n  options: UseSelectionOptions<TKey> = {},\n): SelectionControls<TKey> {\n  const { mode, selectedKeys: controlledKeys, defaultSelectedKeys, onSelectionChange } = options;\n\n  const { value: keys, setValue: setKeys } = useControlled<readonly TKey[]>({\n    controlled: () => toValue(controlledKeys),\n    default: () => toValue(defaultSelectedKeys) ?? NO_KEYS,\n    onChange: onSelectionChange,\n  });\n  const anchor = shallowRef<TKey | null>(null);\n\n  const state = computed(() =>\n    createSelection(toValue(mode) ?? SelectionMode.Multiple, keys.value, anchor.value),\n  );\n\n  const commit = (next: SelectionState<TKey>): void => {\n    // Pure ops return the same reference for a no-op — nothing to publish, no listener to wake.\n    if (next === state.value) return;\n    anchor.value = next.anchor;\n    setKeys(selectedKeys(next));\n  };\n\n  return {\n    state,\n    keys: computed(() => selectedKeys(state.value)),\n    mode: computed(() => state.value.mode),\n    count: computed(() => state.value.keys.size),\n    isSelected: (key) => state.value.keys.has(key),\n    status: (scope) => selectionStatus(state.value, scope),\n    select: (key) => commit(select(state.value, key)),\n    deselect: (key) => commit(deselect(state.value, key)),\n    toggle: (key) => commit(toggle(state.value, key)),\n    selectAll: (scope) => commit(selectAll(state.value, scope)),\n    clear: () => commit(clear(state.value)),\n    invert: (scope) => commit(invert(state.value, scope)),\n    toggleAll: (scope) => commit(toggleAll(state.value, scope)),\n    selectRange: (rangeAnchor, target, orderedKeys, rangeOptions) =>\n      commit(selectRange(state.value, rangeAnchor, target, orderedKeys, rangeOptions)),\n    extend: (target, orderedKeys, rangeOptions) =>\n      commit(extendSelection(state.value, target, orderedKeys, rangeOptions)),\n  };\n}\n","// The Vue seam over the pure sort model — descriptor-list state, controlled or uncontrolled.\n//\n// Deliberately NOT exposed here: a `sortItems(items)` convenience. The honest seam is: the composable owns the\n// descriptors, the consumer calls the pure `applySort(items, controls.descriptors.value, accessors)` inside its\n// own `computed`. A sorting function handed back from here would close over items it does not own, and would\n// invite exactly the re-sort-on-every-read bug this model exists to avoid. Same for `useFilters`.\n//\n// The controlled value is the descriptor ARRAY even for single-field sort, so switching a surface from\n// single to multi is a flag (`isMulti`) rather than a state-shape migration.\n\nimport { computed, toValue, type ComputedRef, type MaybeRefOrGetter } from 'vue';\n\nimport { useControlled } from '../hooks/useControlled';\n\nimport { sortDirectionFor, sortIndexFor, toggleSort, type SortDescriptor, type SortDirection } from './Sort';\n\n/** The stable empty seed — a module constant so an uncontrolled composable never re-seeds from a fresh literal. */\nconst NO_SORT: readonly never[] = Object.freeze([]);\n\n/** Options accepted by {@link useSort}. All are optional; the default is an uncontrolled single-field sort. */\nexport interface UseSortOptions<TField extends string = string> {\n  /** The controlled ordering. Pass to own the sort state; omit for uncontrolled. */\n  sort?: MaybeRefOrGetter<readonly SortDescriptor<TField>[] | undefined>;\n  /** The initial ordering when uncontrolled. Read once; ignored while `sort` is passed. */\n  defaultSort?: MaybeRefOrGetter<readonly SortDescriptor<TField>[] | undefined>;\n  /** Fires with the next ordering whenever it changes. */\n  onSortChange?: (sort: readonly SortDescriptor<TField>[]) => void;\n  /** The multi-field behaviour of {@link SortControls.toggle}. Defaults to `false` (one sorted field). */\n  isMulti?: MaybeRefOrGetter<boolean | undefined>;\n}\n\n/** The sort state and bound operations returned by {@link useSort}. */\nexport interface SortControls<TField extends string = string> {\n  /** The current ordering — array order is precedence. Feed to `applySort` / `sortComparator`. */\n  readonly descriptors: ComputedRef<readonly SortDescriptor<TField>[]>;\n  /** Advances a field through `asc → desc → none` — the header click. */\n  readonly toggle: (field: TField) => void;\n  /** Replaces the whole ordering — for a \"sort by\" menu that sets state outright. */\n  readonly setSort: (descriptors: readonly SortDescriptor<TField>[]) => void;\n  /** Drops all ordering. */\n  readonly clear: () => void;\n  /** The direction applied to a field, or `null` when unsorted — drives the header's arrow and `aria-sort`. */\n  readonly directionFor: (field: TField) => SortDirection | null;\n  /** The 0-based precedence of a field, or `-1` — the multi-sort header's order badge. */\n  readonly indexFor: (field: TField) => number;\n}\n\n/**\n * Binds the sort model to reactive state, controlled or uncontrolled.\n *\n * Controlled when `sort` resolves to a defined value: the composable stores nothing and only calls\n * `onSortChange` — the shape a server-side sorted table wants, where the ordering round-trips through a query\n * rather than local state.\n */\nexport function useSort<TField extends string = string>(\n  options: UseSortOptions<TField> = {},\n): SortControls<TField> {\n  const { sort, defaultSort, onSortChange, isMulti } = options;\n\n  const { value: descriptors, setValue: setDescriptors } = useControlled<readonly SortDescriptor<TField>[]>({\n    controlled: () => toValue(sort),\n    default: () => toValue(defaultSort) ?? NO_SORT,\n    onChange: onSortChange,\n  });\n\n  return {\n    descriptors: computed(() => descriptors.value),\n    toggle: (field) =>\n      setDescriptors(toggleSort(descriptors.value, field, { isMulti: toValue(isMulti) ?? false })),\n    setSort: setDescriptors,\n    clear: () => setDescriptors(NO_SORT),\n    directionFor: (field) => sortDirectionFor(descriptors.value, field),\n    indexFor: (field) => sortIndexFor(descriptors.value, field),\n  };\n}\n","// The Vue seam over the pure filter model — clause-list state, controlled or uncontrolled.\n//\n// `setFilter` upserts BY FIELD, which is the filter-bar shape: one control per column, changing it replaces\n// that column's clause in place rather than stacking a second one. The model itself allows several clauses on\n// one field (a `gt` and an `lt` AND-ed into a range), and that stays reachable through `setFilters` — the\n// upsert is a convenience over the common case, not a restriction of the model.\n//\n// As with `useSort`, no `filterItems(items)` convenience: the pure `applyFilters(items, controls.filters.value)`\n// belongs in the consumer's own `computed`. A function handed back from here would close over items it does not\n// own.\n\nimport { computed, toValue, type ComputedRef, type MaybeRefOrGetter } from 'vue';\n\nimport { useControlled } from '../hooks/useControlled';\n\nimport type { FilterDescriptor } from './Filter';\n\n/** The stable empty seed — a module constant so an uncontrolled composable never re-seeds from a fresh literal. */\nconst NO_FILTERS: readonly never[] = Object.freeze([]);\n\n/** Options accepted by {@link useFilters}. All are optional; the default is an uncontrolled empty filter set. */\nexport interface UseFiltersOptions<TField extends string = string> {\n  /** The controlled clause list. Pass to own the filter state; omit for uncontrolled. */\n  filters?: MaybeRefOrGetter<readonly FilterDescriptor<TField>[] | undefined>;\n  /** The initial clause list when uncontrolled. Read once; ignored while `filters` is passed. */\n  defaultFilters?: MaybeRefOrGetter<readonly FilterDescriptor<TField>[] | undefined>;\n  /** Fires with the next clause list whenever it changes. */\n  onFiltersChange?: (filters: readonly FilterDescriptor<TField>[]) => void;\n}\n\n/** The filter state and bound operations returned by {@link useFilters}. */\nexport interface FilterControls<TField extends string = string> {\n  /** The current clauses, AND-ed. Feed to `applyFilters` / `filterPredicate`. */\n  readonly filters: ComputedRef<readonly FilterDescriptor<TField>[]>;\n  /** Replaces the whole clause list — the escape hatch for several clauses on one field. */\n  readonly setFilters: (filters: readonly FilterDescriptor<TField>[]) => void;\n  /** Upserts a clause by field, keeping its position when it already exists. */\n  readonly setFilter: (filter: FilterDescriptor<TField>) => void;\n  /** Drops every clause on a field. */\n  readonly removeFilter: (field: TField) => void;\n  /** Drops every clause. */\n  readonly clear: () => void;\n  /** The first clause on a field, or `undefined` — what a filter-bar control reads to render its value. */\n  readonly filterFor: (field: TField) => FilterDescriptor<TField> | undefined;\n}\n\n/**\n * Binds the filter model to reactive state, controlled or uncontrolled.\n *\n * Controlled when `filters` resolves to a defined value: the composable stores nothing and only calls\n * `onFiltersChange` — the shape a server-side filtered list wants, where the clauses round-trip through a\n * query.\n */\nexport function useFilters<TField extends string = string>(\n  options: UseFiltersOptions<TField> = {},\n): FilterControls<TField> {\n  const { filters: controlledFilters, defaultFilters, onFiltersChange } = options;\n\n  const { value: filters, setValue: setFilters } = useControlled<readonly FilterDescriptor<TField>[]>({\n    controlled: () => toValue(controlledFilters),\n    default: () => toValue(defaultFilters) ?? NO_FILTERS,\n    onChange: onFiltersChange,\n  });\n\n  const setFilter = (filter: FilterDescriptor<TField>): void => {\n    const current = filters.value;\n    const index = current.findIndex((candidate) => candidate.field === filter.field);\n    if (index === -1) {\n      setFilters([...current, filter]);\n      return;\n    }\n    setFilters(current.map((candidate, at) => (at === index ? filter : candidate)));\n  };\n\n  const removeFilter = (field: TField): void =>\n    setFilters(filters.value.filter((candidate) => candidate.field !== field));\n\n  return {\n    filters: computed(() => filters.value),\n    setFilters,\n    setFilter,\n    removeFilter,\n    clear: () => setFilters(NO_FILTERS),\n    filterFor: (field) => filters.value.find((candidate) => candidate.field === field),\n  };\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../../../src/foundation/selection/models/Field.ts","../../../src/foundation/selection/models/Selection.ts","../../../src/foundation/selection/models/Sort.ts","../../../src/foundation/selection/models/Filter.ts","../../../src/foundation/selection/hooks/UseSelection.ts","../../../src/foundation/selection/hooks/UseSort.ts","../../../src/foundation/selection/hooks/UseFilters.ts"],"sourcesContent":["// The one field-reading seam shared by the sort and filter models. Both answer the same question —\n// \"given an item and a field name, what value do I compare?\" — so the vocabulary lives here rather than\n// being defined twice and drifting.\n//\n// Accessors are OPTIONAL by design: the overwhelmingly common table column sorts on a plain property, so\n// `readField` falls back to a direct property read when no accessor is registered for the field. That\n// keeps the zero-config call (`applySort(rows, [{ field: 'name', direction: 'asc' }])`) working while\n// still letting a computed column (`fullName`, `total`) register a real accessor.\n//\n// The map is `Partial` on purpose: with `noUncheckedIndexedAccess` a `Partial<Record<TField, F>>` lookup\n// is `F | undefined` for BOTH a `string` field type and a literal union, so the guard below type-checks\n// identically either way — no cast, no `any`.\n\n/** Represents the value extraction for one field of an item — the unit a comparator or predicate reads. */\nexport type FieldAccessor<T> = (item: T) => unknown;\n\n/**\n * Represents the field-name → accessor registry handed to {@link readField}, `applySort`, and `applyFilters`.\n * Every entry is optional; a field with no entry falls back to a plain property read.\n */\nexport type FieldAccessors<T, TField extends string = string> = Partial<Readonly<Record<TField, FieldAccessor<T>>>>;\n\n/**\n * Reads one field off an item: the registered accessor when present, otherwise the item's own property of\n * that name. Returns `undefined` for a non-object item with no accessor — which the sort model treats as\n * nullish (sorts last) and the filter model treats as \"matches nothing but a nullish `equals`\".\n */\nexport function readField<T, TField extends string>(\n  item: T,\n  field: TField,\n  accessors?: FieldAccessors<T, TField>,\n): unknown {\n  const accessor: FieldAccessor<T> | undefined = accessors?.[field];\n  if (accessor) return accessor(item);\n  if (typeof item === 'object' && item !== null) {\n    return (item as Record<string, unknown>)[field];\n  }\n  return undefined;\n}\n\n/**\n * Reports whether a value is absent for comparison purposes — `null`, `undefined`, or `NaN`.\n *\n * `NaN` counts as nullish deliberately: it is the one number that makes `a - b` return `NaN`, which would\n * make a comparator non-transitive and leave the sorted order engine-defined. Folding it in with the\n * nullish values gives it a documented home (last) instead.\n */\nexport function isNullish(value: unknown): boolean {\n  return value === null || value === undefined || (typeof value === 'number' && Number.isNaN(value));\n}\n\n/** Represents the locale seam shared by the sort and filter entry points. Omit to use the host default. */\nexport interface LocaleOptions {\n  /** The BCP 47 locale driving string collation (sort) and case folding (filter). Defaults to the host locale. */\n  locale?: string;\n}\n\n/**\n * Coerces any value to text for the filter model's text operators. Symbols are handled explicitly because\n * `String(symbol)` throws, and a filter must never throw on unexpected row data.\n */\nexport function toText(value: unknown): string {\n  if (typeof value === 'string') return value;\n  if (typeof value === 'symbol') return value.toString();\n  return String(value);\n}\n","// Selection — the canonical model behind every selectable surface (DataTable rows, Listbox options, tree\n// nodes, transfer lists). Pure and immutable: every op takes a state and returns a state, never mutates,\n// and returns the SAME reference when the op changed nothing — so a memoized consumer can skip work on an\n// inert click without a deep compare.\n//\n// Why a `Set` plus a separate anchor rather than one array of keys: membership is the hot path (one test\n// per rendered row), and the anchor is selection *history*, not selection *content* — a shift-click must\n// know where the last plain click landed, and that has to survive ops that don't touch the key set.\n//\n// Why `mode` lives IN the state instead of being a per-call argument: the invariants then hold\n// structurally. `none` makes every mutating op inert and `single` caps the set at one key no matter which\n// op a caller reaches for, so a single-select list cannot accumulate keys by calling the wrong function.\n//\n// The set-shaped ops (`selectAll`, `invert`, `toggleAll`, `selectionStatus`) all take an explicit key list\n// rather than reading some ambient \"all rows\". That list is the caller's CURRENT FILTERED PAGE, which is\n// the whole point: a header checkbox on a filtered table must mean \"all matching rows\", and selections\n// made outside the current filter must survive it.\n\n/** Represents the identity of a selectable item — the value a surface keys its rows/options by. */\nexport type SelectionKey = string | number;\n\n/** Defines how many items a surface allows to be selected at once. */\nexport const SelectionMode = {\n  /** Refers to a non-selectable surface — every mutating op is inert. */\n  None: 'none',\n  /** Refers to at most one selected item — selecting replaces rather than accumulates. */\n  Single: 'single',\n  /** Refers to any number of selected items, including ranges. */\n  Multiple: 'multiple',\n} as const;\n\nexport type SelectionMode = (typeof SelectionMode)[keyof typeof SelectionMode];\n\n/** Defines the tri-state a header checkbox renders for a key set. */\nexport const SelectionStatus = {\n  /** Refers to none of the given keys being selected — an unchecked box. */\n  None: 'none',\n  /** Refers to a partial selection — an indeterminate box. */\n  Some: 'some',\n  /** Refers to every given key being selected — a checked box. */\n  All: 'all',\n} as const;\n\nexport type SelectionStatus = (typeof SelectionStatus)[keyof typeof SelectionStatus];\n\n/** Represents an immutable selection snapshot. Build with {@link createSelection}; never construct by hand. */\nexport interface SelectionState<TKey extends SelectionKey> {\n  /** The mode enforced by every op on this state. */\n  readonly mode: SelectionMode;\n  /** The selected keys, in the order they were added. */\n  readonly keys: ReadonlySet<TKey>;\n  /** The last plainly-interacted key — the fixed end of a subsequent range extension, or `null`. */\n  readonly anchor: TKey | null;\n}\n\n/** Options accepted by the range ops. */\nexport interface SelectRangeOptions {\n  /**\n   * The union behaviour. `true` (default) merges the range into the existing selection — the checkbox-list\n   * shift-click every data grid in this SDK wants. `false` replaces the selection with the range alone,\n   * matching a file-manager style list.\n   */\n  isAdditive?: boolean;\n}\n\n/** Reports whether two key sets hold the same members — the identity check behind the no-op short circuit. */\nfunction areKeySetsEqual<TKey extends SelectionKey>(a: ReadonlySet<TKey>, b: ReadonlySet<TKey>): boolean {\n  if (a === b) return true;\n  if (a.size !== b.size) return false;\n  for (const key of a) if (!b.has(key)) return false;\n  return true;\n}\n\n/** Builds the next state, collapsing to the previous reference when nothing actually changed. */\nfunction withSelection<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  keys: ReadonlySet<TKey>,\n  anchor: TKey | null,\n): SelectionState<TKey> {\n  if (anchor === state.anchor && areKeySetsEqual(state.keys, keys)) return state;\n  return { mode: state.mode, keys, anchor };\n}\n\n/**\n * Creates a selection state, normalising the seed to the mode: `none` drops every key, `single` keeps only\n * the first. Also the way to re-mode an existing state — `createSelection('single', state.keys)`.\n *\n * @param mode The selection mode to enforce. Defaults to `'multiple'`.\n * @param keys The initially selected keys, in priority order.\n * @param anchor The initial range anchor. Defaults to `null`.\n */\nexport function createSelection<TKey extends SelectionKey>(\n  mode: SelectionMode = SelectionMode.Multiple,\n  keys: Iterable<TKey> = [],\n  anchor: TKey | null = null,\n): SelectionState<TKey> {\n  if (mode === SelectionMode.None) return { mode, keys: new Set<TKey>(), anchor: null };\n  const seeded = new Set<TKey>(keys);\n  if (mode === SelectionMode.Single && seeded.size > 1) {\n    const first = [...seeded].at(0);\n    return {\n      mode,\n      keys: first === undefined ? new Set<TKey>() : new Set<TKey>([first]),\n      anchor,\n    };\n  }\n  return { mode, keys: seeded, anchor };\n}\n\n/** Reports whether a key is currently selected. */\nexport function isSelected<TKey extends SelectionKey>(state: SelectionState<TKey>, key: TKey): boolean {\n  return state.keys.has(key);\n}\n\n/** The number of selected keys. */\nexport function selectionCount<TKey extends SelectionKey>(state: SelectionState<TKey>): number {\n  return state.keys.size;\n}\n\n/** The selected keys as an array, in insertion order — the shape a controlled `onSelectionChange` emits. */\nexport function selectedKeys<TKey extends SelectionKey>(state: SelectionState<TKey>): ReadonlyArray<TKey> {\n  return [...state.keys];\n}\n\n/**\n * Selects a key and moves the anchor to it. In `single` mode this REPLACES the selection rather than\n * accumulating; in `none` mode it is inert.\n */\nexport function select<TKey extends SelectionKey>(state: SelectionState<TKey>, key: TKey): SelectionState<TKey> {\n  if (state.mode === SelectionMode.None) return state;\n  if (state.mode === SelectionMode.Single) return withSelection(state, new Set([key]), key);\n  const next = new Set(state.keys);\n  next.add(key);\n  return withSelection(state, next, key);\n}\n\n/**\n * Deselects a key and moves the anchor to it. Inert in `none` mode, and inert when the key was not\n * selected — an unselected key carries no interaction to anchor on.\n */\nexport function deselect<TKey extends SelectionKey>(state: SelectionState<TKey>, key: TKey): SelectionState<TKey> {\n  if (state.mode === SelectionMode.None || !state.keys.has(key)) return state;\n  const next = new Set(state.keys);\n  next.delete(key);\n  return withSelection(state, next, key);\n}\n\n/**\n * Flips one key's membership and moves the anchor to it — the plain click. In `single` mode, toggling the\n * selected key clears the selection and toggling any other key replaces it.\n */\nexport function toggle<TKey extends SelectionKey>(state: SelectionState<TKey>, key: TKey): SelectionState<TKey> {\n  if (state.mode === SelectionMode.None) return state;\n  return state.keys.has(key) ? deselect(state, key) : select(state, key);\n}\n\n/**\n * Adds every given key to the selection, leaving the anchor and any selection OUTSIDE the given keys\n * untouched — so \"select all\" on a filtered table keeps rows selected under other filters.\n *\n * Inert in `none` and `single` modes: \"all\" has no meaning on a surface that holds at most one key.\n */\nexport function selectAll<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  keys: Iterable<TKey>,\n): SelectionState<TKey> {\n  if (state.mode !== SelectionMode.Multiple) return state;\n  const next = new Set(state.keys);\n  for (const key of keys) next.add(key);\n  return withSelection(state, next, state.anchor);\n}\n\n/** Empties the selection and drops the anchor — with nothing selected there is no range to extend from. */\nexport function clear<TKey extends SelectionKey>(state: SelectionState<TKey>): SelectionState<TKey> {\n  if (state.keys.size === 0 && state.anchor === null) return state;\n  return { mode: state.mode, keys: new Set<TKey>(), anchor: null };\n}\n\n/**\n * Flips the membership of every given key. Keys selected OUTSIDE the given set are left alone, so\n * inverting a filtered page inverts exactly that page.\n *\n * Inert in `none` and `single` modes.\n */\nexport function invert<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  keys: Iterable<TKey>,\n): SelectionState<TKey> {\n  if (state.mode !== SelectionMode.Multiple) return state;\n  const next = new Set(state.keys);\n  for (const key of keys) {\n    if (next.has(key)) next.delete(key);\n    else next.add(key);\n  }\n  return withSelection(state, next, state.anchor);\n}\n\n/**\n * The header-checkbox click: selects every given key unless all of them are already selected, in which\n * case it deselects them. Selections outside the given keys survive either way.\n *\n * Inert in `none` and `single` modes, and on an empty key list.\n */\nexport function toggleAll<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  keys: Iterable<TKey>,\n): SelectionState<TKey> {\n  if (state.mode !== SelectionMode.Multiple) return state;\n  const scope = [...keys];\n  if (scope.length === 0) return state;\n  if (selectionStatus(state, scope) === SelectionStatus.All) {\n    const next = new Set(state.keys);\n    for (const key of scope) next.delete(key);\n    return withSelection(state, next, state.anchor);\n  }\n  return selectAll(state, scope);\n}\n\n/**\n * The tri-state a header checkbox renders for the given keys: `'all'` when every one is selected,\n * `'none'` when none is, `'some'` otherwise. An empty key list is `'none'` — there is nothing to check.\n */\nexport function selectionStatus<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  keys: Iterable<TKey>,\n): SelectionStatus {\n  let total = 0;\n  let hit = 0;\n  for (const key of keys) {\n    total += 1;\n    if (state.keys.has(key)) hit += 1;\n  }\n  if (total === 0 || hit === 0) return SelectionStatus.None;\n  return hit === total ? SelectionStatus.All : SelectionStatus.Some;\n}\n\n/**\n * Selects the contiguous run between two keys — the shift-click. `orderedKeys` is the surface's CURRENT\n * visual order (already sorted and filtered), which is what makes the range mean what the user sees.\n *\n * The anchor is left AT `anchor`, not moved to `target`: successive shift-clicks must all measure from the\n * same fixed end, so dragging a range back and forth grows and shrinks it instead of walking it away.\n *\n * Degenerate cases, all documented rather than thrown: `none` mode is inert; `single` mode collapses to\n * {@link select} on `target`; a `target` missing from `orderedKeys` is inert; an `anchor` missing from\n * `orderedKeys` falls back to selecting `target` alone.\n */\nexport function selectRange<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  anchor: TKey,\n  target: TKey,\n  orderedKeys: ReadonlyArray<TKey>,\n  options: SelectRangeOptions = {},\n): SelectionState<TKey> {\n  if (state.mode === SelectionMode.None) return state;\n  if (state.mode === SelectionMode.Single) return select(state, target);\n\n  const targetIndex = orderedKeys.indexOf(target);\n  if (targetIndex === -1) return state;\n\n  const anchorIndex = orderedKeys.indexOf(anchor);\n  if (anchorIndex === -1) return withSelection(state, new Set([target]), target);\n\n  const start = Math.min(anchorIndex, targetIndex);\n  const end = Math.max(anchorIndex, targetIndex);\n  const run = orderedKeys.slice(start, end + 1);\n\n  const isAdditive = options.isAdditive ?? true;\n  const next = isAdditive ? new Set(state.keys) : new Set<TKey>();\n  for (const key of run) next.add(key);\n  return withSelection(state, next, anchor);\n}\n\n/**\n * The shift-click as a surface actually calls it: extends from the state's own anchor to `target`. With no\n * anchor yet (nothing has been plainly clicked), the target itself becomes the anchor and the range is the\n * single row — which is exactly what a shift-click on a fresh list should do.\n */\nexport function extendSelection<TKey extends SelectionKey>(\n  state: SelectionState<TKey>,\n  target: TKey,\n  orderedKeys: ReadonlyArray<TKey>,\n  options: SelectRangeOptions = {},\n): SelectionState<TKey> {\n  return selectRange(state, state.anchor ?? target, target, orderedKeys, options);\n}\n","// Sort — the canonical descriptor list + comparator behind every sortable surface. A list of\n// `SortDescriptor`s rather than one `{ field, direction }` because multi-field sort is the same model with\n// more entries: precedence IS array order, so a header click that appends a field reads the same as one\n// that replaces it.\n//\n// Two rules are load-bearing and neither is guessable from the types, so they are stated here and tested:\n//\n//   1. NULLISH SORTS LAST IN BOTH DIRECTIONS. The direction flip is applied to the value comparison only,\n//      never to the nullish check. A blank cell is an absence, not a smallest-value — flipping to `desc`\n//      to see the biggest revenue must not float every revenue-less row to the top. (This is where the\n//      model deliberately differs from the ad-hoc comparator in `presentation` DataTable, which negates\n//      the whole result and therefore floats nullish to the top on `desc`.)\n//   2. THE CYCLE IS `asc → desc → none`. A third click clears the field rather than returning to `asc`, so\n//      \"unsorted\" stays reachable by clicking — otherwise a user who sorts a table can never get back to\n//      the server's natural order.\n//\n// String comparison goes through `foundation/i18n`' `compareStrings` — the SDK's one cached, numeric-aware\n// `Intl.Collator`. There is no second collator in this slice, deliberately: text ordering must not differ\n// between a DataTable header and a headless `applySort` call.\n\nimport { ExactNumber } from '../../numbers';\nimport { Temporal } from 'temporal-polyfill';\n\nimport { compareStrings } from '../../i18n/Compare';\nimport { isNullish, readField, type FieldAccessors, type LocaleOptions } from './Field';\n\n/** Defines the ordering applied to a sorted field. */\nexport const SortDirection = {\n  /** Refers to ascending order — smallest/earliest/`false` first. */\n  Asc: 'asc',\n  /** Refers to descending order — largest/latest/`true` first. */\n  Desc: 'desc',\n} as const;\n\nexport type SortDirection = (typeof SortDirection)[keyof typeof SortDirection];\n\n/** Represents one field of an ordering. A list of these is the whole sort state; array order is precedence. */\nexport interface SortDescriptor<TField extends string = string> {\n  /** The field name, resolved through the accessor registry or read as a plain property. */\n  readonly field: TField;\n  /** The direction applied to this field. */\n  readonly direction: SortDirection;\n}\n\n/** Options accepted by {@link toggleSort}. */\nexport interface ToggleSortOptions {\n  /**\n   * The multi-field behaviour. `false` (default) keeps at most one sorted field — a click on a new field\n   * replaces the ordering. `true` appends the new field after the existing ones, so precedence follows\n   * click order (the shift-click-a-second-header behaviour).\n   */\n  isMulti?: boolean;\n}\n\n/**\n * Compares two non-nullish values with the SDK's default ordering, direction-agnostic (callers negate).\n * Handles, in order: numbers, bigints, booleans (`false` before `true`), the `Temporal` types, native\n * `Date`, strings, and finally anything else via its text form.\n *\n * Nullish handling is deliberately NOT here — {@link applySort} applies it outside the direction flip so\n * absent values sort last in both directions. Calling this with a nullish value falls through to the text\n * comparison, which is not the documented ordering.\n */\nexport function compareValues(a: unknown, b: unknown, options: LocaleOptions = {}): number {\n  if (Object.is(a, b)) return 0;\n  if (ExactNumber.isExactNumber(a) && ExactNumber.isExactNumber(b)) {\n    const comparison = a.compare(b);\n    if (comparison.ok) return comparison.value;\n    throw new TypeError('Exact numeric values could not be compared');\n  }\n  if (typeof a === 'number' && typeof b === 'number') return a - b;\n  if (typeof a === 'bigint' && typeof b === 'bigint') return a < b ? -1 : a > b ? 1 : 0;\n  if (typeof a === 'boolean' && typeof b === 'boolean') return Number(a) - Number(b);\n  if (a instanceof Temporal.PlainDate && b instanceof Temporal.PlainDate) return Temporal.PlainDate.compare(a, b);\n  if (a instanceof Temporal.PlainTime && b instanceof Temporal.PlainTime) return Temporal.PlainTime.compare(a, b);\n  if (a instanceof Temporal.PlainDateTime && b instanceof Temporal.PlainDateTime)\n    return Temporal.PlainDateTime.compare(a, b);\n  if (a instanceof Temporal.ZonedDateTime && b instanceof Temporal.ZonedDateTime)\n    return Temporal.ZonedDateTime.compare(a, b);\n  if (a instanceof Temporal.Instant && b instanceof Temporal.Instant) return Temporal.Instant.compare(a, b);\n  // Native `Date` stays supported: a consumer's row data is arbitrary, and a `Date` in a column must not\n  // silently degrade to a string comparison of its locale form.\n  if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();\n  if (typeof a === 'string' && typeof b === 'string') return compareStrings(a, b, options.locale);\n  return compareStrings(String(a), String(b), options.locale);\n}\n\n/** The direction currently applied to a field, or `null` when the field is unsorted. */\nexport function sortDirectionFor<TField extends string>(\n  descriptors: ReadonlyArray<SortDescriptor<TField>>,\n  field: TField,\n): SortDirection | null {\n  return descriptors.find((descriptor) => descriptor.field === field)?.direction ?? null;\n}\n\n/**\n * The 0-based precedence of a field in the ordering, or `-1` when unsorted — the number a multi-sort header\n * renders as its \"1 / 2 / 3\" badge (add one for display).\n */\nexport function sortIndexFor<TField extends string>(\n  descriptors: ReadonlyArray<SortDescriptor<TField>>,\n  field: TField,\n): number {\n  return descriptors.findIndex((descriptor) => descriptor.field === field);\n}\n\n/**\n * Advances one field through the `asc → desc → none` cycle and returns the next descriptor list.\n *\n * Single-field (default): the result is `[{ field, 'asc' }]`, `[{ field, 'desc' }]`, or `[]`. Clicking a\n * different field restarts that field's cycle at `asc` and drops the previous one.\n *\n * Multi-field (`{ isMulti: true }`): the field keeps its position while cycling `asc → desc`, and the third\n * click removes it, leaving the other fields' precedence intact. A field not yet in the list is appended.\n */\nexport function toggleSort<TField extends string>(\n  descriptors: ReadonlyArray<SortDescriptor<TField>>,\n  field: TField,\n  options: ToggleSortOptions = {},\n): ReadonlyArray<SortDescriptor<TField>> {\n  const current = sortDirectionFor(descriptors, field);\n  const isMulti = options.isMulti ?? false;\n\n  if (!isMulti) {\n    if (current === SortDirection.Asc) return [{ field, direction: SortDirection.Desc }];\n    if (current === SortDirection.Desc) return [];\n    return [{ field, direction: SortDirection.Asc }];\n  }\n\n  if (current === null) return [...descriptors, { field, direction: SortDirection.Asc }];\n  if (current === SortDirection.Desc) {\n    return descriptors.filter((descriptor) => descriptor.field !== field);\n  }\n  return descriptors.map((descriptor) =>\n    descriptor.field === field ? { field, direction: SortDirection.Desc } : descriptor,\n  );\n}\n\n/**\n * Builds the comparator an ordering describes — exported so a virtualised or server-side surface can feed\n * it to its own machinery instead of materialising a sorted array.\n *\n * Fields are consulted in array order and the first non-zero result wins. Within each field: absent values\n * (`null` / `undefined` / `NaN`) sort last regardless of direction, then {@link compareValues} decides and\n * the direction is applied to that result only.\n */\nexport function sortComparator<T, TField extends string = string>(\n  descriptors: ReadonlyArray<SortDescriptor<TField>>,\n  accessors?: FieldAccessors<T, TField>,\n  options: LocaleOptions = {},\n): (a: T, b: T) => number {\n  return (a, b) => {\n    for (const descriptor of descriptors) {\n      const left = readField(a, descriptor.field, accessors);\n      const right = readField(b, descriptor.field, accessors);\n\n      const isLeftNullish = isNullish(left);\n      const isRightNullish = isNullish(right);\n      if (isLeftNullish || isRightNullish) {\n        if (isLeftNullish && isRightNullish) continue;\n        return isLeftNullish ? 1 : -1;\n      }\n\n      const result = compareValues(left, right, options);\n      if (result !== 0) return descriptor.direction === SortDirection.Desc ? -result : result;\n    }\n    return 0;\n  };\n}\n\n/**\n * Sorts a list by an ordering, without mutating the input. Returns the input array itself when there is\n * nothing to order, so an unsorted render costs no copy.\n *\n * The sort is stable (`Array.prototype.sort` has been stable since ES2019), which is what makes multi-field\n * ordering composable: equal rows keep the order the previous field — or the server — put them in.\n */\nexport function applySort<T, TField extends string = string>(\n  items: ReadonlyArray<T>,\n  descriptors: ReadonlyArray<SortDescriptor<TField>>,\n  accessors?: FieldAccessors<T, TField>,\n  options: LocaleOptions = {},\n): ReadonlyArray<T> {\n  if (descriptors.length === 0) return items;\n  return [...items].sort(sortComparator(descriptors, accessors, options));\n}\n","// Filter — predicate composition over a small, CLOSED operator set. Seven operators, no `or`, no nesting,\n// no expression tree: this is deliberately not a query language. A filter bar, a column filter menu, and a\n// faceted sidebar all reduce to \"field, operator, value, AND-ed together\", and every product that has\n// needed more has needed a *server* query, not a richer client model. Growing this into a DSL would put a\n// second, weaker query engine in the client and invite it to drift from the backend's.\n//\n// Operator semantics, all of which are choices rather than derivations:\n//   - `equals`      — no cross-type coercion; `'2'` does not equal `2`. Strings compare case-folded.\n//   - `contains`    — substring of the value's text form.\n//   - `startsWith`  — prefix of the value's text form.\n//   - `gt` / `lt`   — strict, via the sort model's `compareValues` (numbers, dates, Temporal, text).\n//   - `between`     — INCLUSIVE on both bounds; reversed bounds are normalised rather than matching nothing.\n//   - `in`          — membership, entry-wise `equals`.\n//\n// Text operators are CASE-INSENSITIVE by default (`isCaseSensitive: true` opts out) because a filter box is\n// a human typing, not a key lookup.\n//\n// Case folding here uses `toLocaleLowerCase`, not the collator that `Sort` uses. That split is intentional:\n// `contains`/`startsWith` need substring semantics, which a collator cannot express, and having `equals`\n// silently follow collator rules would make `'2'` match `'02'` under numeric collation. Ordering is a\n// collator's job; matching is not.\n//\n// An absent field value (`null` / `undefined` / `NaN`) matches ONLY a nullish `equals` (or an `in` list\n// containing one). Every other operator rejects it — there is no ordering or substring of an absence.\n\nimport { ExactNumber } from '../../numbers';\nimport { Temporal } from 'temporal-polyfill';\n\nimport { isNullish, readField, toText, type FieldAccessors, type LocaleOptions } from './Field';\nimport { compareValues } from './Sort';\n\n/** Defines the closed set of comparisons a filter may express. */\nexport const FilterOperator = {\n  /** Refers to exact equality — case-folded for strings, no cross-type coercion. */\n  Equals: 'equals',\n  /** Refers to a substring match on the value's text form. */\n  Contains: 'contains',\n  /** Refers to a prefix match on the value's text form. */\n  StartsWith: 'startsWith',\n  /** Refers to a strictly-greater-than comparison. */\n  GreaterThan: 'gt',\n  /** Refers to a strictly-less-than comparison. */\n  LessThan: 'lt',\n  /** Refers to an inclusive range check between two bounds. */\n  Between: 'between',\n  /** Refers to membership in a fixed list of values. */\n  In: 'in',\n} as const;\n\nexport type FilterOperator = (typeof FilterOperator)[keyof typeof FilterOperator];\n\n/** The fields every filter carries, whatever its operator. */\ninterface FilterBase<TField extends string> {\n  /** The field name, resolved through the accessor registry or read as a plain property. */\n  readonly field: TField;\n  /** The case sensitivity of string comparison. Defaults to `false` — text operators fold case. */\n  readonly isCaseSensitive?: boolean;\n}\n\n/** Represents a filter whose operator takes a single comparison value. */\nexport interface ValueFilter<TField extends string = string> extends FilterBase<TField> {\n  /** The comparison applied to the field. */\n  readonly op: 'equals' | 'contains' | 'startsWith' | 'gt' | 'lt';\n  /** The value compared against the field. */\n  readonly value: unknown;\n}\n\n/** Represents an inclusive range filter. Bounds may be given in either order. */\nexport interface BetweenFilter<TField extends string = string> extends FilterBase<TField> {\n  /** The comparison applied to the field. */\n  readonly op: 'between';\n  /** The inclusive `[low, high]` bounds — normalised when reversed. */\n  readonly value: readonly [unknown, unknown];\n}\n\n/** Represents a membership filter over a fixed candidate list. */\nexport interface InFilter<TField extends string = string> extends FilterBase<TField> {\n  /** The comparison applied to the field. */\n  readonly op: 'in';\n  /** The candidate values; the field matches when it equals any of them. */\n  readonly value: ReadonlyArray<unknown>;\n}\n\n/**\n * Represents one filter clause. A discriminated union rather than `{ field, op, value: unknown }` so the\n * value shape each operator requires — a 2-tuple for `between`, an array for `in` — is checked at the call\n * site instead of failing at match time.\n */\nexport type FilterDescriptor<TField extends string = string> =\n  ValueFilter<TField> | BetweenFilter<TField> | InFilter<TField>;\n\n/** Reports whether a value is a date-like instance, which compares by value rather than identity. */\nfunction isDateLike(value: unknown): boolean {\n  return (\n    value instanceof Date ||\n    value instanceof Temporal.PlainDate ||\n    value instanceof Temporal.PlainTime ||\n    value instanceof Temporal.PlainDateTime ||\n    value instanceof Temporal.ZonedDateTime ||\n    value instanceof Temporal.Instant\n  );\n}\n\n/** Folds a value to its comparable text form, lower-casing unless the filter asked for case sensitivity. */\nfunction foldText(value: unknown, isCaseSensitive: boolean, locale?: string): string {\n  const text = toText(value);\n  return isCaseSensitive ? text : text.toLocaleLowerCase(locale);\n}\n\n/** The equality behind `equals` and `in` — case-folded for strings, by value for dates, else identity. */\nfunction valuesEqual(a: unknown, b: unknown, isCaseSensitive: boolean, locale: string | undefined): boolean {\n  if (isNullish(a) || isNullish(b)) return isNullish(a) && isNullish(b);\n  if (typeof a === 'string' && typeof b === 'string') {\n    return foldText(a, isCaseSensitive, locale) === foldText(b, isCaseSensitive, locale);\n  }\n  if (Object.is(a, b)) return true;\n  if (ExactNumber.isExactNumber(a) && ExactNumber.isExactNumber(b)) return compareValues(a, b, { locale }) === 0;\n  if (isDateLike(a) && isDateLike(b)) return compareValues(a, b, { locale }) === 0;\n  return false;\n}\n\n/**\n * Reports whether one item satisfies one filter clause. Exported for the surfaces that test a single row —\n * an optimistic insert deciding whether the new row belongs in the current view, for instance.\n */\nexport function matchesFilter<T, TField extends string = string>(\n  item: T,\n  filter: FilterDescriptor<TField>,\n  accessors?: FieldAccessors<T, TField>,\n  options: LocaleOptions = {},\n): boolean {\n  const locale = options.locale;\n  const isCaseSensitive = filter.isCaseSensitive ?? false;\n  const fieldValue = readField(item, filter.field, accessors);\n\n  switch (filter.op) {\n    case FilterOperator.Equals:\n      return valuesEqual(fieldValue, filter.value, isCaseSensitive, locale);\n\n    case FilterOperator.In:\n      return filter.value.some((candidate) => valuesEqual(fieldValue, candidate, isCaseSensitive, locale));\n\n    case FilterOperator.Contains: {\n      if (isNullish(fieldValue) || isNullish(filter.value)) return false;\n      return foldText(fieldValue, isCaseSensitive, locale).includes(foldText(filter.value, isCaseSensitive, locale));\n    }\n\n    case FilterOperator.StartsWith: {\n      if (isNullish(fieldValue) || isNullish(filter.value)) return false;\n      return foldText(fieldValue, isCaseSensitive, locale).startsWith(foldText(filter.value, isCaseSensitive, locale));\n    }\n\n    case FilterOperator.GreaterThan: {\n      if (isNullish(fieldValue) || isNullish(filter.value)) return false;\n      return compareValues(fieldValue, filter.value, { locale }) > 0;\n    }\n\n    case FilterOperator.LessThan: {\n      if (isNullish(fieldValue) || isNullish(filter.value)) return false;\n      return compareValues(fieldValue, filter.value, { locale }) < 0;\n    }\n\n    case FilterOperator.Between: {\n      const [first, second] = filter.value;\n      if (isNullish(fieldValue) || isNullish(first) || isNullish(second)) return false;\n      // Normalise reversed bounds: a two-ended range input can be filled in either order, and silently\n      // matching nothing reads as a broken filter rather than a swapped one.\n      const isReversed = compareValues(first, second, { locale }) > 0;\n      const low = isReversed ? second : first;\n      const high = isReversed ? first : second;\n      return compareValues(fieldValue, low, { locale }) >= 0 && compareValues(fieldValue, high, { locale }) <= 0;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Builds the AND-ed predicate a filter list describes — exported so a virtualised or streaming surface can\n * test rows as they arrive instead of materialising a filtered array.\n */\nexport function filterPredicate<T, TField extends string = string>(\n  filters: ReadonlyArray<FilterDescriptor<TField>>,\n  accessors?: FieldAccessors<T, TField>,\n  options: LocaleOptions = {},\n): (item: T) => boolean {\n  return (item) => filters.every((filter) => matchesFilter(item, filter, accessors, options));\n}\n\n/**\n * Keeps the items matching every filter. Clauses combine with AND — two clauses on the same field narrow\n * each other (the `between` of a `gt` and an `lt`), they do not union.\n *\n * Returns the input array itself when there is nothing to filter, so an unfiltered render costs no copy.\n */\nexport function applyFilters<T, TField extends string = string>(\n  items: ReadonlyArray<T>,\n  filters: ReadonlyArray<FilterDescriptor<TField>>,\n  accessors?: FieldAccessors<T, TField>,\n  options: LocaleOptions = {},\n): ReadonlyArray<T> {\n  if (filters.length === 0) return items;\n  return items.filter(filterPredicate(filters, accessors, options));\n}\n","// The Vue seam over the pure selection model — state ownership only. Every op here is `commit(pureOp(...))`;\n// no selection logic lives in this file, so a headless caller and a component behave identically.\n//\n// Controlled value = the KEY ARRAY, not the whole `SelectionState`. A consumer that controls selection wants\n// to own \"what is selected\" (it round-trips to a URL, a form, a server); it does not want to own the anchor,\n// which is interaction history with no meaning outside this composable. So the keys flow through\n// `useControlled` while the anchor stays internal — which is what makes shift-click keep working on a fully\n// controlled list, where a naive implementation loses the anchor whenever the parent republishes its keys.\n//\n// The mode is applied by re-deriving the state through `createSelection` in a `computed`, so a controlled\n// parent that hands `['a','b']` to a `single`-mode list gets the model's normalisation rather than an invalid\n// state.\n//\n// `commit` short-circuits on reference equality: the pure ops return the same state for a no-op, so an inert\n// click (a `none`-mode row, deselecting an unselected key) fires no `onSelectionChange` at all.\n\nimport { computed, shallowRef, toValue, type ComputedRef, type MaybeRefOrGetter } from 'vue';\n\nimport { useControlled } from '../../state/hooks/UseControlled';\n\nimport {\n  clear,\n  createSelection,\n  deselect,\n  extendSelection,\n  invert,\n  select,\n  selectAll,\n  selectRange,\n  selectedKeys,\n  selectionStatus,\n  toggle,\n  toggleAll,\n  SelectionMode,\n  type SelectionKey,\n  type SelectionState,\n  type SelectionStatus,\n  type SelectRangeOptions,\n} from '../models/Selection';\n\n/** The stable empty seed — a module constant so an uncontrolled composable never re-seeds from a fresh literal. */\nconst NoKeys: ReadonlyArray<never> = Object.freeze([]);\n\n/** Options accepted by {@link useSelection}. All are optional; the default is an uncontrolled multi-select. */\nexport interface UseSelectionOptions<TKey extends SelectionKey> {\n  /** The selection mode. Defaults to `'multiple'`. */\n  mode?: MaybeRefOrGetter<SelectionMode | undefined>;\n  /** The controlled selected keys. Pass to own the selection; omit for uncontrolled. */\n  selectedKeys?: MaybeRefOrGetter<ReadonlyArray<TKey> | undefined>;\n  /** The initial selected keys when uncontrolled. Read once; ignored while `selectedKeys` is passed. */\n  defaultSelectedKeys?: MaybeRefOrGetter<ReadonlyArray<TKey> | undefined>;\n  /** Fires with the next key list whenever the selection actually changes. */\n  onSelectionChange?: (keys: ReadonlyArray<TKey>) => void;\n}\n\n/** The selection state and bound operations returned by {@link useSelection}. */\nexport interface SelectionControls<TKey extends SelectionKey> {\n  /** The current immutable snapshot — pass to the pure model for anything not covered here. */\n  readonly state: ComputedRef<SelectionState<TKey>>;\n  /** The selected keys in insertion order. */\n  readonly keys: ComputedRef<ReadonlyArray<TKey>>;\n  /** The mode in force. */\n  readonly mode: ComputedRef<SelectionMode>;\n  /** The number of selected keys. */\n  readonly count: ComputedRef<number>;\n  /** Reports whether a key is selected. */\n  readonly isSelected: (key: TKey) => boolean;\n  /** The tri-state for a header checkbox over the given (usually filtered) keys. */\n  readonly status: (keys: Iterable<TKey>) => SelectionStatus;\n  /** Selects a key and anchors on it. */\n  readonly select: (key: TKey) => void;\n  /** Deselects a key and anchors on it. */\n  readonly deselect: (key: TKey) => void;\n  /** Flips a key and anchors on it — the plain click. */\n  readonly toggle: (key: TKey) => void;\n  /** Adds every given key to the selection. */\n  readonly selectAll: (keys: Iterable<TKey>) => void;\n  /** Empties the selection and drops the anchor. */\n  readonly clear: () => void;\n  /** Flips every given key, leaving keys outside the set alone. */\n  readonly invert: (keys: Iterable<TKey>) => void;\n  /** The header-checkbox click over the given keys. */\n  readonly toggleAll: (keys: Iterable<TKey>) => void;\n  /** Selects the run between an explicit anchor and a target, in the surface's visual order. */\n  readonly selectRange: (\n    anchor: TKey,\n    target: TKey,\n    orderedKeys: ReadonlyArray<TKey>,\n    options?: SelectRangeOptions,\n  ) => void;\n  /** The shift-click — extends from the tracked anchor to the target. */\n  readonly extend: (target: TKey, orderedKeys: ReadonlyArray<TKey>, options?: SelectRangeOptions) => void;\n}\n\n/**\n * Binds the selection model to reactive state, controlled or uncontrolled.\n *\n * Controlled when `selectedKeys` resolves to a defined value: the composable never stores keys, it only calls\n * `onSelectionChange` with the next list. Uncontrolled otherwise, seeded from `defaultSelectedKeys`, with\n * `onSelectionChange` still firing so a consumer can observe without owning.\n */\nexport function useSelection<TKey extends SelectionKey>(\n  options: UseSelectionOptions<TKey> = {},\n): SelectionControls<TKey> {\n  const { mode, selectedKeys: controlledKeys, defaultSelectedKeys, onSelectionChange } = options;\n\n  const { value: keys, setValue: setKeys } = useControlled<readonly TKey[]>({\n    controlled: () => toValue(controlledKeys),\n    default: () => toValue(defaultSelectedKeys) ?? NoKeys,\n    onChange: onSelectionChange,\n  });\n  const anchor = shallowRef<TKey | null>(null);\n\n  const state = computed(() => createSelection(toValue(mode) ?? SelectionMode.Multiple, keys.value, anchor.value));\n\n  const commit = (next: SelectionState<TKey>): void => {\n    // Pure ops return the same reference for a no-op — nothing to publish, no listener to wake.\n    if (next === state.value) return;\n    anchor.value = next.anchor;\n    setKeys(selectedKeys(next));\n  };\n\n  return {\n    state,\n    keys: computed(() => selectedKeys(state.value)),\n    mode: computed(() => state.value.mode),\n    count: computed(() => state.value.keys.size),\n    isSelected: (key) => state.value.keys.has(key),\n    status: (scope) => selectionStatus(state.value, scope),\n    select: (key) => commit(select(state.value, key)),\n    deselect: (key) => commit(deselect(state.value, key)),\n    toggle: (key) => commit(toggle(state.value, key)),\n    selectAll: (scope) => commit(selectAll(state.value, scope)),\n    clear: () => commit(clear(state.value)),\n    invert: (scope) => commit(invert(state.value, scope)),\n    toggleAll: (scope) => commit(toggleAll(state.value, scope)),\n    selectRange: (rangeAnchor, target, orderedKeys, rangeOptions) =>\n      commit(selectRange(state.value, rangeAnchor, target, orderedKeys, rangeOptions)),\n    extend: (target, orderedKeys, rangeOptions) =>\n      commit(extendSelection(state.value, target, orderedKeys, rangeOptions)),\n  };\n}\n","// The Vue seam over the pure sort model — descriptor-list state, controlled or uncontrolled.\n//\n// Deliberately NOT exposed here: a `sortItems(items)` convenience. The honest seam is: the composable owns the\n// descriptors, the consumer calls the pure `applySort(items, controls.descriptors.value, accessors)` inside its\n// own `computed`. A sorting function handed back from here would close over items it does not own, and would\n// invite exactly the re-sort-on-every-read bug this model exists to avoid. Same for `useFilters`.\n//\n// The controlled value is the descriptor ARRAY even for single-field sort, so switching a surface from\n// single to multi is a flag (`isMulti`) rather than a state-shape migration.\n\nimport { computed, toValue, type ComputedRef, type MaybeRefOrGetter } from 'vue';\n\nimport { useControlled } from '../../state/hooks/UseControlled';\n\nimport { sortDirectionFor, sortIndexFor, toggleSort, type SortDescriptor, type SortDirection } from '../models/Sort';\n\n/** The stable empty seed — a module constant so an uncontrolled composable never re-seeds from a fresh literal. */\nconst NoSort: ReadonlyArray<never> = Object.freeze([]);\n\n/** Options accepted by {@link useSort}. All are optional; the default is an uncontrolled single-field sort. */\nexport interface UseSortOptions<TField extends string = string> {\n  /** The controlled ordering. Pass to own the sort state; omit for uncontrolled. */\n  sort?: MaybeRefOrGetter<ReadonlyArray<SortDescriptor<TField>> | undefined>;\n  /** The initial ordering when uncontrolled. Read once; ignored while `sort` is passed. */\n  defaultSort?: MaybeRefOrGetter<ReadonlyArray<SortDescriptor<TField>> | undefined>;\n  /** Fires with the next ordering whenever it changes. */\n  onSortChange?: (sort: ReadonlyArray<SortDescriptor<TField>>) => void;\n  /** The multi-field behaviour of {@link SortControls.toggle}. Defaults to `false` (one sorted field). */\n  isMulti?: MaybeRefOrGetter<boolean | undefined>;\n}\n\n/** The sort state and bound operations returned by {@link useSort}. */\nexport interface SortControls<TField extends string = string> {\n  /** The current ordering — array order is precedence. Feed to `applySort` / `sortComparator`. */\n  readonly descriptors: ComputedRef<ReadonlyArray<SortDescriptor<TField>>>;\n  /** Advances a field through `asc → desc → none` — the header click. */\n  readonly toggle: (field: TField) => void;\n  /** Replaces the whole ordering — for a \"sort by\" menu that sets state outright. */\n  readonly setSort: (descriptors: ReadonlyArray<SortDescriptor<TField>>) => void;\n  /** Drops all ordering. */\n  readonly clear: () => void;\n  /** The direction applied to a field, or `null` when unsorted — drives the header's arrow and `aria-sort`. */\n  readonly directionFor: (field: TField) => SortDirection | null;\n  /** The 0-based precedence of a field, or `-1` — the multi-sort header's order badge. */\n  readonly indexFor: (field: TField) => number;\n}\n\n/**\n * Binds the sort model to reactive state, controlled or uncontrolled.\n *\n * Controlled when `sort` resolves to a defined value: the composable stores nothing and only calls\n * `onSortChange` — the shape a server-side sorted table wants, where the ordering round-trips through a query\n * rather than local state.\n */\nexport function useSort<TField extends string = string>(options: UseSortOptions<TField> = {}): SortControls<TField> {\n  const { sort, defaultSort, onSortChange, isMulti } = options;\n\n  const { value: descriptors, setValue: setDescriptors } = useControlled<readonly SortDescriptor<TField>[]>({\n    controlled: () => toValue(sort),\n    default: () => toValue(defaultSort) ?? NoSort,\n    onChange: onSortChange,\n  });\n\n  return {\n    descriptors: computed(() => descriptors.value),\n    toggle: (field) => setDescriptors(toggleSort(descriptors.value, field, { isMulti: toValue(isMulti) ?? false })),\n    setSort: setDescriptors,\n    clear: () => setDescriptors(NoSort),\n    directionFor: (field) => sortDirectionFor(descriptors.value, field),\n    indexFor: (field) => sortIndexFor(descriptors.value, field),\n  };\n}\n","// The Vue seam over the pure filter model — clause-list state, controlled or uncontrolled.\n//\n// `setFilter` upserts BY FIELD, which is the filter-bar shape: one control per column, changing it replaces\n// that column's clause in place rather than stacking a second one. The model itself allows several clauses on\n// one field (a `gt` and an `lt` AND-ed into a range), and that stays reachable through `setFilters` — the\n// upsert is a convenience over the common case, not a restriction of the model.\n//\n// As with `useSort`, no `filterItems(items)` convenience: the pure `applyFilters(items, controls.filters.value)`\n// belongs in the consumer's own `computed`. A function handed back from here would close over items it does not\n// own.\n\nimport { computed, toValue, type ComputedRef, type MaybeRefOrGetter } from 'vue';\n\nimport { useControlled } from '../../state/hooks/UseControlled';\n\nimport type { FilterDescriptor } from '../models/Filter';\n\n/** The stable empty seed — a module constant so an uncontrolled composable never re-seeds from a fresh literal. */\nconst NoFilters: ReadonlyArray<never> = Object.freeze([]);\n\n/** Options accepted by {@link useFilters}. All are optional; the default is an uncontrolled empty filter set. */\nexport interface UseFiltersOptions<TField extends string = string> {\n  /** The controlled clause list. Pass to own the filter state; omit for uncontrolled. */\n  filters?: MaybeRefOrGetter<ReadonlyArray<FilterDescriptor<TField>> | undefined>;\n  /** The initial clause list when uncontrolled. Read once; ignored while `filters` is passed. */\n  defaultFilters?: MaybeRefOrGetter<ReadonlyArray<FilterDescriptor<TField>> | undefined>;\n  /** Fires with the next clause list whenever it changes. */\n  onFiltersChange?: (filters: ReadonlyArray<FilterDescriptor<TField>>) => void;\n}\n\n/** The filter state and bound operations returned by {@link useFilters}. */\nexport interface FilterControls<TField extends string = string> {\n  /** The current clauses, AND-ed. Feed to `applyFilters` / `filterPredicate`. */\n  readonly filters: ComputedRef<ReadonlyArray<FilterDescriptor<TField>>>;\n  /** Replaces the whole clause list — the escape hatch for several clauses on one field. */\n  readonly setFilters: (filters: ReadonlyArray<FilterDescriptor<TField>>) => void;\n  /** Upserts a clause by field, keeping its position when it already exists. */\n  readonly setFilter: (filter: FilterDescriptor<TField>) => void;\n  /** Drops every clause on a field. */\n  readonly removeFilter: (field: TField) => void;\n  /** Drops every clause. */\n  readonly clear: () => void;\n  /** The first clause on a field, or `undefined` — what a filter-bar control reads to render its value. */\n  readonly filterFor: (field: TField) => FilterDescriptor<TField> | undefined;\n}\n\n/**\n * Binds the filter model to reactive state, controlled or uncontrolled.\n *\n * Controlled when `filters` resolves to a defined value: the composable stores nothing and only calls\n * `onFiltersChange` — the shape a server-side filtered list wants, where the clauses round-trip through a\n * query.\n */\nexport function useFilters<TField extends string = string>(\n  options: UseFiltersOptions<TField> = {},\n): FilterControls<TField> {\n  const { filters: controlledFilters, defaultFilters, onFiltersChange } = options;\n\n  const { value: filters, setValue: setFilters } = useControlled<readonly FilterDescriptor<TField>[]>({\n    controlled: () => toValue(controlledFilters),\n    default: () => toValue(defaultFilters) ?? NoFilters,\n    onChange: onFiltersChange,\n  });\n\n  const setFilter = (filter: FilterDescriptor<TField>): void => {\n    const current = filters.value;\n    const index = current.findIndex((candidate) => candidate.field === filter.field);\n    if (index === -1) {\n      setFilters([...current, filter]);\n      return;\n    }\n    setFilters(current.map((candidate, at) => (at === index ? filter : candidate)));\n  };\n\n  const removeFilter = (field: TField): void =>\n    setFilters(filters.value.filter((candidate) => candidate.field !== field));\n\n  return {\n    filters: computed(() => filters.value),\n    setFilters,\n    setFilter,\n    removeFilter,\n    clear: () => setFilters(NoFilters),\n    filterFor: (field) => filters.value.find((candidate) => candidate.field === field),\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/foundation/selection/models/Filter.d.ts

@@ -0,0 +1,71 @@
+import { FieldAccessors, LocaleOptions } from './Field';
+/** Defines the closed set of comparisons a filter may express. */
+export declare const FilterOperator: {
+    /** Refers to exact equality — case-folded for strings, no cross-type coercion. */
+    readonly Equals: "equals";
+    /** Refers to a substring match on the value's text form. */
+    readonly Contains: "contains";
+    /** Refers to a prefix match on the value's text form. */
+    readonly StartsWith: "startsWith";
+    /** Refers to a strictly-greater-than comparison. */
+    readonly GreaterThan: "gt";
+    /** Refers to a strictly-less-than comparison. */
+    readonly LessThan: "lt";
+    /** Refers to an inclusive range check between two bounds. */
+    readonly Between: "between";
+    /** Refers to membership in a fixed list of values. */
+    readonly In: "in";
+};
+export type FilterOperator = (typeof FilterOperator)[keyof typeof FilterOperator];
+/** The fields every filter carries, whatever its operator. */
+interface FilterBase<TField extends string> {
+    /** The field name, resolved through the accessor registry or read as a plain property. */
+    readonly field: TField;
+    /** The case sensitivity of string comparison. Defaults to `false` — text operators fold case. */
+    readonly isCaseSensitive?: boolean;
+}
+/** Represents a filter whose operator takes a single comparison value. */
+export interface ValueFilter<TField extends string = string> extends FilterBase<TField> {
+    /** The comparison applied to the field. */
+    readonly op: 'equals' | 'contains' | 'startsWith' | 'gt' | 'lt';
+    /** The value compared against the field. */
+    readonly value: unknown;
+}
+/** Represents an inclusive range filter. Bounds may be given in either order. */
+export interface BetweenFilter<TField extends string = string> extends FilterBase<TField> {
+    /** The comparison applied to the field. */
+    readonly op: 'between';
+    /** The inclusive `[low, high]` bounds — normalised when reversed. */
+    readonly value: readonly [unknown, unknown];
+}
+/** Represents a membership filter over a fixed candidate list. */
+export interface InFilter<TField extends string = string> extends FilterBase<TField> {
+    /** The comparison applied to the field. */
+    readonly op: 'in';
+    /** The candidate values; the field matches when it equals any of them. */
+    readonly value: ReadonlyArray<unknown>;
+}
+/**
+ * Represents one filter clause. A discriminated union rather than `{ field, op, value: unknown }` so the
+ * value shape each operator requires — a 2-tuple for `between`, an array for `in` — is checked at the call
+ * site instead of failing at match time.
+ */
+export type FilterDescriptor<TField extends string = string> = ValueFilter<TField> | BetweenFilter<TField> | InFilter<TField>;
+/**
+ * Reports whether one item satisfies one filter clause. Exported for the surfaces that test a single row —
+ * an optimistic insert deciding whether the new row belongs in the current view, for instance.
+ */
+export declare function matchesFilter<T, TField extends string = string>(item: T, filter: FilterDescriptor<TField>, accessors?: FieldAccessors<T, TField>, options?: LocaleOptions): boolean;
+/**
+ * Builds the AND-ed predicate a filter list describes — exported so a virtualised or streaming surface can
+ * test rows as they arrive instead of materialising a filtered array.
+ */
+export declare function filterPredicate<T, TField extends string = string>(filters: ReadonlyArray<FilterDescriptor<TField>>, accessors?: FieldAccessors<T, TField>, options?: LocaleOptions): (item: T) => boolean;
+/**
+ * Keeps the items matching every filter. Clauses combine with AND — two clauses on the same field narrow
+ * each other (the `between` of a `gt` and an `lt`), they do not union.
+ *
+ * Returns the input array itself when there is nothing to filter, so an unfiltered render costs no copy.
+ */
+export declare function applyFilters<T, TField extends string = string>(items: ReadonlyArray<T>, filters: ReadonlyArray<FilterDescriptor<TField>>, accessors?: FieldAccessors<T, TField>, options?: LocaleOptions): ReadonlyArray<T>;
+export {};