@lavalogic/scoria 0.37.44 → 0.37.45

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

@@ -0,0 +1,98 @@
+import type { ColumnDef } from '../Columns/Definitions/ColumnDef.svelte.js';
+import type { CellCoordinates } from '../Coordinates/CellCoordinates.js';
+import type { VisualColumnIndex } from '../Coordinates/ColumnIndices.js';
+import type { Primitive } from './TableInitOptions.js';
+/**
+ * Shape of the parent context's read surface that `ClipboardState` needs.
+ * Every entry is a thunk so the sub-context never holds a parent reference
+ * and the reactive graph keeps its `$derived` shape.
+ */
+export interface ClipboardStateDeps<T extends object, RowIdType extends Primitive> {
+    getColumnDefs: () => ReadonlyArray<ColumnDef<T>>;
+    /** Same shape as `VisibilityState`; the deps interface keeps the
+     *  structural form so the sub-context doesn't depend on the type alias. */
+    getColumnVisibility: () => Record<string, boolean | undefined>;
+    getHighlightedItems: () => ReadonlyMap<RowIdType, T>;
+    getSelectedItems: () => ReadonlyMap<RowIdType, T>;
+    getSortedData: () => ReadonlyArray<T>;
+    getCurrentPageData: () => ReadonlyArray<T>;
+    getPaginationRowModel: () => {
+        rows: ReadonlyArray<{
+            visibleIndex: number;
+            original: T;
+            originalIndex: number;
+        }>;
+    };
+    getVisualColumns: () => ReadonlyArray<ColumnDef<T>>;
+    getFocusStart: () => CellCoordinates | null | undefined;
+    getFocusEnd: () => CellCoordinates | null | undefined;
+    cachedKey: (item: T) => RowIdType | Promise<RowIdType>;
+    columnVisualIndex: (id: string) => VisualColumnIndex;
+    /** Master gate from `TableInitOptions.allowCopy`. */
+    getAllowCopy: () => boolean;
+    /** Called by the persistence setters after a successful write so the
+     *  parent flushes the user-settings blob to localStorage. */
+    persistSettings: () => void;
+}
+/**
+ * Sub-context owning the copy-to-clipboard machinery: the two user-tunable
+ * preference flags (`copyWithHeaders`, `commaSeparatedCopy`), the
+ * `Promise`-returning serialisers for the highlighted-rows and focus-range
+ * payloads, and the `_performRowCopy` writer that funnels everything through
+ * `escapeForSpreadsheet` / `encapsulate` before reaching `navigator.clipboard`.
+ *
+ * Why a sub-context (rather than methods on `TableContext`):
+ *
+ *   - All the load-bearing rules live in one file — header gating,
+ *     separator selection, formula-injection neutralisation, select-option
+ *     label resolution. The grouping matches the user mental model.
+ *   - `TableContext.svelte.ts` is the long-standing god-object; pulling
+ *     clipboard out shrinks the parent by ~250 lines.
+ *   - The two preference flags persist via the parent's existing
+ *     `TableSettings` payload, so they live here behind the same
+ *     `persistSettings` thunk the other prefs already use.
+ */
+export declare class ClipboardState<T extends object, RowIdType extends Primitive> {
+    private readonly _deps;
+    /** Whether copy-to-clipboard prepends a TSV / CSV header row. */
+    private _copyWithHeaders;
+    /** When true the separator is comma (CSV); otherwise tab (TSV). */
+    private _commaSeparatedCopy;
+    constructor(deps: ClipboardStateDeps<T, RowIdType>);
+    get copyWithHeaders(): boolean;
+    set copyWithHeaders(v: boolean);
+    get commaSeparatedCopy(): boolean;
+    set commaSeparatedCopy(v: boolean);
+    /** Toggles whether copy-to-clipboard prepends a header row and persists. */
+    readonly setCopyWithHeaders: (value: boolean) => void;
+    /** Toggles CSV vs TSV copy-to-clipboard separator and persists. */
+    readonly setCommaSeparatedCopy: (value: boolean) => void;
+    /** Copies the highlighted rows to the OS clipboard as TSV / CSV. */
+    readonly copyHighlightedRowsToClipboard: () => Promise<void>;
+    /** Copies the currently focused cell range to the OS clipboard. */
+    readonly copyDataToClipboard: () => Promise<void>;
+    /**
+     * Predicate determining whether a column contributes a text value to
+     * the clipboard payload. Hidden columns and structural / custom kinds
+     * are excluded; row-selection survives because it's serialised below.
+     */
+    private columnDefReturnsTextValue;
+    private getHighlightedRowData;
+    private getFocusElementData;
+    /**
+     * Walk `rows` × `columns` and produce the inner 2D string buffer used
+     * by `_performRowCopy`. Factored out so the highlighted-rows and
+     * focus-range serialisers share their cell-reading logic verbatim
+     * (the two paths diverged historically only in how they picked which
+     * rows / which columns to include).
+     */
+    private _readCellsFromRows;
+    /**
+     * Final serialisation step. Resolves `SelectDef` option labels for any
+     * affected select columns, picks the configured separator, encapsulates
+     * each cell, and writes the final string to the OS clipboard. Single-cell
+     * copies bypass TSV wrapping but still pass through
+     * `escapeForSpreadsheet` so a pasted formula payload can't execute.
+     */
+    private _performRowCopy;
+}

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

@@ -0,0 +1,290 @@
+import { dev } from '$app/environment';
+import { devCatch } from '../../../../Helpers/Helpers.svelte.js';
+import { encapsulate, escapeForSpreadsheet } from '../../clipboardEscape.js';
+import { ColumnType } from '../Columns/ColumnType.js';
+import { SelectDef } from '../Columns/Definitions/Accessors/SelectDef.svelte.js';
+import { RowSelectionDef } from '../Columns/Definitions/RowSelection/RowSelectionDef.svelte.js';
+/**
+ * Column kinds whose cell value isn't a meaningful text payload and so
+ * should be skipped when serialising a row to the clipboard. Row-selection
+ * is handled explicitly (it serialises as "true" / "false") and is therefore
+ * NOT in this set.
+ */
+const uncopyableColumns = new Set([
+    ColumnType.Expand,
+    ColumnType.Actions,
+    ColumnType.FilterOnly,
+    ColumnType.Custom,
+]);
+/**
+ * Sub-context owning the copy-to-clipboard machinery: the two user-tunable
+ * preference flags (`copyWithHeaders`, `commaSeparatedCopy`), the
+ * `Promise`-returning serialisers for the highlighted-rows and focus-range
+ * payloads, and the `_performRowCopy` writer that funnels everything through
+ * `escapeForSpreadsheet` / `encapsulate` before reaching `navigator.clipboard`.
+ *
+ * Why a sub-context (rather than methods on `TableContext`):
+ *
+ *   - All the load-bearing rules live in one file — header gating,
+ *     separator selection, formula-injection neutralisation, select-option
+ *     label resolution. The grouping matches the user mental model.
+ *   - `TableContext.svelte.ts` is the long-standing god-object; pulling
+ *     clipboard out shrinks the parent by ~250 lines.
+ *   - The two preference flags persist via the parent's existing
+ *     `TableSettings` payload, so they live here behind the same
+ *     `persistSettings` thunk the other prefs already use.
+ */
+export class ClipboardState {
+    _deps;
+    /** Whether copy-to-clipboard prepends a TSV / CSV header row. */
+    _copyWithHeaders = $state(true);
+    /** When true the separator is comma (CSV); otherwise tab (TSV). */
+    _commaSeparatedCopy = $state(false);
+    constructor(deps) {
+        this._deps = deps;
+    }
+    // -------- preference flags -----------------------------------------
+    get copyWithHeaders() {
+        return this._copyWithHeaders;
+    }
+    set copyWithHeaders(v) {
+        this._copyWithHeaders = v;
+    }
+    get commaSeparatedCopy() {
+        return this._commaSeparatedCopy;
+    }
+    set commaSeparatedCopy(v) {
+        this._commaSeparatedCopy = v;
+    }
+    /** Toggles whether copy-to-clipboard prepends a header row and persists. */
+    setCopyWithHeaders = (value) => {
+        if (this._deps.getAllowCopy()) {
+            this._copyWithHeaders = value;
+            this._deps.persistSettings();
+        }
+    };
+    /** Toggles CSV vs TSV copy-to-clipboard separator and persists. */
+    setCommaSeparatedCopy = (value) => {
+        if (this._deps.getAllowCopy()) {
+            this._commaSeparatedCopy = value;
+            this._deps.persistSettings();
+        }
+    };
+    // -------- public clipboard writers ---------------------------------
+    /** Copies the highlighted rows to the OS clipboard as TSV / CSV. */
+    copyHighlightedRowsToClipboard = async () => {
+        // `navigator.clipboard` is undefined in non-HTTPS contexts. The lint
+        // rule below is a false-positive in that environment.
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (!navigator.clipboard) {
+            alert('cannot copy in an insecure connection');
+            return;
+        }
+        return this._performRowCopy(await this.getHighlightedRowData());
+    };
+    /** Copies the currently focused cell range to the OS clipboard. */
+    copyDataToClipboard = async () => {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (!navigator.clipboard) {
+            alert('cannot copy in an insecure connection');
+            return;
+        }
+        return this._performRowCopy(await this.getFocusElementData());
+    };
+    // -------- internals ------------------------------------------------
+    /**
+     * Predicate determining whether a column contributes a text value to
+     * the clipboard payload. Hidden columns and structural / custom kinds
+     * are excluded; row-selection survives because it's serialised below.
+     */
+    columnDefReturnsTextValue = (it) => {
+        return ('index' in it &&
+            this._deps.getColumnVisibility()[it.id] !== false &&
+            !uncopyableColumns.has(it.columnType));
+    };
+    async getHighlightedRowData() {
+        const affectedColumns = this._deps
+            .getColumnDefs()
+            .filter((d) => this.columnDefReturnsTextValue(d));
+        // eslint-disable-next-line svelte/prefer-svelte-reactivity
+        const indices = new Map();
+        const selectedRows = [...this._deps.getHighlightedItems().values()];
+        const sortedData = this._deps.getSortedData();
+        for (const item of selectedRows) {
+            const rowIndex = sortedData.indexOf(item);
+            if (rowIndex === -1) {
+                if (dev) {
+                    console.warn('row index for highlighted row data not found');
+                }
+                continue;
+            }
+            indices.set(item, rowIndex);
+        }
+        selectedRows.sort((left, right) => (indices.get(left) ?? -1) - (indices.get(right) ?? -1));
+        const selectedCells = await this._readCellsFromRows(selectedRows, affectedColumns, sortedData);
+        return {
+            items: selectedRows,
+            indicesByItem: indices,
+            focusedElementData: selectedCells,
+            affectedColumns,
+        };
+    }
+    async getFocusElementData() {
+        const focusStart = this._deps.getFocusStart();
+        const focusEnd = this._deps.getFocusEnd();
+        if (!focusStart || !focusEnd) {
+            return {
+                items: [],
+                // eslint-disable-next-line svelte/prefer-svelte-reactivity
+                indicesByItem: new Map(),
+                focusedElementData: [],
+                affectedColumns: [],
+            };
+        }
+        const { row: startRowIndexId } = focusStart;
+        const { row: endRowIndexId } = focusEnd;
+        const model = this._deps.getPaginationRowModel();
+        const startRowIndex = model.rows.findIndex((row) => row.visibleIndex === startRowIndexId);
+        const endRowIndex = model.rows.findIndex((row) => row.visibleIndex === endRowIndexId);
+        if (!this._deps.getCurrentPageData().length || startRowIndex === -1 || endRowIndex === -1) {
+            throw new Error(`copy was missing one of the two indices. First: ${startRowIndex.toString()}, second: ${endRowIndex.toString()}`);
+        }
+        const minRowIndex = Math.min(startRowIndex, endRowIndex);
+        const maxRowIndex = Math.max(startRowIndex, endRowIndex);
+        const startVisualIndex = this._deps.columnVisualIndex(focusStart.id);
+        const endVisualIndex = this._deps.columnVisualIndex(focusEnd.id);
+        const minVisualIndex = Math.min(startVisualIndex, endVisualIndex);
+        const maxVisualIndex = Math.max(startVisualIndex, endVisualIndex);
+        const affectedColumns = this._deps
+            .getVisualColumns()
+            .slice(minVisualIndex, maxVisualIndex + 1)
+            .filter((it) => this.columnDefReturnsTextValue(it));
+        const selectedRows = [];
+        // eslint-disable-next-line svelte/prefer-svelte-reactivity
+        const indices = new Map();
+        for (let i = minRowIndex; i <= maxRowIndex; i++) {
+            const row = model.rows[i];
+            selectedRows.push(row.original);
+            indices.set(row.original, row.originalIndex);
+        }
+        const sortedData = this._deps.getSortedData();
+        const selectedCells = await this._readCellsFromRows(selectedRows, affectedColumns, sortedData);
+        return {
+            items: selectedRows,
+            indicesByItem: indices,
+            focusedElementData: selectedCells,
+            affectedColumns,
+        };
+    }
+    /**
+     * Walk `rows` × `columns` and produce the inner 2D string buffer used
+     * by `_performRowCopy`. Factored out so the highlighted-rows and
+     * focus-range serialisers share their cell-reading logic verbatim
+     * (the two paths diverged historically only in how they picked which
+     * rows / which columns to include).
+     */
+    async _readCellsFromRows(rows, columns, sortedData) {
+        const cells = [];
+        for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+            const item = rows[rowIndex];
+            const rawKey = this._deps.cachedKey(item);
+            const key = rawKey instanceof Promise ? await rawKey : rawKey;
+            cells[rowIndex] = [];
+            const targetRow = cells[rowIndex];
+            for (let colIndex = 0; colIndex < columns.length; colIndex++) {
+                const columnDef = columns[colIndex];
+                if (columnDef instanceof RowSelectionDef) {
+                    targetRow.push(this._deps.getSelectedItems().has(key) ? 'true' : 'false');
+                    continue;
+                }
+                if (uncopyableColumns.has(columnDef.columnType)) {
+                    continue;
+                }
+                const x = (await columnDef.getDisplayValue?.(item, sortedData.lastIndexOf(item))) ||
+                    ('accessorFn' in columnDef &&
+                        (await columnDef.accessorFn?.(item, sortedData.indexOf(item))));
+                if (x && typeof x === 'string') {
+                    targetRow.push(x);
+                    continue;
+                }
+                if (x && Array.isArray(x) && typeof x[0] === 'string') {
+                    targetRow.push(x.join(', '));
+                    continue;
+                }
+                const toCopy = columnDef.id && columnDef.id in item
+                    ? item[columnDef.id]
+                    : null;
+                const y = toCopy && typeof toCopy === 'object' && toCopy instanceof Date
+                    ? toCopy.toLocaleDateString()
+                    : (toCopy?.toString() ?? '');
+                targetRow.push(y);
+            }
+        }
+        return cells;
+    }
+    /**
+     * Final serialisation step. Resolves `SelectDef` option labels for any
+     * affected select columns, picks the configured separator, encapsulates
+     * each cell, and writes the final string to the OS clipboard. Single-cell
+     * copies bypass TSV wrapping but still pass through
+     * `escapeForSpreadsheet` so a pasted formula payload can't execute.
+     */
+    _performRowCopy = async ({ items, indicesByItem, focusedElementData, affectedColumns, }) => {
+        const focusedColumnIds = affectedColumns.map((it) => encapsulate(typeof it.header === 'string' ? it.header : it.id));
+        const value = await (async () => {
+            // Resolve per-row option sets for SelectDef columns; iterates
+            // in reverse so the last value wins when a row maps to
+            // multiple SelectOption sources via `getSpecificOptions`.
+            // eslint-disable-next-line svelte/prefer-svelte-reactivity
+            const selectColumns = new Map();
+            for (let i = affectedColumns.length - 1; i > -1; i--) {
+                const columnDef = affectedColumns[i];
+                if (columnDef instanceof SelectDef) {
+                    const item = items[i];
+                    const defOptions = indicesByItem.get(item);
+                    selectColumns.set(i, await (defOptions
+                        ? (columnDef.getSpecificOptions?.(item, defOptions) ?? columnDef.getOptions())
+                        : columnDef.getOptions()));
+                }
+            }
+            const separator = this._commaSeparatedCopy ? ',' : '\t';
+            const shouldCopyHeaders = this._copyWithHeaders &&
+                (focusedElementData.length !== 1 || focusedElementData[0].length !== 1);
+            if (focusedElementData.length === 1 && focusedElementData[0].length === 1) {
+                // Single-cell copy: skip TSV/CSV wrapping but still escape
+                // formula-injection prefixes ('=', '+', '-', '@', '\t', '\r').
+                if (selectColumns.has(0)) {
+                    const columnOptions = selectColumns.get(0);
+                    const v = columnOptions?.find((it) => it.value === focusedElementData[0][0])?.label ??
+                        focusedElementData[0][0]?.toString() ??
+                        '';
+                    return escapeForSpreadsheet(v);
+                }
+                const v = focusedElementData[0][0]?.toString().trim() ?? '';
+                return escapeForSpreadsheet(v);
+            }
+            return `${shouldCopyHeaders ? `${focusedColumnIds.join(separator)}\n` : ''}${focusedElementData
+                .map((it) => it
+                .map((toCopy, i) => {
+                if (toCopy instanceof Date) {
+                    return toCopy.toLocaleDateString();
+                }
+                if (selectColumns.has(i)) {
+                    const columnOptions = selectColumns.get(i);
+                    if (dev && !columnOptions) {
+                        console.warn(`could not find column with index ${i.toString()}`);
+                    }
+                    const v = columnOptions?.find((it) => it.value === toCopy)?.label ??
+                        toCopy?.toString() ??
+                        '';
+                    return encapsulate(v);
+                }
+                const v = toCopy?.toString().trim() ?? '';
+                return encapsulate(v);
+            })
+                .join(separator))
+                .join('\n')}`;
+        })();
+        navigator.clipboard.writeText(value).catch(devCatch);
+    };
+}

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

@@ -17,36 +17,18 @@ export interface ColumnLayoutStateDeps {
     getDebug: () => boolean;
 }
 /**
- * Phase 6.3 god-object decomposition - sub-context that owns every
- * column-layout concern previously held directly on `TableContext`:
+ * Sub-context owning column-layout state:
  *
- * - `columnDefs` (the ordered array of column definitions),
- * - `columnDefsById` (`$derived` id->def lookup map),
+ * - `columnDefs` (ordered column definitions);
+ * - `columnDefsById` (`$derived` id->def lookup);
  * - `columnPinning` / `columnSizing` / `columnVisibility` (the three
- *   per-column maps the consumer mutates through the public setters),
- * - `_visualColumns` and `_visualColumnIndexById` (the cached visual
- *   display order plus the paired `Map<id, VisualColumnIndex>` that
- *   makes `columnVisualIndex` an O(1) lookup - Phase-5 Group 1
- *   workorder P0),
- * - `columnVisualIndex(id)` (the public lookup),
- * - `setColumnPinning(updater)` (delegating writer that respects the
+ *   per-column maps mutated through public setters);
+ * - `_visualColumns` and `_visualColumnIndexById` (cached visual order
+ *   plus the paired `Map<id, VisualColumnIndex>` so
+ *   `columnVisualIndex` is O(1));
+ * - `columnVisualIndex(id)` (public lookup);
+ * - `setColumnPinning(updater)` (writer that respects the
  *   `allowColumnReordering` master gate).
- *
- * `TableContext` retains delegating getters / setters / methods for
- * every legacy surface (`columnDefs`, `columnPinning`, `columnSizing`,
- * `columnVisibility`, `columnDefsById`, `columnVisualIndex`,
- * `_visualColumns`, `setColumnPinning`, etc.) so existing consumers
- * need no migration. Future consumers can read `tableContext._columnLayout`
- * directly once the migration is complete (see
- * `src/stories/Concepts/TableContext-decomposition.mdx`).
- *
- * The `focusStartVisualColumn` / `focusEndVisualColumn` getters straddle
- * column-layout and focus; the column-layout-side calculation
- * (`columnVisualIndex` lookup) lives here, but the focus-side state
- * (`focusStart`, `focusEnd`) stays on `TableContext` until the Phase 6.6
- * `FocusState` extraction. The parent's `focusStartVisualColumn` getter
- * therefore reads `this.focusStart?.id` and calls
- * `this._columnLayout.columnVisualIndex(...)`.
  */
 export declare class ColumnLayoutState<T extends object> {
     private readonly _deps;
@@ -114,17 +96,10 @@ export declare class ColumnLayoutState<T extends object> {
      * pinned-right, preserving memory order within each section.
      * Excludes columns whose visibility is explicitly `false`.
      *
-     * Cached as a `$derived` array (rebuilt only when `columnDefs`,
-     * `columnVisibility`, or `columnPinning` change). Phase-5 Group 1
-     * workorder P0 introduced this caching layer to avoid the
-     * O(columns) filter cost on every focus-arrow keystroke; see the
-     * paired `_visualColumnIndexById` below for the O(1) reverse-lookup
-     * map.
-     *
-     * Made `public` (with the underscore prefix preserved) so the
-     * parent `TableContext` can delegate its legacy `_visualColumns`
-     * field. Future consumers should read
-     * `tableContext._columnLayout.visualColumns` directly.
+     * Cached as a `$derived` (rebuilds only when `columnDefs`,
+     * `columnVisibility`, or `columnPinning` change) to avoid the
+     * O(columns) filter cost on every focus-arrow keystroke; see
+     * `_visualColumnIndexById` for the O(1) reverse-lookup map.
      */
     readonly visualColumns: Array<ColumnDef<T>>;
     /**
@@ -142,10 +117,9 @@ export declare class ColumnLayoutState<T extends object> {
      */
     columnVisualIndex(id: string): VisualColumnIndex;
     /**
-     * Applies an updater to the column-pinning state (left / right
+     * Apply an updater to the column-pinning state (left / right
      * pins). No-op when column reordering is disabled at the table
-     * level. Mirrors the pre-extraction
-     * `TableContext.setColumnPinning` writer verbatim.
+     * level.
      */
     readonly setColumnPinning: (updater: (state: ColumnPinningState) => ColumnPinningState) => void;
     /**
@@ -163,11 +137,9 @@ export declare class ColumnLayoutState<T extends object> {
      */
     readonly updateDefsBasedOnPinning: () => Array<ColumnDef<T>>;
     /**
-     * Re-publishes the column-pinning map so its left / right entries
+     * Re-publish the column-pinning map so its left / right entries
      * are keyed by the current `columnDefs` ordering. Used by the
-     * parent's drag-drop and `moveColumnTo` flows after a reorder
-     * operation; preserves the pre-extraction
-     * `TableContext._setNewPinningState` contract verbatim.
+     * parent's drag-drop and `moveColumnTo` flows after a reorder.
      */
     readonly setNewPinningState: () => void;
 }

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

@@ -1,34 +1,16 @@
 /**
- * Phase 6.3 god-object decomposition - sub-context that owns every
- * column-layout concern previously held directly on `TableContext`:
+ * Sub-context owning column-layout state:
  *
- * - `columnDefs` (the ordered array of column definitions),
- * - `columnDefsById` (`$derived` id->def lookup map),
+ * - `columnDefs` (ordered column definitions);
+ * - `columnDefsById` (`$derived` id->def lookup);
  * - `columnPinning` / `columnSizing` / `columnVisibility` (the three
- *   per-column maps the consumer mutates through the public setters),
- * - `_visualColumns` and `_visualColumnIndexById` (the cached visual
- *   display order plus the paired `Map<id, VisualColumnIndex>` that
- *   makes `columnVisualIndex` an O(1) lookup - Phase-5 Group 1
- *   workorder P0),
- * - `columnVisualIndex(id)` (the public lookup),
- * - `setColumnPinning(updater)` (delegating writer that respects the
+ *   per-column maps mutated through public setters);
+ * - `_visualColumns` and `_visualColumnIndexById` (cached visual order
+ *   plus the paired `Map<id, VisualColumnIndex>` so
+ *   `columnVisualIndex` is O(1));
+ * - `columnVisualIndex(id)` (public lookup);
+ * - `setColumnPinning(updater)` (writer that respects the
  *   `allowColumnReordering` master gate).
- *
- * `TableContext` retains delegating getters / setters / methods for
- * every legacy surface (`columnDefs`, `columnPinning`, `columnSizing`,
- * `columnVisibility`, `columnDefsById`, `columnVisualIndex`,
- * `_visualColumns`, `setColumnPinning`, etc.) so existing consumers
- * need no migration. Future consumers can read `tableContext._columnLayout`
- * directly once the migration is complete (see
- * `src/stories/Concepts/TableContext-decomposition.mdx`).
- *
- * The `focusStartVisualColumn` / `focusEndVisualColumn` getters straddle
- * column-layout and focus; the column-layout-side calculation
- * (`columnVisualIndex` lookup) lives here, but the focus-side state
- * (`focusStart`, `focusEnd`) stays on `TableContext` until the Phase 6.6
- * `FocusState` extraction. The parent's `focusStartVisualColumn` getter
- * therefore reads `this.focusStart?.id` and calls
- * `this._columnLayout.columnVisualIndex(...)`.
  */
 export class ColumnLayoutState {
     _deps;
@@ -116,17 +98,10 @@ export class ColumnLayoutState {
      * pinned-right, preserving memory order within each section.
      * Excludes columns whose visibility is explicitly `false`.
      *
-     * Cached as a `$derived` array (rebuilt only when `columnDefs`,
-     * `columnVisibility`, or `columnPinning` change). Phase-5 Group 1
-     * workorder P0 introduced this caching layer to avoid the
-     * O(columns) filter cost on every focus-arrow keystroke; see the
-     * paired `_visualColumnIndexById` below for the O(1) reverse-lookup
-     * map.
-     *
-     * Made `public` (with the underscore prefix preserved) so the
-     * parent `TableContext` can delegate its legacy `_visualColumns`
-     * field. Future consumers should read
-     * `tableContext._columnLayout.visualColumns` directly.
+     * Cached as a `$derived` (rebuilds only when `columnDefs`,
+     * `columnVisibility`, or `columnPinning` change) to avoid the
+     * O(columns) filter cost on every focus-arrow keystroke; see
+     * `_visualColumnIndexById` for the O(1) reverse-lookup map.
      */
     visualColumns = $derived.by(() => {
         const visibility = this._columnVisibility;
@@ -164,10 +139,9 @@ export class ColumnLayoutState {
         return this.visualColumnIndexById.get(id) ?? -1;
     }
     /**
-     * Applies an updater to the column-pinning state (left / right
+     * Apply an updater to the column-pinning state (left / right
      * pins). No-op when column reordering is disabled at the table
-     * level. Mirrors the pre-extraction
-     * `TableContext.setColumnPinning` writer verbatim.
+     * level.
      */
     setColumnPinning = (updater) => {
         if (!this._deps.getAllowColumnReordering()) {
@@ -216,11 +190,9 @@ export class ColumnLayoutState {
         return allDefs;
     };
     /**
-     * Re-publishes the column-pinning map so its left / right entries
+     * Re-publish the column-pinning map so its left / right entries
      * are keyed by the current `columnDefs` ordering. Used by the
-     * parent's drag-drop and `moveColumnTo` flows after a reorder
-     * operation; preserves the pre-extraction
-     * `TableContext._setNewPinningState` contract verbatim.
+     * parent's drag-drop and `moveColumnTo` flows after a reorder.
      */
     setNewPinningState = () => {
         this._columnPinning = {

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

@@ -40,19 +40,10 @@ export interface FilteringStateDeps<T extends object> {
     getDebug: () => boolean;
 }
 /**
- * Phase 6.2 god-object decomposition - sub-context that owns the
- * filtering-related state, the relayed per-type `FilterFn` derived
- * values, the `filteredData` $derived chain, the user-facing toggle
- * flags (`showQuickFiltering`, `showSelectedOnly`), the remote-filter
- * slot, and the `updateFilters` `OnChangeFn` slot.
- *
- * `TableContext` retains delegating getters / setters for every legacy
- * surface (`filteredIndices`, `filteredData`, `showQuickFiltering`,
- * `showSelectedOnly`, `remoteFilters`, `dateFilter`, `numberFilter`,
- * `selectFilter`, `boolFilter`, `stringFilter`, `updateFilters`); future
- * consumers can read `tableContext._filtering` directly once the
- * migration completes (see
- * `src/stories/Concepts/TableContext-decomposition.mdx`).
+ * Sub-context owning filtering-related state: relayed per-type
+ * `FilterFn` derived values, the `filteredData` `$derived` chain, the
+ * user-facing toggle flags (`showQuickFiltering`, `showSelectedOnly`),
+ * the remote-filter slot, and the `updateFilters` `OnChangeFn` slot.
  */
 export declare class FilteringState<T extends object> {
     private readonly _deps;
@@ -87,10 +78,9 @@ export declare class FilteringState<T extends object> {
     setFilteredIndices(indices: ReadonlyArray<number>): void;
     /**
      * Whether the quick-filter row is currently visible. The setter
-     * enforces the `allowQuickFiltering` gate (a master init option):
-     * if quick filtering is disabled at the table level, the setter is
-     * a no-op except for the debug log. Mirrors the pre-extraction
-     * `TableContext.showQuickFiltering` setter verbatim.
+     * enforces the `allowQuickFiltering` master gate: when quick
+     * filtering is disabled at the table level, the setter is a no-op
+     * (with a debug log).
      */
     get showQuickFiltering(): boolean;
     set showQuickFiltering(v: boolean);
@@ -158,9 +148,8 @@ export declare class FilteringState<T extends object> {
      *
      * Reactivity note: `selectedItems` is intentionally NOT touched
      * outside the `showSelectedOnly` branches. Reading it unconditionally
-     * would invalidate `filteredData` → `sortedData` → `currentPageData`
-     * → the entire row model on every single toggle (regression caught
-     * during Phase-5 Group 2).
+     * would invalidate `filteredData` -> `sortedData` ->
+     * `currentPageData` -> the entire row model on every single toggle.
      */
     readonly filteredData: T[];
 }