@lavalogic/scoria 0.37.44 → 0.37.45

package/dist/Components/Table/Types/Context/QueryValuesState.svelte.d.ts

@@ -0,0 +1,50 @@
+import type { ColumnDef } from '../Columns/Definitions/ColumnDef.svelte.js';
+/**
+ * Sub-context owning the typeahead-echo cache for QuerySelect-backed
+ * filter inputs. Each value here is the last option the user selected
+ * for a column whose filter renders a remote `QuerySelect` — kept so
+ * the chip's label survives a reactive re-render even when the
+ * server-side filter representation in `ColumnFiltersState` is just a
+ * primitive id.
+ *
+ * Why a sub-context (rather than the legacy
+ * `dataRepo.__queryValues: Map<string, unknown>`):
+ *
+ *   - Forces every read and write to flow through methods keyed on the
+ *     `ColumnDef`, so the `def.id` keying contract is checked at the
+ *     call site instead of accidentally diverging (the most recent
+ *     "select snaps back to placeholder" regressions were caused by
+ *     a write keyed by header label vs a read keyed by `def.id`).
+ *   - Lives alongside the other Phase 6 sub-contexts on
+ *     `TableContext`, keeping the data repo focused on data-fetch
+ *     concerns rather than UI-state echo.
+ *   - Backed by a `SvelteMap` so reads inside `$derived` / `$effect`
+ *     blocks re-evaluate when a write lands.
+ */
+export declare class QueryValuesState<TRow extends object> {
+    private readonly _values;
+    /**
+     * Return the cached typeahead echo for `def`, or `undefined` if none
+     * was stored. The generic `V` lets a caller with a typed
+     * `ColumnDef<TRow, V>` narrow the result; defaults to `unknown` for
+     * untyped consumers.
+     */
+    get<V = unknown>(def: ColumnDef<TRow>): V | undefined;
+    /**
+     * Cache the supplied value under `def.id`. Pass `null` to record an
+     * explicit "user cleared the selection" state (still considered
+     * present by `has`); use `delete` to forget the column entirely.
+     */
+    set<V>(def: ColumnDef<TRow>, value: V | null): void;
+    /** True when the column has any cached value (including an explicit `null`). */
+    has(def: ColumnDef<TRow>): boolean;
+    /** Drop the cache entry for `def`. No-op when not present. */
+    delete(def: ColumnDef<TRow>): void;
+    /** Drop every cached value. */
+    clear(): void;
+    /**
+     * Return a snapshot copy of the cache for debug / inspection use.
+     * Consumers cannot mutate the live store through the returned map.
+     */
+    snapshot(): ReadonlyMap<string, unknown>;
+}

package/dist/Components/Table/Types/Context/QueryValuesState.svelte.js

@@ -0,0 +1,62 @@
+import { SvelteMap } from 'svelte/reactivity';
+/**
+ * Sub-context owning the typeahead-echo cache for QuerySelect-backed
+ * filter inputs. Each value here is the last option the user selected
+ * for a column whose filter renders a remote `QuerySelect` — kept so
+ * the chip's label survives a reactive re-render even when the
+ * server-side filter representation in `ColumnFiltersState` is just a
+ * primitive id.
+ *
+ * Why a sub-context (rather than the legacy
+ * `dataRepo.__queryValues: Map<string, unknown>`):
+ *
+ *   - Forces every read and write to flow through methods keyed on the
+ *     `ColumnDef`, so the `def.id` keying contract is checked at the
+ *     call site instead of accidentally diverging (the most recent
+ *     "select snaps back to placeholder" regressions were caused by
+ *     a write keyed by header label vs a read keyed by `def.id`).
+ *   - Lives alongside the other Phase 6 sub-contexts on
+ *     `TableContext`, keeping the data repo focused on data-fetch
+ *     concerns rather than UI-state echo.
+ *   - Backed by a `SvelteMap` so reads inside `$derived` / `$effect`
+ *     blocks re-evaluate when a write lands.
+ */
+export class QueryValuesState {
+    _values = new SvelteMap();
+    /**
+     * Return the cached typeahead echo for `def`, or `undefined` if none
+     * was stored. The generic `V` lets a caller with a typed
+     * `ColumnDef<TRow, V>` narrow the result; defaults to `unknown` for
+     * untyped consumers.
+     */
+    get(def) {
+        return this._values.get(def.id);
+    }
+    /**
+     * Cache the supplied value under `def.id`. Pass `null` to record an
+     * explicit "user cleared the selection" state (still considered
+     * present by `has`); use `delete` to forget the column entirely.
+     */
+    set(def, value) {
+        this._values.set(def.id, value);
+    }
+    /** True when the column has any cached value (including an explicit `null`). */
+    has(def) {
+        return this._values.has(def.id);
+    }
+    /** Drop the cache entry for `def`. No-op when not present. */
+    delete(def) {
+        this._values.delete(def.id);
+    }
+    /** Drop every cached value. */
+    clear() {
+        this._values.clear();
+    }
+    /**
+     * Return a snapshot copy of the cache for debug / inspection use.
+     * Consumers cannot mutate the live store through the returned map.
+     */
+    snapshot() {
+        return new Map(this._values);
+    }
+}

package/dist/Components/Table/Types/Context/SelectionState.svelte.d.ts

@@ -48,24 +48,18 @@ export interface SelectionStateDeps<T extends object, RowIdType extends Primitiv
     getDebug: () => boolean;
 }
 /**
- * Phase 6.5 god-object decomposition - sub-context that owns every
- * selection + highlighting + key-cache concern previously held directly
- * on `TableContext`:
+ * Sub-context owning every selection + highlighting + key-cache
+ * concern:
  *
- * - `selectedItems` (the `SvelteMap<RowIdType, T>` of currently
- *   selected rows, keyed by extractor id);
- * - `invalidValues` (the parallel `SvelteMap` of rows currently
- *   failing their per-cell validation);
- * - `highlightedItems` (the visual-highlight `SvelteMap`, used for
- *   the copy-to-clipboard "highlighted rows" flow);
- * - `_keyCache` (a `WeakMap<T, RowIdType>` that memoises the
- *   `selectionExtractor` result for each row reference;
- *   `handleItemMutation` clears the entry when the parent's
- *   `onEditCell` callback may have mutated the id field in place);
+ * - `selectedItems` / `invalidValues` / `highlightedItems`
+ *   (`SvelteMap<RowIdType, T>` slots keyed by extractor id);
+ * - `_keyCache` (`WeakMap<T, RowIdType>` memoising the
+ *   `selectionExtractor` result per row reference;
+ *   `handleItemMutation` clears the entry when `onEditCell` may have
+ *   mutated the id field in place);
  * - the pending-flush buffer (`_pendingSelectionChanges`) and its
- *   debounced flush - preserves SvelteMap per-key reactivity and
- *   avoids the per-toggle reactive cascade caught during Phase-5
- *   Group 2;
+ *   debounced flush - preserves SvelteMap per-key reactivity and avoids
+ *   a per-toggle reactive cascade;
  * - `toggleSelected` / `setSelected` / `resetSelectedItems` /
  *   `setSelectionMap` (consumer-facing writers);
  * - `selectionContains` / `addInvalidValue` / `removeInvalidValue`;
@@ -75,19 +69,14 @@ export interface SelectionStateDeps<T extends object, RowIdType extends Primitiv
  *   `onHighlightAll` / `allHighlighted` / `hasHighlightedItems`;
  * - `cachedKey(item)` (sync/async key memoisation);
  * - `handleItemMutation` (the key-cache + selection-rebind half of
- *   the pre-extraction `onEditCell`; the user-supplied edit callback
- *   stays on `TableContext`).
+ *   `onEditCell`; the user-supplied edit callback lives on
+ *   `TableContext`).
  *
- * Effect lifecycle: the parent owns every `$effect`. The two effects
- * that previously read these state slots (the post-pagination rebind
- * and the `_allHighlighted` derivation) continue to live on
- * `TableContext`, but they now call into this sub-context through
- * `updateSelectedItems()` / `setAllHighlighted(...)` /
- * `computeAllHighlightedInRange(...)` rather than mutating the state
- * slots directly.
- *
- * `TableContext` retains delegating getters / setters / methods for
- * every legacy surface so existing consumers need no migration.
+ * Effect lifecycle: the parent owns every `$effect`. Effects that read
+ * these state slots (the post-pagination rebind, the `_allHighlighted`
+ * derivation) live on `TableContext` and call into this sub-context
+ * through `updateSelectedItems()` / `setAllHighlighted(...)` /
+ * `computeAllHighlightedInRange(...)`.
  */
 export declare class SelectionState<T extends object, RowIdType extends Primitive> {
     private readonly _deps;

package/dist/Components/Table/Types/Context/SelectionState.svelte.js

@@ -3,24 +3,18 @@ import { SvelteMap } from 'svelte/reactivity';
 import { asyncForEach, devCatch } from '../../../../Helpers/Helpers.svelte.js';
 import { RowSelectionDef } from '../Columns/Definitions/RowSelection/RowSelectionDef.svelte.js';
 /**
- * Phase 6.5 god-object decomposition - sub-context that owns every
- * selection + highlighting + key-cache concern previously held directly
- * on `TableContext`:
+ * Sub-context owning every selection + highlighting + key-cache
+ * concern:
  *
- * - `selectedItems` (the `SvelteMap<RowIdType, T>` of currently
- *   selected rows, keyed by extractor id);
- * - `invalidValues` (the parallel `SvelteMap` of rows currently
- *   failing their per-cell validation);
- * - `highlightedItems` (the visual-highlight `SvelteMap`, used for
- *   the copy-to-clipboard "highlighted rows" flow);
- * - `_keyCache` (a `WeakMap<T, RowIdType>` that memoises the
- *   `selectionExtractor` result for each row reference;
- *   `handleItemMutation` clears the entry when the parent's
- *   `onEditCell` callback may have mutated the id field in place);
+ * - `selectedItems` / `invalidValues` / `highlightedItems`
+ *   (`SvelteMap<RowIdType, T>` slots keyed by extractor id);
+ * - `_keyCache` (`WeakMap<T, RowIdType>` memoising the
+ *   `selectionExtractor` result per row reference;
+ *   `handleItemMutation` clears the entry when `onEditCell` may have
+ *   mutated the id field in place);
  * - the pending-flush buffer (`_pendingSelectionChanges`) and its
- *   debounced flush - preserves SvelteMap per-key reactivity and
- *   avoids the per-toggle reactive cascade caught during Phase-5
- *   Group 2;
+ *   debounced flush - preserves SvelteMap per-key reactivity and avoids
+ *   a per-toggle reactive cascade;
  * - `toggleSelected` / `setSelected` / `resetSelectedItems` /
  *   `setSelectionMap` (consumer-facing writers);
  * - `selectionContains` / `addInvalidValue` / `removeInvalidValue`;
@@ -30,19 +24,14 @@ import { RowSelectionDef } from '../Columns/Definitions/RowSelection/RowSelectio
  *   `onHighlightAll` / `allHighlighted` / `hasHighlightedItems`;
  * - `cachedKey(item)` (sync/async key memoisation);
  * - `handleItemMutation` (the key-cache + selection-rebind half of
- *   the pre-extraction `onEditCell`; the user-supplied edit callback
- *   stays on `TableContext`).
+ *   `onEditCell`; the user-supplied edit callback lives on
+ *   `TableContext`).
  *
- * Effect lifecycle: the parent owns every `$effect`. The two effects
- * that previously read these state slots (the post-pagination rebind
- * and the `_allHighlighted` derivation) continue to live on
- * `TableContext`, but they now call into this sub-context through
- * `updateSelectedItems()` / `setAllHighlighted(...)` /
- * `computeAllHighlightedInRange(...)` rather than mutating the state
- * slots directly.
- *
- * `TableContext` retains delegating getters / setters / methods for
- * every legacy surface so existing consumers need no migration.
+ * Effect lifecycle: the parent owns every `$effect`. Effects that read
+ * these state slots (the post-pagination rebind, the `_allHighlighted`
+ * derivation) live on `TableContext` and call into this sub-context
+ * through `updateSelectedItems()` / `setAllHighlighted(...)` /
+ * `computeAllHighlightedInRange(...)`.
  */
 export class SelectionState {
     _deps;

package/dist/Components/Table/Types/Context/SortingState.svelte.d.ts

@@ -2,31 +2,24 @@ import type { ColumnDef } from '../Columns/Definitions/ColumnDef.svelte.js';
 import { PaginationType } from '../Pagination/PaginationType.js';
 import type { SortingState as SortingStateArray } from '../DataRepository/SortingState.js';
 /**
- * Comparator factory for any column whose stored row values implement the
- * `<` / `>` operators natively (strings, numbers, Dates). Used by
- * `DisplayDef`, `TextInputDef`, `NumberInputDef`, `DateInputDef`, and
- * `SelectDef`. The desc flag is captured at builder time so the inner
- * comparator pays no extra branching per comparison.
- *
- * Lifted out of `TableContext.svelte.ts` during Phase 6.1 god-object
- * decomposition; the closure shape and return values are unchanged.
+ * Comparator factory for any column whose stored row values implement
+ * `<` / `>` natively (strings, numbers, Dates). Used by `DisplayDef`,
+ * `TextInputDef`, `NumberInputDef`, `DateInputDef`, and `SelectDef`.
+ * The desc flag is captured at builder time so the inner comparator
+ * pays no extra branching per comparison.
  */
 export declare function comparableSortingFn<T>(id: keyof T, desc: boolean): (a: T, b: T) => -1 | 0 | 1;
 /**
  * Comparator factory for `CheckboxDef` columns. Boolean-coercion compares
  * truthy-vs-falsy so undefined / null / 0 collapse to "unchecked".
- *
- * Lifted from `TableContext.svelte.ts` during Phase 6.1.
  */
 export declare function checkboxSortingFn<T>(id: keyof T, desc: boolean): (a: T, b: T) => -1 | 0 | 1;
 /**
  * Comparator factory for `ProgressBarDef` columns. The stored value is a
- * `[min, max]` tuple and the comparison is performed on `min / max` (the
- * fractional completion). Zero-`max` and undefined endpoints sort to the
- * bottom in ascending order (and to the top in descending order) so empty
- * progress bars cluster together.
- *
- * Lifted from `TableContext.svelte.ts` during Phase 6.1.
+ * `[min, max]` tuple; comparison is performed on `min / max` (fractional
+ * completion). Zero-`max` and undefined endpoints sort to the bottom in
+ * ascending order (and to the top in descending order) so empty progress
+ * bars cluster together.
  */
 export declare function progressSortingFn<T>(id: keyof T, desc: boolean): (a: T, b: T) => -1 | 0 | 1;
 /**
@@ -52,16 +45,10 @@ export interface SortingStateDeps<T extends object> {
     getDebug: () => boolean;
 }
 /**
- * Phase 6.1 god-object decomposition - sub-context that owns the
- * sort-related derived chain (`sortedData`), the per-`ColumnDef`
- * comparator dispatch (`getSortingFn`), and the comparator-hoist
- * optimisation that lifts the `instanceof` cascade out of the
- * `.sort()` callback.
- *
- * `TableContext` retains delegating getters / methods for backwards
- * compatibility; future consumers can read `tableContext._sorting`
- * directly once the migration is complete (see
- * `src/stories/Concepts/TableContext-decomposition.mdx`).
+ * Sub-context owning the sort-related derived chain (`sortedData`),
+ * the per-`ColumnDef` comparator dispatch (`getSortingFn`), and the
+ * comparator-hoist optimisation that lifts the `instanceof` cascade
+ * out of the `.sort()` callback.
  */
 export declare class SortingState<T extends object> {
     private readonly _deps;
@@ -99,9 +86,8 @@ export declare class SortingState<T extends object> {
      *
      * Performance: the per-column `instanceof` cascade inside
      * `getSortingFn` is paid O(columns) times per re-sort instead of
-     * O(n log n) - the comparator array is materialised once before the
-     * `.sort()` callback. Lifted from `TableContext.sortedData` in
-     * Phase-5 Group 2 (workorder P0); preserved verbatim here.
+     * O(n log n); the comparator array is materialised once before the
+     * `.sort()` callback runs.
      *
      * Abort semantics: when `filteredData` or `sortingState` changes
      * mid-sort the previous controller is aborted and the in-flight

package/dist/Components/Table/Types/Context/SortingState.svelte.js

@@ -8,14 +8,11 @@ import { DisplayDef } from '../Columns/Definitions/Display/DisplayDef.svelte.js'
 import { ProgressBarDef } from '../Columns/Definitions/Display/ProgressBarDef.svelte.js';
 import { PaginationType } from '../Pagination/PaginationType.js';
 /**
- * Comparator factory for any column whose stored row values implement the
- * `<` / `>` operators natively (strings, numbers, Dates). Used by
- * `DisplayDef`, `TextInputDef`, `NumberInputDef`, `DateInputDef`, and
- * `SelectDef`. The desc flag is captured at builder time so the inner
- * comparator pays no extra branching per comparison.
- *
- * Lifted out of `TableContext.svelte.ts` during Phase 6.1 god-object
- * decomposition; the closure shape and return values are unchanged.
+ * Comparator factory for any column whose stored row values implement
+ * `<` / `>` natively (strings, numbers, Dates). Used by `DisplayDef`,
+ * `TextInputDef`, `NumberInputDef`, `DateInputDef`, and `SelectDef`.
+ * The desc flag is captured at builder time so the inner comparator
+ * pays no extra branching per comparison.
  */
 export function comparableSortingFn(id, desc) {
     return desc
@@ -53,8 +50,6 @@ export function comparableSortingFn(id, desc) {
 /**
  * Comparator factory for `CheckboxDef` columns. Boolean-coercion compares
  * truthy-vs-falsy so undefined / null / 0 collapse to "unchecked".
- *
- * Lifted from `TableContext.svelte.ts` during Phase 6.1.
  */
 export function checkboxSortingFn(id, desc) {
     return desc
@@ -79,12 +74,10 @@ export function checkboxSortingFn(id, desc) {
 }
 /**
  * Comparator factory for `ProgressBarDef` columns. The stored value is a
- * `[min, max]` tuple and the comparison is performed on `min / max` (the
- * fractional completion). Zero-`max` and undefined endpoints sort to the
- * bottom in ascending order (and to the top in descending order) so empty
- * progress bars cluster together.
- *
- * Lifted from `TableContext.svelte.ts` during Phase 6.1.
+ * `[min, max]` tuple; comparison is performed on `min / max` (fractional
+ * completion). Zero-`max` and undefined endpoints sort to the bottom in
+ * ascending order (and to the top in descending order) so empty progress
+ * bars cluster together.
  */
 export function progressSortingFn(id, desc) {
     return desc
@@ -138,16 +131,10 @@ export function progressSortingFn(id, desc) {
         };
 }
 /**
- * Phase 6.1 god-object decomposition - sub-context that owns the
- * sort-related derived chain (`sortedData`), the per-`ColumnDef`
- * comparator dispatch (`getSortingFn`), and the comparator-hoist
- * optimisation that lifts the `instanceof` cascade out of the
- * `.sort()` callback.
- *
- * `TableContext` retains delegating getters / methods for backwards
- * compatibility; future consumers can read `tableContext._sorting`
- * directly once the migration is complete (see
- * `src/stories/Concepts/TableContext-decomposition.mdx`).
+ * Sub-context owning the sort-related derived chain (`sortedData`),
+ * the per-`ColumnDef` comparator dispatch (`getSortingFn`), and the
+ * comparator-hoist optimisation that lifts the `instanceof` cascade
+ * out of the `.sort()` callback.
  */
 export class SortingState {
     _deps;
@@ -214,9 +201,8 @@ export class SortingState {
      *
      * Performance: the per-column `instanceof` cascade inside
      * `getSortingFn` is paid O(columns) times per re-sort instead of
-     * O(n log n) - the comparator array is materialised once before the
-     * `.sort()` callback. Lifted from `TableContext.sortedData` in
-     * Phase-5 Group 2 (workorder P0); preserved verbatim here.
+     * O(n log n); the comparator array is materialised once before the
+     * `.sort()` callback runs.
      *
      * Abort semantics: when `filteredData` or `sortingState` changes
      * mid-sort the previous controller is aborted and the in-flight
@@ -239,8 +225,8 @@ export class SortingState {
             }
             const dataToSort = filteredData.concat();
             // Hoist comparators out of the .sort() callback so the
-            // per-column instanceof cascade inside getSortingFn is paid
-            // O(columns) times instead of O(n log n) (workorder P0).
+            // per-column instanceof cascade in getSortingFn is paid
+            // O(columns) times instead of O(n log n).
             const sortingFns = [];
             for (let i = 0; i < sortingArray.length; i++) {
                 const { id, desc } = sortingArray[i];