@lavalogic/scoria 0.37.55 → 0.38.0

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

@@ -1,25 +1,8 @@
 import { dev } from '$app/environment';
 import { readJSON, readVersionedJSON, writeJSON } from '../../../../Helpers/Storage.js';
 import { isJSONTableLayout, TABLE_LAYOUT_SCHEMA_VERSION, } from '../Columns/JSONTableLayout.js';
-/**
- * Conservative typeguard for the persisted preset list. Storage is
- * same-origin-writable so only the array shape can be trusted;
- * downstream `reassignDefsToPresets` performs deeper checks and drops
- * presets that fail. Asserts the outer envelope plus the bare minimum
- * per entry: a string `name` and an array `columnDefs`.
- */
-export function isJSONColumnDefSetArray(raw) {
-    if (!Array.isArray(raw)) {
-        return false;
-    }
-    return raw.every((entry) => {
-        if (typeof entry !== 'object' || entry === null) {
-            return false;
-        }
-        const candidate = entry;
-        return typeof candidate.name === 'string' && Array.isArray(candidate.columnDefs);
-    });
-}
+import { isJSONActiveView, TABLE_ACTIVE_VIEW_SCHEMA_VERSION, } from '../Persistence/JSONActiveView.js';
+import { isJSONTableFilter, TABLE_FILTER_SCHEMA_VERSION, } from '../Persistence/JSONTableFilter.js';
 /**
  * Typeguard for the persisted user-level table settings blob. Every
  * field is optional, but every present field must be boolean; anything
@@ -38,34 +21,22 @@ export function isSavedTableSettings(raw) {
         optionalBoolean('copyWithHeaders') &&
         optionalBoolean('commaSeparatedCopy'));
 }
-/**
- * Typeguard for a non-empty string. Used for the persisted selected
- * preset name slot.
- */
-export function isNonEmptyString(raw) {
-    return typeof raw === 'string' && raw.length > 0;
-}
 /**
  * Sub-context owning every persistence / preferences concern:
  *
- * - `_columnPresets` (persisted preset list `$state`);
- * - `_selectedPreset` (currently-active preset `$state`);
  * - `userIdSegment` (sanitised user-id segment used in storage keys;
  *   `$derived` over `getUserId()`);
- * - `saveColumnPreset(name)` (snapshot the live layout, persist the
- *   list, mark the new preset as selected);
- * - `setSelectedPreset(preset)` (apply the preset to the live layout
- *   and persist the selected name);
- * - `loadPresets()` / `loadSelectedPresetName()` /
- *   `loadSavedSettings()` (boot-time hydration helpers; the parent
- *   owns the orchestration because it depends on
- *   `setupDefaultColumnDefs` running first);
- * - `clearPresetsAndSelection()` (drop both persisted slots);
- * - `persistSettings(settings)` (write the per-table TableSettings
- *   blob);
- * - schema-validation typeguards (`isJSONColumnDefSetArray`,
- *   `isSavedTableSettings`, `isNonEmptyString`) - exported alongside
- *   the class.
+ * - `loadSavedSettings()` / `persistSettings()` (the per-table
+ *   TableSettings blob: compact, alternate rows, etc.);
+ * - `loadLayout()` / `persistLayout()` / `clearLayout()` (the
+ *   auto-saved live-layout working copy);
+ * - `loadActiveView()` / `persistActiveView()` / `clearActiveView()`
+ *   (the DB-backed view selection envelope);
+ * - the filter counterparts (`loadFilter` / `persistFilter` /
+ *   `clearFilter`, `loadActiveFilterView` / `persistActiveFilterView` /
+ *   `clearActiveFilterView`);
+ * - schema-validation typeguards (`isSavedTableSettings`) - exported
+ *   alongside the class.
  *
  * Every `localStorage` access is funnelled through this sub-context so
  * the `scoria-table:<user>:<tableName>:<suffix>` namespace convention
@@ -73,15 +44,11 @@ export function isNonEmptyString(raw) {
  */
 export class PreferencesState {
     _deps;
-    _columnPresets = $state([]);
-    //FIXME why is this allowed to be undefined? Retained as
-    // `undefined`-capable for backwards source compatibility.
-    _selectedPreset = $state();
     /**
      * Sanitised segment of the persisted-storage key path. Resolves to
      * `getUserId() ?? 'anon'` so different users on a shared browser
-     * cannot read each other's column presets, and so anonymous
-     * sessions still have a stable namespace.
+     * cannot read each other's persisted layout / filter state, and so
+     * anonymous sessions still have a stable namespace.
      *
      * The `$derived.by` form is required here (over plain
      * `$derived(expr)`) because class-field initialisers run BEFORE
@@ -98,77 +65,19 @@ export class PreferencesState {
         this._deps = deps;
     }
     /**
-     * The current list of saved column presets. Setter is private to
-     * the sub-context; the parent writes through `setPresets` during
-     * the boot-time hydration flow.
-     */
-    get columnPresets() {
-        return this._columnPresets;
-    }
-    /**
-     * Writer for `columnPresets`. Public so the parent boot flow can
-     * publish the hydrated list; not part of the consumer-facing
-     * surface (consumer-facing writes go through `saveColumnPreset`).
-     */
-    setPresets(v) {
-        this._columnPresets = v;
-    }
-    /**
-     * The currently-active preset (the one whose name is persisted in
-     * the `selected-preset-name` slot). Setter is public so the parent
-     * boot flow can publish the resolved preset; the consumer-facing
-     * writer is `setSelectedPreset` below (which also persists the
-     * name).
-     */
-    get selectedPreset() {
-        return this._selectedPreset;
-    }
-    set selectedPreset(v) {
-        this._selectedPreset = v;
-    }
-    /**
-     * Build the canonical `scoria-table:<user>:<tableName>:<suffix>`
-     * storage key. Centralised so every persisted-state slot reaches
-     * for the same namespacing convention; the `<user>` segment is
-     * `getUserId() ?? 'anon'` (see `userIdSegment`).
-     */
-    storageKey(suffix) {
-        return `scoria-table:${this.userIdSegment}:${this._deps.getTableName()}:${suffix}`;
-    }
-    /**
-     * Boot-time hydration helper. Reads the persisted preset list from
-     * `localStorage`, validates it against `isJSONColumnDefSetArray`,
-     * and returns the parsed array (or an empty array on every failure
-     * path). The parent runs this once `setupDefaultColumnDefs` has
-     * completed so the live `columnDefs` can be compared against the
-     * persisted snapshot.
+     * Build the canonical `scoria-table:<user>:<scope>:<suffix>` storage
+     * key. Centralised so every persisted-state slot reaches for the same
+     * namespacing convention; the `<user>` segment is `getUserId() ??
+     * 'anon'` (see `userIdSegment`).
      *
-     * `localStorage` access is gated by the parent's `browser` check;
-     * this method assumes the caller already verified the environment.
+     * The `<scope>` segment is the host-supplied `datatableUuid` when one
+     * is present, falling back to the table `name`. Preferring the UUID
+     * keeps two tables that share a `name` option from colliding on the
+     * same localStorage slots.
      */
-    loadPresets() {
-        return readJSON(localStorage, this.storageKey('presets'), isJSONColumnDefSetArray, []);
-    }
-    /**
-     * Boot-time hydration helper. Reads the persisted selected-preset
-     * name. Returns `null` for missing / empty / storage-error slots
-     * so the parent can fall back to the first preset (or the default).
-     * Emits a dev-only warning on `getItem` failure.
-     */
-    loadSelectedPresetName() {
-        let savedPresetName = null;
-        try {
-            savedPresetName = localStorage.getItem(this.storageKey('selected-preset-name'));
-        }
-        catch (e) {
-            if (dev) {
-                console.warn('selected-preset-name read failed:', e);
-            }
-        }
-        if (!isNonEmptyString(savedPresetName)) {
-            return null;
-        }
-        return savedPresetName;
+    storageKey(suffix) {
+        const scope = this._deps.getDatatableUuid() ?? this._deps.getTableName();
+        return `scoria-table:${this.userIdSegment}:${scope}:${suffix}`;
     }
     /**
      * Boot-time hydration helper. Reads the persisted per-table
@@ -184,15 +93,6 @@ export class PreferencesState {
         }
         return saved;
     }
-    /**
-     * Drop the persisted presets and selected-preset-name slots. Used
-     * by the parent's boot flow when the saved snapshot disagrees with
-     * the live column-def shape (schema drift or column-set change).
-     */
-    clearPresetsAndSelection() {
-        localStorage.removeItem(this.storageKey('presets'));
-        localStorage.removeItem(this.storageKey('selected-preset-name'));
-    }
     /**
      * Boot-time hydration helper. Reads the auto-saved live-layout
      * snapshot (column order / visibility / pinning / sizing the user
@@ -241,98 +141,151 @@ export class PreferencesState {
         }
     }
     /**
-     * Persist the selected-preset name as plain text (no JSON
-     * envelope - the slot is a single string by design).
+     * Boot-time hydration helper. Reads the persisted active-view
+     * envelope (which saved view, if any, the live working copy belongs
+     * to, plus its dirty flag). Returns `null` for a missing slot, a
+     * schema-version mismatch, or a value that fails validation, so the
+     * parent can fall back to the Default view.
+     *
+     * `localStorage` access is gated by the parent's `browser` check;
+     * this method assumes the caller already verified the environment.
      */
-    persistSelectedPresetName(name) {
-        localStorage.setItem(this.storageKey('selected-preset-name'), name);
+    loadActiveView() {
+        // Reference-equality sentinel: `readVersionedJSON` demands a
+        // fallback of the value type, so a distinct object instance is
+        // used to distinguish "no usable slot" from a real snapshot.
+        const fallback = {
+            active: { kind: 'default' },
+            dirty: false,
+        };
+        const saved = readVersionedJSON(localStorage, this.storageKey('active-view'), TABLE_ACTIVE_VIEW_SCHEMA_VERSION, isJSONActiveView, fallback);
+        return saved === fallback ? null : saved;
     }
     /**
-     * Persist the per-table settings blob (`isCompact`,
-     * `singleClickEditing`, etc.) as JSON.
+     * Persist the active-view envelope. Written by the parent (debounced,
+     * alongside the working-copy layout) on every layout change, wrapped
+     * in a versioned envelope so a future schema bump drops stale
+     * snapshots cleanly. Storage failures are swallowed inside
+     * `writeJSON`.
      */
-    persistSettings(settings) {
-        localStorage.setItem(this.storageKey('settings'), JSON.stringify(settings));
+    persistActiveView(v) {
+        writeJSON(localStorage, this.storageKey('active-view'), v, TABLE_ACTIVE_VIEW_SCHEMA_VERSION);
     }
     /**
-     * Persist the full preset list as JSON. Each preset's
-     * `columnPinningState` (Map-based) is flattened into entry arrays
-     * because Map does not survive `JSON.stringify`; the reader (via
-     * `loadPresets` -> `reassignDefsToPresets`) rehydrates it through
-     * `adaptJSONPinningState`.
+     * Drop the persisted active-view envelope. Called when table state is
+     * explicitly reset; the next mount falls back to the Default view.
      */
-    persistPresets(presets) {
-        const jsonFriendly = presets.map((preset) => {
-            return {
-                ...preset,
-                columnDefs: preset.columnDefs.map((it) => {
-                    return { ...it.toJSON(), header: it.header.toString() };
-                }),
-                columnPinningState: {
-                    left: [...(preset.columnPinningState.left?.entries() ?? [])],
-                    right: [...(preset.columnPinningState.right?.entries() ?? [])],
-                },
-            };
-        });
-        localStorage.setItem(this.storageKey('presets'), JSON.stringify(jsonFriendly));
+    clearActiveView() {
+        try {
+            localStorage.removeItem(this.storageKey('active-view'));
+        }
+        catch (e) {
+            if (dev) {
+                console.warn('table active-view slot clear failed:', e);
+            }
+        }
     }
     /**
-     * Apply a saved column preset to the live table layout and persist
-     * the selection by name:
-     *
-     * 1. Replace `columnDefs`, `columnVisibility`, `columnPinning`.
-     * 2. Forward the preset's `sortingState` to the data-repository
-     *    updater (no-op when the repo has no `updateSorting` hook).
-     * 3. Update `selectedPreset`.
-     * 4. Persist the preset name to `selected-preset-name`.
+     * Boot-time hydration helper. Reads the auto-saved live-filter
+     * snapshot (the per-column filter values and modes the user built up
+     * in the quick-filter row / advanced filter panel without saving a
+     * named view). Returns `null` for a missing slot, a schema-version
+     * mismatch, or a value that fails validation, so the parent can fall
+     * back to the empty filter state.
      *
-     * Bound as a class property so callers (notably the toolbar
-     * dropdown) can pass the reference around without binding `this`.
+     * The filter counterpart of `loadLayout`. `localStorage` access is
+     * gated by the parent's `browser` check; this method assumes the
+     * caller already verified the environment.
      */
-    setSelectedPreset = (preset) => {
-        if (this._deps.getDebug()) {
-            console.log('setting selected preset:', preset);
-        }
-        this._deps.setColumnDefs(preset.columnDefs);
-        this._deps.applySortingState(preset.sortingState);
-        this._deps.setColumnVisibility(preset.visibilityState);
-        this._deps.setColumnPinning(preset.columnPinningState);
-        this._selectedPreset = preset;
-        this.persistSelectedPresetName(preset.name);
-    };
+    loadFilter() {
+        // Reference-equality sentinel: `readVersionedJSON` demands a
+        // fallback of the value type, so a distinct object instance is
+        // used to distinguish "no usable slot" from a real snapshot.
+        const fallback = {
+            filters: [],
+            modes: {},
+        };
+        const saved = readVersionedJSON(localStorage, this.storageKey('filter'), TABLE_FILTER_SCHEMA_VERSION, isJSONTableFilter, fallback);
+        return saved === fallback ? null : saved;
+    }
     /**
-     * Snapshot the current column layout into a new preset, replacing
-     * any existing preset whose name matches case-insensitively, and
-     * persist the full preset list to `localStorage`. Marks the new
-     * preset as selected (which also persists its name). No-op when
-     * `name` is empty.
+     * Persist the live-filter snapshot. Written by the parent (debounced)
+     * on every filter value / mode change, wrapped in a versioned
+     * envelope so a future schema bump drops stale snapshots cleanly.
+     * Storage failures are swallowed inside `writeJSON`. The filter
+     * counterpart of `persistLayout`.
      */
-    saveColumnPreset = (name) => {
-        if (!name) {
-            return;
+    persistFilter(filter) {
+        writeJSON(localStorage, this.storageKey('filter'), filter, TABLE_FILTER_SCHEMA_VERSION);
+    }
+    /**
+     * Drop the persisted live-filter snapshot. Called when the snapshot
+     * no longer matches the table's column set (schema drift) or when
+     * table state is explicitly reset. The filter counterpart of
+     * `clearLayout`.
+     */
+    clearFilter() {
+        try {
+            localStorage.removeItem(this.storageKey('filter'));
         }
-        const visibilityState = this._deps.getColumnVisibility();
-        const columnPinningState = this._deps.getColumnPinning();
-        const columnDefs = this._deps.getColumnDefs();
-        const sortingState = this._deps.getSortingArray() ?? [];
-        const newPreset = {
-            columnDefs,
-            name,
-            visibilityState,
-            columnPinningState,
-            sortingState,
+        catch (e) {
+            if (dev) {
+                console.warn('table filter slot clear failed:', e);
+            }
+        }
+    }
+    /**
+     * Boot-time hydration helper. Reads the persisted *filter*
+     * active-view envelope (which saved filter view, if any, the live
+     * filter working copy belongs to, plus its dirty flag). Returns
+     * `null` for a missing slot, a schema-version mismatch, or a value
+     * that fails validation, so the parent can fall back to the Default
+     * filter view. The filter counterpart of `loadActiveView`.
+     *
+     * `localStorage` access is gated by the parent's `browser` check;
+     * this method assumes the caller already verified the environment.
+     */
+    loadActiveFilterView() {
+        // Reference-equality sentinel: `readVersionedJSON` demands a
+        // fallback of the value type, so a distinct object instance is
+        // used to distinguish "no usable slot" from a real snapshot.
+        const fallback = {
+            active: { kind: 'default' },
+            dirty: false,
         };
-        const lowercasePresetname = name.toLocaleLowerCase();
-        const indexToReplace = this._columnPresets.findIndex((oldPreset) => oldPreset.name.toLocaleLowerCase() === lowercasePresetname);
-        const newPresets = this._columnPresets.concat();
-        if (indexToReplace > -1) {
-            newPresets[indexToReplace] = newPreset;
+        const saved = readVersionedJSON(localStorage, this.storageKey('active-filter-view'), TABLE_ACTIVE_VIEW_SCHEMA_VERSION, isJSONActiveView, fallback);
+        return saved === fallback ? null : saved;
+    }
+    /**
+     * Persist the *filter* active-view envelope. Written by the parent
+     * (debounced, alongside the working-copy filter) on every filter
+     * change, wrapped in a versioned envelope so a future schema bump
+     * drops stale snapshots cleanly. Storage failures are swallowed
+     * inside `writeJSON`. The filter counterpart of `persistActiveView`.
+     */
+    persistActiveFilterView(v) {
+        writeJSON(localStorage, this.storageKey('active-filter-view'), v, TABLE_ACTIVE_VIEW_SCHEMA_VERSION);
+    }
+    /**
+     * Drop the persisted *filter* active-view envelope. Called when table
+     * state is explicitly reset; the next mount falls back to the Default
+     * filter view. The filter counterpart of `clearActiveView`.
+     */
+    clearActiveFilterView() {
+        try {
+            localStorage.removeItem(this.storageKey('active-filter-view'));
         }
-        else {
-            newPresets.push(newPreset);
+        catch (e) {
+            if (dev) {
+                console.warn('table active-filter-view slot clear failed:', e);
+            }
         }
-        this._columnPresets = newPresets;
-        this.persistPresets(newPresets);
-        this.setSelectedPreset(newPreset);
-    };
+    }
+    /**
+     * Persist the per-table settings blob (`isCompact`,
+     * `singleClickEditing`, etc.) as JSON.
+     */
+    persistSettings(settings) {
+        localStorage.setItem(this.storageKey('settings'), JSON.stringify(settings));
+    }
 }