@lavalogic/scoria 0.36.0 → 0.37.1

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

@@ -0,0 +1,613 @@
+import { tick } from 'svelte';
+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`:
+ *
+ * - `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);
+ * - 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;
+ * - `toggleSelected` / `setSelected` / `resetSelectedItems` /
+ *   `setSelectionMap` (consumer-facing writers);
+ * - `selectionContains` / `addInvalidValue` / `removeInvalidValue`;
+ * - `selectAllInCurrentPage`, `updateSelectedItems`,
+ *   `allSelectedInCurrentPage`;
+ * - `toggleHighlightedRow` / `resetHighlightedRows` /
+ *   `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`).
+ *
+ * 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.
+ */
+export class SelectionState {
+    _deps;
+    /** Selected rows keyed by id. Map entries are mutated in place so
+     *  the per-key reactivity tracking of `SvelteMap` survives every
+     *  toggle. Replacing the slot with a cloned map would invalidate
+     *  every `.has()` / `.get()` subscriber across all visible rows
+     *  (regression caught during Phase-5 Group 2). */
+    _selectedItems = $state(new SvelteMap());
+    /** Parallel `SvelteMap` of rows currently failing per-cell
+     *  validation. Public-mutable for source compatibility. */
+    _invalidValues = $state(new SvelteMap());
+    /** Visual-highlight `SvelteMap`, distinct from selection. */
+    _highlightedItems = $state(new SvelteMap());
+    /**
+     * Memoises the `selectionExtractor` result for each row reference.
+     * Cleared by `handleItemMutation` immediately before the parent's
+     * `onEditCell` callback may mutate the id field in place.
+     *
+     * `WeakMap` so rows that get garbage-collected do not hold the
+     * cache entry forever; rows replaced by remote-paged refresh see
+     * their entry collected automatically.
+     */
+    _keyCache = new WeakMap();
+    /**
+     * Pending selection changes - buffered and flushed as a single
+     * `SvelteMap` mutation pass to avoid per-toggle reactive cascades.
+     * Values: `null` = pending delete, `T` = pending insert.
+     */
+    // eslint-disable-next-line svelte/prefer-svelte-reactivity
+    _pendingSelectionChanges = new Map();
+    _flushScheduled = false;
+    /** Tracks the async `allSelectedBySelectableMethod` result so the
+     *  `$derived` can return a synchronous value while a promise
+     *  resolves in the background. */
+    _allSelectedAsync = $state(false);
+    /** Last computed value of `_areAllHighlightedInRange` for the
+     *  current page. Mutated by the parent's `$effect` through
+     *  `setAllHighlighted` (the effect lives in `TableContext`
+     *  because it needs the parent's pagination-repo reads). */
+    _allHighlighted = $state(false);
+    /**
+     * @param deps thunks the sub-context reads from the parent.
+     *             Constructor-only - no implicit setup so the parent
+     *             remains in control of effect ownership and lifecycle.
+     */
+    constructor(deps) {
+        this._deps = deps;
+    }
+    // -----------------------------------------------------------------
+    // selectedItems / invalidValues / highlightedItems
+    // -----------------------------------------------------------------
+    /** Currently-selected rows, keyed by `selectionExtractor(item)`. */
+    get selectedItems() {
+        return this._selectedItems;
+    }
+    /** Currently-invalid rows. */
+    get invalidValues() {
+        return this._invalidValues;
+    }
+    set invalidValues(v) {
+        this._invalidValues = v;
+    }
+    /** Currently-highlighted rows. */
+    get highlightedItems() {
+        return this._highlightedItems;
+    }
+    /** `true` iff any row is currently highlighted. */
+    hasHighlightedItems = $derived(this._highlightedItems.size > 0);
+    /**
+     * `true` iff every visible row on the current page is highlighted.
+     * Set by the parent's `$effect` through `setAllHighlighted` (the
+     * effect reads `paginationRepo.pageStartIndex` /
+     * `paginationRepo.pageEndIndexExclusive` and delegates the range
+     * computation to `computeAllHighlightedInRange`).
+     */
+    get allHighlighted() {
+        return this._allHighlighted;
+    }
+    /** Setter for `_allHighlighted` driven by the parent's effect. */
+    setAllHighlighted(v) {
+        this._allHighlighted = v;
+    }
+    // -----------------------------------------------------------------
+    // _cachedKey / handleItemMutation (key-cache half of onEditCell)
+    // -----------------------------------------------------------------
+    /**
+     * Resolves the row identifier through the caller-supplied
+     * extractor, memoising the result in `_keyCache` so subsequent
+     * lookups on the same `T` reference avoid the extractor cost.
+     *
+     * Async extractors are supported: the returned promise is awaited
+     * by every call site through the `instanceof Promise` branch.
+     *
+     * Public so the parent's `originalRowIndices` / `getHighlightedRowData`
+     * flows can reach the cached key without piercing the boundary.
+     */
+    cachedKey(item) {
+        const cached = this._keyCache.get(item);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const raw = this._deps.getSelectionExtractor()(item);
+        if (raw instanceof Promise) {
+            return raw.then((key) => {
+                this._keyCache.set(item, key);
+                return key;
+            });
+        }
+        this._keyCache.set(item, raw);
+        return raw;
+    }
+    /**
+     * Invoked by the parent's `onEditCell`. Splits cleanly:
+     *
+     *   1. Resolves the row's old key (sync or async) and snapshots
+     *      its selection state.
+     *   2. If the row was selected, drops it from the selection map
+     *      so the post-edit insert (step 4) does not duplicate.
+     *   3. Invalidates the key-cache entry for the row reference -
+     *      the callback may mutate the id field in place.
+     *   4. Awaits the supplied callback (the user's
+     *      `TableInitOptions.onEditCell`).
+     *   5. Re-inserts the row under its new extractor result if it
+     *      was previously selected AND `isSelectable` is currently
+     *      true.
+     *
+     * The parent's `onEditCell` becomes a thin wrapper that passes
+     * the user-supplied callback in as the `runUserEditCallback`
+     * thunk.
+     */
+    handleItemMutation = async (item, runUserEditCallback) => {
+        const rawOldKey = this.cachedKey(item);
+        const oldKey = rawOldKey instanceof Promise ? await rawOldKey : rawOldKey;
+        const wasSelected = this._selectedItems.has(oldKey);
+        if (wasSelected) {
+            this._selectedItems.delete(oldKey);
+        }
+        // Invalidate cache - the callback may mutate the item's key
+        // field in place.
+        this._keyCache.delete(item);
+        await runUserEditCallback();
+        if (wasSelected && this._deps.getIsSelectable()) {
+            const rawNewKey = this.cachedKey(item);
+            const newKey = rawNewKey instanceof Promise ? await rawNewKey : rawNewKey;
+            if (newKey) {
+                this._selectedItems.set(newKey, item);
+            }
+        }
+    };
+    // -----------------------------------------------------------------
+    // pending-flush buffer
+    // -----------------------------------------------------------------
+    _flushPendingSelectionChanges() {
+        if (this._pendingSelectionChanges.size === 0) {
+            return;
+        }
+        // Mutate in place to preserve SvelteMap's per-key reactive tracking.
+        // Replacing _selectedItems with a cloned map would invalidate every
+        // .has()/.get() subscriber across all visible rows, not just the
+        // changed keys.
+        for (const [key, item] of this._pendingSelectionChanges) {
+            if (item === null) {
+                this._selectedItems.delete(key);
+            }
+            else {
+                this._selectedItems.set(key, item);
+            }
+        }
+        this._pendingSelectionChanges.clear();
+        this._flushScheduled = false;
+    }
+    _schedulePendingFlush() {
+        if (this._flushScheduled) {
+            return;
+        }
+        this._flushScheduled = true;
+        tick()
+            .then(() => {
+            this._flushPendingSelectionChanges();
+        })
+            .catch(devCatch);
+    }
+    // -----------------------------------------------------------------
+    // selection writers
+    // -----------------------------------------------------------------
+    /** Whether the row's selection key is currently in the selected
+     *  map. Returns `true` unconditionally when the table has no
+     *  selection column (legacy semantics). */
+    selectionContains = (item) => {
+        void item;
+        void this._deps.getIsSelectable();
+        void this._selectedItems.size;
+        if (!this._deps.getIsSelectable()) {
+            return true;
+        }
+        const rawIdentity = this.cachedKey(item);
+        return rawIdentity instanceof Promise
+            ? rawIdentity.then((identity) => this._selectedItems.has(identity))
+            : this._selectedItems.has(rawIdentity);
+    };
+    /** Marks a row as invalid for downstream invalid-rows tracking. */
+    addInvalidValue = (item) => {
+        const raw = this.cachedKey(item);
+        if (raw instanceof Promise) {
+            return raw.then((key) => {
+                this._invalidValues.set(key, item);
+            });
+        }
+        this._invalidValues.set(raw, item);
+    };
+    /** Clears the invalid-state marker for a row. */
+    removeInvalidValue = (item) => {
+        const raw = this.cachedKey(item);
+        if (raw instanceof Promise) {
+            return raw.then((key) => {
+                this._invalidValues.delete(key);
+            });
+        }
+        this._invalidValues.delete(raw);
+    };
+    /**
+     * Toggles the selected state of a row. Both the selected map and
+     * the pending-flush buffer are consulted so a same-microtask
+     * double-toggle reflects the user's last action rather than the
+     * persisted state.
+     */
+    toggleSelected = (item) => {
+        const raw = this.cachedKey(item);
+        if (raw instanceof Promise) {
+            return raw.then((key) => {
+                const pendingValue = this._pendingSelectionChanges.get(key);
+                const isSelected = pendingValue !== undefined ? pendingValue !== null : this._selectedItems.has(key);
+                this._pendingSelectionChanges.set(key, isSelected ? null : item);
+                this._schedulePendingFlush();
+            });
+        }
+        const pendingValue = this._pendingSelectionChanges.get(raw);
+        const isSelected = pendingValue !== undefined ? pendingValue !== null : this._selectedItems.has(raw);
+        this._pendingSelectionChanges.set(raw, isSelected ? null : item);
+        this._schedulePendingFlush();
+    };
+    /** Sets the selected state of a row to the supplied value. */
+    setSelected = (item, selected) => {
+        const raw = this.cachedKey(item);
+        if (raw instanceof Promise) {
+            return raw.then((key) => {
+                this._pendingSelectionChanges.set(key, selected ? item : null);
+                this._schedulePendingFlush();
+            });
+        }
+        this._pendingSelectionChanges.set(raw, selected ? item : null);
+        this._schedulePendingFlush();
+    };
+    /** Replaces the entire selected-items map. */
+    setSelectionMap = (set) => {
+        this._selectedItems = set;
+    };
+    /** Clears every selected row. */
+    resetSelectedItems = () => {
+        this._selectedItems.clear();
+    };
+    // -----------------------------------------------------------------
+    // page-wide selection helpers
+    // -----------------------------------------------------------------
+    /**
+     * Resolve the page-window pair `[start, end)` from the dependency
+     * thunks, applying the `undefined` -> "no pagination" fallback.
+     * Exposed publicly so the parent's `_hasInvalidSelectedItems`
+     * effect can reach the same window without duplicating the
+     * fallback logic.
+     */
+    getPageWindow() {
+        const sortedDataLength = this._deps.getSortedData().length;
+        const pageStartIndex = this._deps.getPageStartIndex() ?? 0;
+        const pageEndIndexRaw = this._deps.getPageEndIndexExclusive();
+        const pageEndIndexExclusive = pageEndIndexRaw === undefined
+            ? sortedDataLength
+            : Math.min(pageEndIndexRaw, sortedDataLength);
+        return { pageStartIndex, pageEndIndexExclusive };
+    }
+    allSelectedBySelectableMethod(pageStartIndex, pageEndIndexExclusive, selectableMethod) {
+        const sortedData = this._deps.getSortedData();
+        const emptyPromise = new Promise(() => undefined);
+        if (selectableMethod) {
+            const pending = [];
+            for (let i = pageStartIndex; i < pageEndIndexExclusive; i++) {
+                const item = sortedData[i];
+                const relIdx = i - pageStartIndex;
+                const raw = this.cachedKey(item);
+                const checkUnselected = (key) => {
+                    const selectable = selectableMethod(item, relIdx);
+                    if (selectable instanceof Promise) {
+                        return selectable.then((s) => s && !this._selectedItems.has(key));
+                    }
+                    return selectable && !this._selectedItems.has(key);
+                };
+                const r = raw instanceof Promise ? raw.then(checkUnselected) : checkUnselected(raw);
+                if (r === true) {
+                    return false;
+                }
+                if (r instanceof Promise) {
+                    pending.push(r);
+                }
+            }
+            if (pending.length === 0) {
+                return true;
+            }
+            return Promise.race([
+                Promise.race(pending.map(async (p) => ((await p) ? false : emptyPromise))),
+                Promise.all(pending).then((results) => {
+                    return !results.some(Boolean);
+                }),
+            ]);
+        }
+        else {
+            const pending = [];
+            for (let i = pageStartIndex; i < pageEndIndexExclusive; i++) {
+                const raw = this.cachedKey(sortedData[i]);
+                if (raw instanceof Promise) {
+                    pending.push(raw.then((key) => !this._selectedItems.has(key)));
+                }
+                else if (!this._selectedItems.has(raw)) {
+                    return false;
+                }
+            }
+            if (pending.length === 0) {
+                return true;
+            }
+            return Promise.race([
+                Promise.race(pending.map(async (p) => ((await p) ? false : emptyPromise))),
+                Promise.all(pending).then((results) => !results.some(Boolean)),
+            ]);
+        }
+    }
+    /**
+     * `true` iff every row on the current page is currently in the
+     * selection map (or covered by the `RowSelectionDef.isSelectable`
+     * gate). The async result is parked in `_allSelectedAsync` so a
+     * synchronous read remains possible.
+     */
+    allSelectedInCurrentPage = $derived.by(() => {
+        void this._deps.getColumnDefs();
+        if (this._selectedItems.size === 0) {
+            return false;
+        }
+        // Subscribe to sortedData + pagination window so the derived
+        // recomputes when the page shifts (mirrors the pre-extraction
+        // `void this.paginationRepo?.pageStartIndex` reads).
+        void this._deps.getSortedData();
+        void this._deps.getPageStartIndex();
+        void this._deps.getPageEndIndexExclusive();
+        const { pageStartIndex, pageEndIndexExclusive } = this.getPageWindow();
+        const selectableMethod = this._deps
+            .getColumnDefs()
+            .find((it) => it instanceof RowSelectionDef)?.isSelectable;
+        const result = this.allSelectedBySelectableMethod(pageStartIndex, pageEndIndexExclusive, selectableMethod);
+        if (result instanceof Promise) {
+            result
+                .then((flag) => {
+                this._allSelectedAsync = flag;
+            })
+                .catch(devCatch);
+            return this._allSelectedAsync;
+        }
+        return result;
+    });
+    /**
+     * Toggles the selection state of every row on the current page.
+     * If every row is already selected, every row is deselected;
+     * otherwise every row that passes the optional `RowSelectionDef`
+     * `isSelectable` guard is added to the selection map.
+     */
+    selectAllInCurrentPage = async () => {
+        void this._deps.getPageStartIndex();
+        const sortedData = this._deps.getSortedData();
+        const { pageStartIndex, pageEndIndexExclusive } = this.getPageWindow();
+        // Mutate in place to preserve SvelteMap per-key reactivity AND
+        // to honour `setSelectionMap()` - if the consumer replaced the
+        // slot wholesale, we mutate THAT map rather than allocating a
+        // new one.
+        const sel = this._selectedItems;
+        const pending = [];
+        if (this.allSelectedInCurrentPage) {
+            for (let i = pageStartIndex; i < pageEndIndexExclusive; i++) {
+                const raw = this.cachedKey(sortedData[i]);
+                if (raw instanceof Promise) {
+                    pending.push(raw.then((key) => {
+                        sel.delete(key);
+                    }));
+                }
+                else {
+                    sel.delete(raw);
+                }
+            }
+        }
+        else {
+            const selectableMethod = this._deps
+                .getColumnDefs()
+                .find((it) => it instanceof RowSelectionDef)?.isSelectable;
+            if (selectableMethod) {
+                for (let i = pageStartIndex; i < pageEndIndexExclusive; i++) {
+                    const item = sortedData[i];
+                    const relIdx = i - pageStartIndex;
+                    const s = selectableMethod(item, relIdx);
+                    const doSet = (ok) => {
+                        if (!ok) {
+                            return;
+                        }
+                        const raw = this.cachedKey(item);
+                        if (raw instanceof Promise) {
+                            return raw.then((key) => {
+                                sel.set(key, item);
+                            });
+                        }
+                        sel.set(raw, item);
+                    };
+                    const r = s instanceof Promise ? s.then(doSet) : doSet(s);
+                    if (r instanceof Promise) {
+                        pending.push(r);
+                    }
+                }
+            }
+            else {
+                for (let i = pageStartIndex; i < pageEndIndexExclusive; i++) {
+                    const item = sortedData[i];
+                    const raw = this.cachedKey(item);
+                    if (raw instanceof Promise) {
+                        pending.push(raw.then((key) => {
+                            sel.set(key, item);
+                        }));
+                    }
+                    else {
+                        sel.set(raw, item);
+                    }
+                }
+            }
+        }
+        if (pending.length > 0) {
+            await Promise.all(pending);
+        }
+    };
+    /**
+     * Rebinds every currently selected key to its row object on the
+     * current page. Called by the post-pagination effect so a paged
+     * remote refresh does not leave the selection map pointing at the
+     * old item references.
+     */
+    updateSelectedItems = async () => {
+        if (this._selectedItems.size === 0) {
+            return;
+        }
+        const sortedData = this._deps.getSortedData();
+        const { pageStartIndex, pageEndIndexExclusive } = this.getPageWindow();
+        // Build key -> item map for the current page (O(page_size) extractions)
+        // eslint-disable-next-line svelte/prefer-svelte-reactivity
+        const pageKeyMap = new Map();
+        const pending = [];
+        for (let i = pageStartIndex; i < pageEndIndexExclusive; i++) {
+            const item = sortedData[i];
+            const raw = this.cachedKey(item);
+            if (raw instanceof Promise) {
+                pending.push(raw.then((key) => {
+                    pageKeyMap.set(key, item);
+                }));
+            }
+            else {
+                pageKeyMap.set(raw, item);
+            }
+        }
+        if (pending.length > 0) {
+            await Promise.all(pending);
+        }
+        // Update only selected items that appear on this page (O(selected_size))
+        for (const key of this._selectedItems.keys()) {
+            const newItem = pageKeyMap.get(key);
+            if (newItem !== undefined) {
+                this._selectedItems.set(key, newItem);
+            }
+        }
+    };
+    // -----------------------------------------------------------------
+    // highlighting
+    // -----------------------------------------------------------------
+    /** Toggles whether a row is highlighted (visually marked, not selected). */
+    toggleHighlightedRow = (item) => {
+        const raw = this.cachedKey(item);
+        if (raw instanceof Promise) {
+            return raw.then((key) => {
+                if (this._highlightedItems.has(key)) {
+                    this._highlightedItems.delete(key);
+                }
+                else {
+                    this._highlightedItems.set(key, item);
+                }
+            });
+        }
+        if (this._highlightedItems.has(raw)) {
+            this._highlightedItems.delete(raw);
+        }
+        else {
+            this._highlightedItems.set(raw, item);
+        }
+    };
+    /** Clears every highlighted row. */
+    resetHighlightedRows = () => {
+        this._highlightedItems.clear();
+    };
+    /**
+     * If every row on the current page is highlighted, clears the
+     * highlight; otherwise highlights every row on the current page.
+     */
+    onHighlightAll = () => {
+        if (this._allHighlighted) {
+            this._highlightedItems.clear();
+            return Promise.resolve();
+        }
+        else {
+            // `asyncForEach` is typed `Array<T>` (not `ReadonlyArray<T>`);
+            // the dependency thunk preserves immutability at the boundary
+            // so the cast is safe at runtime - the function only reads
+            // the array.
+            const items = this._deps.getCurrentPageData();
+            return asyncForEach(items, (item) => {
+                const raw = this.cachedKey(item);
+                if (raw instanceof Promise) {
+                    return raw.then((key) => {
+                        this._highlightedItems.set(key, item);
+                    });
+                }
+                this._highlightedItems.set(raw, item);
+                return;
+            });
+        }
+    };
+    /**
+     * Compute whether every row in `[pageStartIndex, pageEndIndexExclusive)`
+     * is currently highlighted. Called by the parent's `_allHighlighted`
+     * `$effect` so the effect retains its `paginationRepo` reads
+     * directly while the row-walk logic lives here.
+     */
+    computeAllHighlightedInRange(pageStartIndex, pageEndIndexExclusive) {
+        const sortedData = this._deps.getSortedData();
+        for (let index = pageStartIndex; index < pageEndIndexExclusive; index++) {
+            const item = sortedData[index];
+            const raw = this.cachedKey(item);
+            if (raw instanceof Promise) {
+                return raw.then(async (key) => {
+                    if (!this._highlightedItems.has(key)) {
+                        return false;
+                    }
+                    for (let j = index + 1; j < pageEndIndexExclusive; j++) {
+                        const r = this.cachedKey(sortedData[j]);
+                        const k = r instanceof Promise ? await r : r;
+                        if (!this._highlightedItems.has(k)) {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+            }
+            if (!this._highlightedItems.has(raw)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}