@lavalogic/scoria 0.37.56 → 0.38.0

package/dist/Components/Table/Types/Persistence/JSONActiveView.js

@@ -0,0 +1,41 @@
+/**
+ * Schema version for the persisted `JSONActiveView` envelope. Bump when
+ * the shape or field semantics change in a backwards-incompatible way;
+ * `readVersionedJSON` silently drops envelopes written under a different
+ * version.
+ */
+export const TABLE_ACTIVE_VIEW_SCHEMA_VERSION = 1;
+/**
+ * Conservative typeguard for a persisted `JSONActiveView`. localStorage is
+ * same-origin-writable so the decoded value is untrusted; this checks the
+ * envelope shape, the `active` discriminated union, and every field's
+ * primitive type.
+ *
+ * The `id` referenced by a `kind: 'saved'` slot is *not* verified against
+ * the live saved-view list here - `TableContext` reconciles the persisted
+ * ref against the fetched views once they load.
+ */
+export function isJSONActiveView(raw) {
+    if (typeof raw !== 'object' || raw === null) {
+        return false;
+    }
+    const candidate = raw;
+    if (typeof candidate.dirty !== 'boolean') {
+        return false;
+    }
+    return isActiveViewRef(candidate.active);
+}
+/** Validates the `ActiveViewRef` discriminated union. */
+function isActiveViewRef(raw) {
+    if (typeof raw !== 'object' || raw === null) {
+        return false;
+    }
+    const candidate = raw;
+    if (candidate.kind === 'default') {
+        return true;
+    }
+    if (candidate.kind === 'saved') {
+        return typeof candidate.id === 'string' && typeof candidate.name === 'string';
+    }
+    return false;
+}

package/dist/Components/Table/Types/Persistence/JSONTableFilter.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Serialisable snapshot of a table's *filter* state - the per-column
+ * filter values and per-column filter modes a user builds up in the
+ * quick-filter row or advanced filter panel.
+ *
+ * This is the filter counterpart of `JSONTableLayout` (column order /
+ * visibility / pinning / width). It is the JSON body persisted inside a
+ * saved `DatatableView` of `kind: 'filter'`, and is deliberately narrow:
+ * sort order and pagination are *not* part of a saved filter and are
+ * excluded by design.
+ *
+ * Both fields are plain JSON-survivable shapes - `filters` is an array of
+ * `{ id, value }` records and `modes` is a flat string map - because a
+ * `Map` does not survive `JSON.stringify`.
+ */
+export interface JSONTableFilter {
+    /**
+     * Serialised per-column filter values, one entry per filtered column.
+     * `id` is the column id; `value` is the filter value as produced by
+     * the column's filter input and is `unknown` here because each column
+     * defines its own value shape (a later step narrows it per column).
+     */
+    filters: Array<{
+        id: string;
+        value: unknown;
+    }>;
+    /**
+     * Per-column filter mode, as a flat `columnId -> mode` string map.
+     * A `Map` does not survive `JSON.stringify`, so a plain record is
+     * used. The mode strings are an open set (the union of every column
+     * filter-mode enum); they are intentionally not validated against a
+     * fixed list here - a later step drops any mode it no longer knows.
+     */
+    modes: Record<string, string>;
+}
+/**
+ * Schema version for the persisted `JSONTableFilter` envelope. Bump when
+ * the shape or field semantics change in a backwards-incompatible way;
+ * `readVersionedJSON` silently drops envelopes written under a different
+ * version.
+ */
+export declare const TABLE_FILTER_SCHEMA_VERSION = 1;
+/**
+ * Conservative typeguard for a persisted `JSONTableFilter`. A saved
+ * filter can arrive from localStorage (same-origin-writable) or from a
+ * backend, so the decoded value is untrusted; this checks the envelope
+ * shape and every field's primitive type.
+ *
+ * It deliberately does *not* validate the mode strings against a fixed
+ * set - mode literals are an open set and a later step is responsible
+ * for dropping any mode it no longer recognises.
+ */
+export declare function isJSONTableFilter(raw: unknown): raw is JSONTableFilter;

package/dist/Components/Table/Types/Persistence/JSONTableFilter.js

@@ -0,0 +1,42 @@
+/**
+ * Schema version for the persisted `JSONTableFilter` envelope. Bump when
+ * the shape or field semantics change in a backwards-incompatible way;
+ * `readVersionedJSON` silently drops envelopes written under a different
+ * version.
+ */
+export const TABLE_FILTER_SCHEMA_VERSION = 1;
+/**
+ * Conservative typeguard for a persisted `JSONTableFilter`. A saved
+ * filter can arrive from localStorage (same-origin-writable) or from a
+ * backend, so the decoded value is untrusted; this checks the envelope
+ * shape and every field's primitive type.
+ *
+ * It deliberately does *not* validate the mode strings against a fixed
+ * set - mode literals are an open set and a later step is responsible
+ * for dropping any mode it no longer recognises.
+ */
+export function isJSONTableFilter(raw) {
+    if (typeof raw !== 'object' || raw === null) {
+        return false;
+    }
+    const candidate = raw;
+    if (!Array.isArray(candidate.filters) || !candidate.filters.every(isFilterEntry)) {
+        return false;
+    }
+    return isStringRecord(candidate.modes);
+}
+/** Validates one `{ id: string; value: unknown }` filter entry. */
+function isFilterEntry(raw) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        return false;
+    }
+    const candidate = raw;
+    return typeof candidate.id === 'string';
+}
+/** Validates a plain (non-array) object whose values are all strings. */
+function isStringRecord(raw) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        return false;
+    }
+    return Object.values(raw).every((value) => typeof value === 'string');
+}

package/dist/Components/Table/Types/Persistence/RemoteTableLayoutAdapter.d.ts

@@ -0,0 +1,47 @@
+import type { CreateDatatableViewRequest, DatatableView, UpdateDatatableViewRequest } from './DatatableView.js';
+/**
+ * Injected backend adapter for saved datatable layouts and filters.
+ *
+ * scoria stays backend-agnostic: it defines this interface but never
+ * implements it. The host app supplies an implementation (over HTTP, a
+ * local store, a mock, etc.) via the `remoteLayouts` `createTable`
+ * option, and scoria calls it to list / create / update / delete saved
+ * views and to manage subscribers.
+ *
+ * Failure contract: every method is async and *rejects* on failure -
+ * implementations must never return error sentinels (no `null`, no
+ * `{ ok: false }`). The one documented exception is a backend
+ * "not found": `listViews` treats it as an empty list rather than a
+ * rejection.
+ */
+export interface RemoteTableLayoutAdapter {
+    /** All views (layouts AND filters) visible to the current user for one
+     *  datatable: owned + subscribed. The implementer treats a backend
+     *  "not found" as an empty list. */
+    listViews(datatableUuid: string): Promise<ReadonlyArray<DatatableView>>;
+    /**
+     * The *public* views (layouts AND filters) for one datatable that the
+     * current user could subscribe to but does not already own or
+     * subscribe to - i.e. the candidates for the modal's "Subscribe to
+     * Additional..." picker. Implementations should exclude anything
+     * already returned by `listViews` so the two lists never overlap. As
+     * with `listViews`, a backend "not found" is treated as an empty
+     * list rather than a rejection.
+     *
+     * Added in A4a: the Table Configuration modal needs a discovery
+     * surface for subscribable views. The backend's `GET
+     * /datatable-state` already returns `publicLayouts` / `publicFilters`,
+     * so a host can implement this directly.
+     */
+    listPublicViews(datatableUuid: string): Promise<ReadonlyArray<DatatableView>>;
+    /** Persist a brand-new view; returns the server-assigned record. */
+    createView(request: CreateDatatableViewRequest): Promise<DatatableView>;
+    /** Update an existing view's name and/or body. */
+    updateView(request: UpdateDatatableViewRequest): Promise<DatatableView>;
+    /** Delete a view the current user owns. */
+    deleteView(viewId: string): Promise<void>;
+    /** v1 sharing: add the given user as a subscriber. */
+    addSubscriber(viewId: string, userId: string): Promise<void>;
+    /** Remove a subscriber. */
+    removeSubscriber(viewId: string, userId: string): Promise<void>;
+}

package/dist/Components/Table/Types/Persistence/RemoteTableLayoutAdapter.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Public/CreateTableOptions.d.ts

@@ -4,6 +4,7 @@ import type { ColumnFactory } from './ColumnFactory.js';
 import type { ColumnSpec } from './ColumnSpec.js';
 import type { LiteralRowIdKey } from './KeyConstraints.js';
 import type { CustomRemoteFilters } from '../Filtering/CustomRemoteFilters.js';
+import type { RemoteTableLayoutAdapter } from '../Persistence/RemoteTableLayoutAdapter.js';
 import type { RowSource } from './RowSource.js';
 import type { SelectionOptions } from './SelectionOptions.js';
 import type { TableInitialState } from './TableInitialState.js';
@@ -89,6 +90,15 @@ export interface CreateTableOptions<TRow extends object, TRowId extends Primitiv
      *  per-column callback resolves. A per-column callback that throws or
      *  rejects suppresses the corresponding `onAnyEdit`. */
     onAnyEdit?: (event: AnyEditEvent<TRow>) => void | Promise<void>;
+    /** Stable per-table identifier (a hard-coded constant supplied by the
+     *  host app). Identifies which datatable saved views belong to. Omit to
+     *  disable remote views - the table then behaves exactly as before
+     *  (localStorage working copy only). */
+    datatableUuid?: string;
+    /** Injected backend adapter for saved layouts/filters. Omit to disable
+     *  remote views. scoria stays backend-agnostic; the host app supplies
+     *  this. */
+    remoteLayouts?: RemoteTableLayoutAdapter;
     /** Identity for storage namespacing and remote-request authentication.
      *  Defaults to `() => undefined`, which namespaces persisted state under
      *  the literal segment `'anon'`. */

package/dist/Components/Table/Types/Public/TablePersistence.d.ts

@@ -13,9 +13,6 @@ export type TablePersistence = boolean | TablePersistenceObject;
 /** Object form of `TablePersistence`. Use when enabling some layers and
  *  disabling others; the boolean form is the all-or-nothing shortcut. */
 export interface TablePersistenceObject {
-    /** Saved column presets (visibility / pinning / sizing snapshots). Default
-     *  true. */
-    presets?: boolean;
     /** User-controlled table settings (compact mode, alternate row colours,
      *  single-click editing, etc.). Default true. */
     settings?: boolean;
@@ -25,7 +22,7 @@ export interface TablePersistenceObject {
      *  columns). Default true. */
     activeExpand?: boolean;
     /** Custom storage backend. Useful for tests; defaults to `localStorage`
-     *  for presets and settings, `sessionStorage` for active state. */
+     *  for settings, `sessionStorage` for active state. */
     storage?: TableStorageAdapter;
 }
 /** Storage backend hook for tests and custom persistence. Mirrors the subset

package/dist/Components/Table/Types/Public/TableSubApis.d.ts

@@ -126,25 +126,7 @@ export interface FocusApi<TRow extends object> {
      *  flows from `Table<TRow, ...>` into focus callbacks. Never read. */
     readonly _row?: TRow;
 }
-/** Stored preset shape. Mirrors the existing internal `JSONColumnDefSet`. */
-export interface SavedPreset {
-    readonly name: string;
-    readonly savedAt: string;
-    readonly columns: ReadonlyArray<{
-        readonly id: string;
-        readonly visible: boolean;
-        readonly width: number;
-        readonly pinned: 'left' | 'right' | 'none';
-    }>;
-}
 export interface PreferencesApi<TRow extends object> {
-    /** Saved column presets. Reactive. */
-    readonly presets: ReadonlyArray<SavedPreset>;
-    /** Currently-applied preset, or `undefined`. */
-    readonly selectedPreset: SavedPreset | undefined;
-    savePreset(name: string): void;
-    applyPreset(preset: SavedPreset): void;
-    deletePreset(name: string): void;
     /** Live table settings (compact mode, etc). Reading via `.settings.x`
      *  is reactive; writing via the per-field setters below persists. */
     readonly settings: Readonly<TableSettings>;

package/dist/Components/Table/Types/Public/index.d.ts

@@ -15,4 +15,4 @@ export type { SelectionOptions } from './SelectionOptions.js';
 export type { Table } from './Table.js';
 export type { TableInitialState } from './TableInitialState.js';
 export type { TablePersistence, TablePersistenceObject, TableStorageAdapter, } from './TablePersistence.js';
-export type { ClipboardApi, ColumnsApi, FilteringApi, FocusApi, ModalApi, PaginationApi, PreferencesApi, SavedPreset, SelectionApi, SortingApi, } from './TableSubApis.js';
+export type { ClipboardApi, ColumnsApi, FilteringApi, FocusApi, ModalApi, PaginationApi, PreferencesApi, SelectionApi, SortingApi, } from './TableSubApis.js';

package/dist/Components/Table/createTable.svelte.js

@@ -77,6 +77,8 @@ export function createTable(options) {
         toolbar: translateToolbar(options.toolbar),
         displayFooter: options.showFooter,
         onEditCell,
+        datatableUuid: options.datatableUuid,
+        remoteLayouts: options.remoteLayouts,
         debug: options.debug,
     };
     const ctx = TableContext.init(defsWrapper, options.name, repository, initOptions);

package/dist/index.d.ts

@@ -103,11 +103,18 @@ export { type SwitchProps } from './Components/SwitchProps.js';
 export type { TabGroupButtonProps } from './Components/TabGroupButtonProps.js';
 export { default as Table, type TableProps } from './Components/Table/Table.svelte';
 export { createTable, customRows, localRows, remoteRows, } from './Components/Table/createTable.svelte.js';
-export type { ActionsColumnOptions, AnyEditEvent, BaseColumnOptions, BooleanKeyOf, BubbleColumnOptions, CheckboxColumnOptions, ClipboardApi, ColumnFactory as TableColumnFactory, ColumnKind, ColumnSpec, ColumnsApi, CreateTableOptions, CustomRowSource, DateColumnOptions, DateKeyOf, DisplayColumnOptions, DisplayModalProps, ExpandColumnOptions, ExpandInnerTableOptions, FilterOnlyColumnOptions, FilteringApi, FocusApi, LiteralRowIdKey, LocalRowSource, ModalApi, NumberColumnOptions, NumberKeyOf, PaginationApi, PreferencesApi, ProgressColumnOptions, QueryColumnOptions, RemoteRowSource, RowAction, RowFetchRequest, RowFetchResponse, RowSelectionColumnOptions, RowSource, SavedPreset, SelectColumnOptions, SelectionApi, SelectionOptions, SortingApi, StringKeyOf, Table as TableInstance, TableInitialState, TablePersistence, TablePersistenceObject, TableStorageAdapter, TextColumnOptions, ValidityColumnOptions, } from './Components/Table/Types/Public/index.js';
+export type { ActionsColumnOptions, AnyEditEvent, BaseColumnOptions, BooleanKeyOf, BubbleColumnOptions, CheckboxColumnOptions, ClipboardApi, ColumnFactory as TableColumnFactory, ColumnKind, ColumnSpec, ColumnsApi, CreateTableOptions, CustomRowSource, DateColumnOptions, DateKeyOf, DisplayColumnOptions, DisplayModalProps, ExpandColumnOptions, ExpandInnerTableOptions, FilterOnlyColumnOptions, FilteringApi, FocusApi, LiteralRowIdKey, LocalRowSource, ModalApi, NumberColumnOptions, NumberKeyOf, PaginationApi, PreferencesApi, ProgressColumnOptions, QueryColumnOptions, RemoteRowSource, RowAction, RowFetchRequest, RowFetchResponse, RowSelectionColumnOptions, RowSource, SelectColumnOptions, SelectionApi, SelectionOptions, SortingApi, StringKeyOf, Table as TableInstance, TableInitialState, TablePersistence, TablePersistenceObject, TableStorageAdapter, TextColumnOptions, ValidityColumnOptions, } from './Components/Table/Types/Public/index.js';
 export { type CellCoordinates } from './Components/Table/Types/Coordinates/CellCoordinates.js';
 export { type ColumnPinningState } from './Components/Table/Types/Columns/ColumnPinningState.js';
 export { type ColumnSizingState } from './Components/Table/Types/Columns/ColumnSizingState.js';
 export { type VisibilityState } from './Components/Table/Types/Columns/VisibilityState.js';
+export { type JSONTableLayout, TABLE_LAYOUT_SCHEMA_VERSION, isJSONTableLayout, } from './Components/Table/Types/Columns/JSONTableLayout.js';
+export { type JSONTableFilter, TABLE_FILTER_SCHEMA_VERSION, isJSONTableFilter, } from './Components/Table/Types/Persistence/JSONTableFilter.js';
+export { type DatatableViewKind } from './Components/Table/Types/Persistence/DatatableViewKind.js';
+export { type DatatableViewBody } from './Components/Table/Types/Persistence/DatatableViewEnvelope.js';
+export type { CreateDatatableViewRequest, DatatableView, DatatableViewSubscriber, DatatableViewSubscription, UpdateDatatableViewRequest, } from './Components/Table/Types/Persistence/DatatableView.js';
+export { type RemoteTableLayoutAdapter } from './Components/Table/Types/Persistence/RemoteTableLayoutAdapter.js';
+export { type ActiveViewRef, type JSONActiveView, TABLE_ACTIVE_VIEW_SCHEMA_VERSION, isJSONActiveView, } from './Components/Table/Types/Persistence/JSONActiveView.js';
 export { type ValidationFn } from './Components/Table/Types/Columns/Definitions/ValidationFn.js';
 export { type TableSettings } from './Components/Table/Types/Context/TableSettings.js';
 export { type ColumnFilter, type ColumnFiltersState, } from './Components/Table/Types/Filtering/ColumnFiltersState.js';

package/dist/index.js

@@ -86,6 +86,15 @@ export {} from './Components/Table/Types/Coordinates/CellCoordinates.js';
 export {} from './Components/Table/Types/Columns/ColumnPinningState.js';
 export {} from './Components/Table/Types/Columns/ColumnSizingState.js';
 export {} from './Components/Table/Types/Columns/VisibilityState.js';
+export { TABLE_LAYOUT_SCHEMA_VERSION, isJSONTableLayout, } from './Components/Table/Types/Columns/JSONTableLayout.js';
+// ─── Datatable saved views (FPM 403): layout/filter persistence DTOs ───
+// The frozen contract the consuming host app codes its `RemoteTableLayoutAdapter`
+// implementation against. Inert in scoria until later steps wire them.
+export { TABLE_FILTER_SCHEMA_VERSION, isJSONTableFilter, } from './Components/Table/Types/Persistence/JSONTableFilter.js';
+export {} from './Components/Table/Types/Persistence/DatatableViewKind.js';
+export {} from './Components/Table/Types/Persistence/DatatableViewEnvelope.js';
+export {} from './Components/Table/Types/Persistence/RemoteTableLayoutAdapter.js';
+export { TABLE_ACTIVE_VIEW_SCHEMA_VERSION, isJSONActiveView, } from './Components/Table/Types/Persistence/JSONActiveView.js';
 export {} from './Components/Table/Types/Columns/Definitions/ValidationFn.js';
 export {} from './Components/Table/Types/Context/TableSettings.js';
 export {} from './Components/Table/Types/Filtering/ColumnFiltersState.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lavalogic/scoria",
   "description": "Svelte components used for the FloWMS Web Frontend",
-  "version": "0.37.56",
+  "version": "0.38.0",
   "publishConfig": {
     "access": "restricted"
   },

package/dist/Components/Table/Types/Columns/Definitions/ColumnDefSet.d.ts

@@ -1,20 +0,0 @@
-import type { SortingState } from '../../DataRepository/SortingState.js';
-import type { ColumnPinningState } from '../ColumnPinningState.js';
-import type { VisibilityState } from '../VisibilityState.js';
-import type { ColumnDef } from './ColumnDef.svelte.js';
-/**
- * A named runtime preset: a snapshot of the column-defs array plus the
- * sort / visibility / pinning state to apply when the preset is loaded.
- * Used by the column-preset dropdown for save/load.
- *
- * The serialised mirror is `JSONColumnDefSet` (substitutes
- * `JSONColumnPinningState` for `ColumnPinningState` and
- * `Array<ColumnJSONRepresentation>` for `Array<ColumnDef<T>>`).
- */
-export interface ColumnDefSet<T extends object> {
-    name: string;
-    sortingState: SortingState;
-    visibilityState: VisibilityState;
-    columnPinningState: ColumnPinningState;
-    columnDefs: Array<ColumnDef<T>>;
-}

package/dist/Components/Table/Types/Columns/Definitions/JSONColumnDefSet.d.ts

@@ -1,25 +0,0 @@
-import type { SortingState } from '../../DataRepository/SortingState.js';
-import type { JSONColumnPinningState } from '../JSONColumnPinningState.js';
-import type { VisibilityState } from '../VisibilityState.js';
-import type { ColumnJSONRepresentation } from './ColumnDef.svelte.js';
-/**
- * Persisted-to-localStorage projection of `ColumnDefSet`. Differs from the
- * runtime form in that:
- *
- * - `columnPinningState` is `JSONColumnPinningState` (`Array<[id, width]>`)
- *   instead of `ReadonlyMap`-based for `JSON.stringify` round-tripping.
- * - `columnDefs` carries the JSON representation of each `ColumnDef`
- *   (a `ColumnJSONRepresentation` produced by `toJSON()` on each def) rather
- *   than the live class instances.
- *
- * Security note: `JSONColumnDefSet` is read back from localStorage and must
- * pass schema validation before being trusted. The validator helper is
- * tracked under the StoragePresetSchemaValidation cross-cutting workorder.
- */
-export interface JSONColumnDefSet {
-    name: string;
-    sortingState: SortingState;
-    visibilityState: VisibilityState;
-    columnPinningState: JSONColumnPinningState;
-    columnDefs: Array<ColumnJSONRepresentation>;
-}