spiderly 19.12.0 → 19.12.1

package/fesm2022/spiderly.mjs

@@ -4754,6 +4754,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.13", ngImpo
 function rootFontSizePx() {
     return parseFloat(getComputedStyle(document.documentElement).fontSize) || 16;
 }
+/** Order matters: `[a, b]` and `[b, a]` ask the server for different orderings. */
+function sortMetaEquals(a, b) {
+    return (a.length === b.length &&
+        a.every((m, i) => m.field === b[i].field && m.order === b[i].order));
+}
 const DEFAULT_COLUMN_WIDTH_REM = {
     text: 12,
     date: 10,
@@ -4852,7 +4857,8 @@ class SpiderlyDataTableComponent {
         /** Paginator page-size choices; merge rules and persistence: CLAUDE.md → "Rows-per-page". */
         this.rowsPerPageOptions = [10, 25, 50, 100];
         /**
-         * The view currently selected. Seeded from the first view in `ngOnInit`, never left null on a
+         * The view currently selected. Seeded from the first view in `ngOnInit` — then overridden by
+         * `restoreActiveView`, so a reload lands where the operator was — and never left null on a
          * table that has views: `viewScope` keys the layout off it, so an unseeded table writes its
          * width and order to the SAME key an unmigrated table uses — orphaned the moment the operator
          * clicks the first tab — and no tab reads as selected until they do.
@@ -5020,9 +5026,12 @@ class SpiderlyDataTableComponent {
                     this.table.saveState();
                 }
                 this.table.anchorRowIndex = null;
-                return;
             }
-            originalSort(event);
+            else {
+                originalSort(event);
+            }
+            // Every explicit header-sort gesture, un-sort included, records the view's override.
+            this.persistActiveViewSort();
         };
     }
     /**
@@ -5048,12 +5057,21 @@ class SpiderlyDataTableComponent {
             }
         }
     }
-    ngOnChanges() {
+    ngOnChanges(changes) {
         // Only meaningful once ngOnInit has resolved the defaults; before that it is a no-op re-run.
         if (this.rows != null)
             this.mergeActivePageSizesIntoOptions();
+        if (changes['views'])
+            this.adoptStoredView();
     }
     ngOnInit() {
+        // Fail loud, not half-broken: the store commits through the paginated request, and a
+        // client-side (form-array) table has none — armed anyway, the first commit would call the
+        // absent getPaginatedListObservableMethod inside the requery effect and strand the pending
+        // overlay forever. Client-side store predicates are unbuilt (spiderly#407 territory).
+        if (this.filters && !this.hasLazyLoad) {
+            throw new Error('spiderly-data-table: [filters] requires a lazy table — client-side filtering through a store is not implemented. Remove [filters] or make the table lazy.');
+        }
         if (this.rows == null)
             this.rows = this.configService.defaultPageSize;
         this.activeViewId ??= this.views?.[0]?.id ?? null;
@@ -5071,23 +5089,31 @@ class SpiderlyDataTableComponent {
             this.clientLoad();
         }
         this.mergeActivePageSizesIntoOptions();
+        // AFTER `resolvedStateKey` is derived, which is what every restore below keys off — placed
+        // above it they read a null key and silently restore nothing. The view restore runs FIRST,
+        // because the other three read the `viewScope` it decides. And all of it before the effect
+        // is armed, so the first request already carries the filters and the effect's skipped first
+        // run sees the state it will be watching.
+        const restoredView = this.restoreActiveView();
         this.restoreColumnVisibility();
         this.restoreColumnLayout();
-        // AFTER `resolvedStateKey` is derived, which is what both of these key off — placed above it
-        // first, they read a null key and silently restored nothing. And before the effect is armed,
-        // so the first request already carries the filters and the effect's skipped first run sees
-        // the state it will be watching.
-        this.restoreAppliedFilters();
+        this.enterViewFilters(restoredView, 'refresh');
         if (this.filters)
             this.requeryOnAppliedFilters();
         this.chooserCols = this.cols.filter(SpiderlyDataTableComponent.isDataColumn);
         this.refreshVisibleCols();
         // Bound to p-table's [multiSortMeta] so the FIRST request already carries the right
-        // sort. Persisted user sort wins over the declared default; we read it ourselves
-        // because PrimeNG's restoreState() runs on the first [value] change — after the
-        // initial lazy emit has already left.
+        // sort. The view's own sort wins; the persisted table-global sort sits deliberately
+        // BETWEEN it and the table default, so a view declaring nothing keeps the ordering the
+        // operator last chose. We read it all ourselves because PrimeNG's restoreState() runs on
+        // the first [value] change — after the initial lazy emit has already left — and is then
+        // told to agree (see `alignPersistedTableStateSort`).
+        const tableState = this.persistedTableState();
         this.initialMultiSortMeta =
-            this.persistedMultiSortMeta() ?? this.defaultMultiSortMeta();
+            this.viewSort() ??
+                this.sanitizedSortMeta(tableState?.multiSortMeta) ??
+                this.tableDefaultMultiSortMeta();
+        this.alignPersistedTableStateSort(tableState);
     }
     /** A data column shows values for a `field`; anything else (the actions column) always renders. */
     static isDataColumn(col) {
@@ -5225,24 +5251,48 @@ class SpiderlyDataTableComponent {
         }
         this.persistColumnVisibility();
         this.refreshVisibleCols();
+        if (!visible)
+            this.dropHiddenColumnSort([col]);
     }
     /**
      * Restores every column to its declared default and forgets the stored overrides — visibility,
      * wrap, order and width alike. It undid visibility only until the header menu shipped three
      * more gestures beside it, and a layout with no way back is worse than one with no knobs.
      *
-     * Hiding — here or from the menu — never touches filters or sort: the chip bar names every
-     * applied filter and the sort chip names the sort, hidden column or not (decision 2b). The
-     * legacy "hidden contributes nothing" apparatus died with the header-filter path.
+     * On a STORE table, hiding — here or from the menu — never touches filters or sort: the chip
+     * bar names every applied filter and the sort chip names the sort, hidden column or not
+     * (decision 2b). A storeless table keeps the sort half of the legacy invariant instead — see
+     * `dropHiddenColumnSort`.
      */
     resetColumnLayout() {
         this.columnWrap = {};
         this.columnOrder = [];
         this.columnWidths = {};
         this.persistColumnLayout();
+        const wasVisible = this.visibleCols.filter(SpiderlyDataTableComponent.isDataColumn);
         this.columnVisibilityOverrides = {};
         this.persistColumnVisibility();
         this.refreshVisibleCols();
+        // Columns the reset just hid follow the same rule as a manual hide.
+        this.dropHiddenColumnSort(wasVisible.filter((col) => !this.isColumnVisible(col)));
+    }
+    /**
+     * The sort half of the legacy "hidden contributes nothing" invariant, kept ONLY for storeless
+     * tables (the generated M2M details grids, until spiderly#407 scaffolds their stores): they
+     * have no sort chip, so a hidden column's sort would order the grid with nothing on screen
+     * naming it and no control left to clear it. The filter half needs no heir — `lazyLoad`
+     * overwrites the outgoing filters unconditionally. On a store table this is a no-op:
+     * decision 2b's chips are the visible surface, hidden column or not.
+     */
+    dropHiddenColumnSort(cols) {
+        if (!this.table || this.filters)
+            return;
+        const sorted = cols.filter((col) => this.table._multiSortMeta?.some((m) => m.field === col.field));
+        if (!sorted.length)
+            return;
+        this.table._multiSortMeta = this.table._multiSortMeta.filter((m) => !sorted.some((col) => col.field === m.field));
+        this.table.tableService.onSort(this.table._multiSortMeta);
+        this.table._filter(); // re-emits the lazy load and saves the cleaned state
     }
     /**
      * Layout keys carry the ACTIVE VIEW, which is what makes a view more than a saved filter: a
@@ -5271,6 +5321,65 @@ class SpiderlyDataTableComponent {
     get filterStorage() {
         return this.stateStorage === 'local' ? localStorage : sessionStorage;
     }
+    /**
+     * Where the active view id lives. Deliberately NOT view-scoped — it is the input `viewScope`
+     * derives from — and it follows `stateStorage` like the filters rather than the layout's
+     * always-local rule, because the id and the filters it scopes are one question: a durable id
+     * over session-scoped filters would restore a tab with nothing under it.
+     */
+    get viewStateKey() {
+        return this.resolvedStateKey ? `${this.resolvedStateKey}:view` : null;
+    }
+    /** Only `selectView` writes; the `ngOnInit` seed does not — absence means "the default". */
+    persistActiveView() {
+        if (!this.viewStateKey || !this.activeViewId)
+            return;
+        writeStoredJson(this.filterStorage, this.viewStateKey, this.activeViewId);
+    }
+    /**
+     * Puts a reload back on the view the operator was using. Every persisted key carries the view
+     * segment, so before this existed the seed decided what got restored: F5 landed on the first
+     * view and read `…:all:filters` — the tab snapped to "Sve" and the bar came back empty while
+     * the operator's filters sat intact under the old view's segment (Filip, on /porudzbine).
+     *
+     * An id naming no current view keeps the seed AND the stored key: "vanished by deploy" and
+     * "not yet arrived" are indistinguishable here (order-list's catalog-licensed "Za pakovanje"
+     * is literally both), so `adoptStoredView` re-reads the key on every `[views]` change and the
+     * key self-heals on the next explicit click.
+     */
+    restoreActiveView() {
+        if (!this.viewStateKey || !this.views?.length)
+            return null;
+        const storedId = readStoredJson(this.filterStorage, this.viewStateKey);
+        if (typeof storedId !== 'string')
+            return null;
+        const view = this.viewById(storedId) ?? null;
+        if (view)
+            this.activeViewId = view.id;
+        return view;
+    }
+    /**
+     * The second half of `restoreActiveView`: a stored view that did not exist at init is adopted
+     * when a later `[views]` change brings it — through `selectView`, so it gets the same
+     * stored-wins/transient/layout/requery semantics a click would have had. There is no parked
+     * copy of the stored id — the key itself is re-read, and because every explicit pick
+     * overwrites it, the operator's own choice wins by construction. Accepted cost of adopting
+     * late instead of holding the first request: a brief flash of the seeded view's rows and a
+     * second request when the late view lands.
+     */
+    adoptStoredView() {
+        if (!this.viewStateKey)
+            return;
+        const storedId = readStoredJson(this.filterStorage, this.viewStateKey);
+        if (typeof storedId !== 'string' || storedId === this.activeViewId)
+            return;
+        const view = this.viewById(storedId);
+        if (view)
+            this.selectView(view);
+    }
+    viewById(id) {
+        return this.views?.find((candidate) => candidate.id === id);
+    }
     persistAppliedFilters() {
         if (!this.filtersStateKey || !this.filters)
             return;
@@ -5282,12 +5391,27 @@ class SpiderlyDataTableComponent {
             writeStoredJson(this.filterStorage, this.filtersStateKey, snapshot);
         }
     }
-    restoreAppliedFilters() {
-        if (!this.filtersStateKey || !this.filters)
+    /**
+     * Applies the right filters for entering `view` — the transient rule's one home. A TRANSIENT
+     * view's `apply` is a function of NOW, so it always re-derives; restoring would put
+     * yesterday's date under a tab claiming "today" (`persistAppliedFilters` has no transient
+     * guard, so storage holds the LAST answer). A non-transient view's own stored answer wins
+     * over its `apply`. The semantics argument is the one deliberate difference between the
+     * callers: a 'click' re-asks the view's question when nothing is stored, a 'refresh' returns
+     * the empty state the operator left — they cleared it, and F5 must give the cleared state
+     * back. On a table with no views, `view` is null and this is a plain restore of the
+     * `persistAppliedFilters` snapshot.
+     */
+    enterViewFilters(view, semantics) {
+        if (!this.filters)
             return;
-        const snapshot = readStoredJson(this.filterStorage, this.filtersStateKey);
-        if (snapshot)
-            this.filters.restore(snapshot);
+        const stored = !view?.transient && this.filtersStateKey
+            ? readStoredJson(this.filterStorage, this.filtersStateKey)
+            : null;
+        if (stored)
+            this.filters.restore(stored);
+        else if (view?.transient || semantics === 'click')
+            view?.apply?.(this.filters);
     }
     get layoutStateKey() {
         return this.resolvedStateKey
@@ -5344,25 +5468,135 @@ class SpiderlyDataTableComponent {
             return null;
         return readStoredJson(this.stateStorage === 'local' ? localStorage : sessionStorage, this.resolvedStateKey);
     }
+    activeView() {
+        return this.activeViewId ? this.viewById(this.activeViewId) : undefined;
+    }
+    /**
+     * Where the operator's per-view sort override lives. Null on a table without views — those
+     * keep the pure PrimeNG sort persistence they always had — and null on a STORELESS table:
+     * there "hidden contributes nothing" retires a hidden column's sort (`dropHiddenColumnSort`)
+     * with no persist call at the hide site, so an override restored blind at the next init
+     * would re-impose a sort no chip can name. Store tables — where every viewed consumer
+     * lives — have the chip. Follows `stateStorage` like the filters and the view id: the sort
+     * is part of the same question they scope.
+     */
+    get viewSortStateKey() {
+        if (!this.views?.length || !this.filters)
+            return null;
+        return this.resolvedStateKey
+            ? `${this.resolvedStateKey}${this.viewScope}:sort`
+            : null;
+    }
+    /** The operator's stored sort for the active view, sanitized like any persisted sort. */
+    persistedViewSort() {
+        if (!this.viewSortStateKey)
+            return null;
+        const stored = readStoredJson(this.filterStorage, this.viewSortStateKey);
+        return Array.isArray(stored) ? this.sanitizedSortMeta(stored) : null;
+    }
+    /** The sort this view asks for: the operator's stored override, else its declared sort. */
+    viewSort() {
+        return this.persistedViewSort() ?? this.viewDeclaredMultiSortMeta();
+    }
+    /**
+     * Records the current sort as the active view's override — called from the EXPLICIT sort
+     * gestures only (header click, menu sort, Clear filters), never from a load: a sort merely
+     * inherited at init must not crystallize into an override, or a later change to the view's
+     * declared sort would stop flowing to operators who never touched sort — the same
+     * flows-through rule `columnVisibilityOverrides` documents. A sort equal to the declared
+     * default is stored as ABSENCE for the same reason.
+     */
+    persistActiveViewSort() {
+        const key = this.viewSortStateKey;
+        if (!key)
+            return;
+        const current = this.table._multiSortMeta ?? [];
+        if (sortMetaEquals(current, this.defaultMultiSortMeta() ?? [])) {
+            this.filterStorage.removeItem(key);
+        }
+        else {
+            writeStoredJson(this.filterStorage, key, current);
+        }
+    }
+    /**
+     * Puts the entering view's sort on the grid — stored override first, then the declared sort;
+     * a view stating no preference keeps the ordering already there (the pre-decision-10-sort
+     * behavior, and the least surprising for the tab an operator never sorted). Broadcast only —
+     * the caller owns the refetch, because which request carries the new sort differs between the
+     * store and storeless paths.
+     */
+    applyViewSort() {
+        const target = this.viewSort();
+        if (!target)
+            return false;
+        if (sortMetaEquals(target, this.table._multiSortMeta ?? []))
+            return false;
+        this.broadcastSort(target);
+        return true;
+    }
+    /**
+     * Rewrites the sort inside PrimeNG's persisted state to the one `ngOnInit` resolved. The two
+     * can disagree only on a viewed table — PrimeNG's state is table-global while the resolved
+     * sort is the view's — and PrimeNG's restoreState() applies its copy on the first [value]
+     * change, AFTER the initial request already left with ours: without this line the grid's
+     * arrows and every later request silently fall back to the other view's sort. Handed the
+     * already-parsed state: `ngOnInit` reads the blob once for the whole init pass.
+     */
+    alignPersistedTableStateSort(state) {
+        if (!this.views?.length || !this.resolvedStateKey || !state)
+            return;
+        const resolved = this.initialMultiSortMeta ?? [];
+        if (sortMetaEquals(state.multiSortMeta ?? [], resolved))
+            return;
+        state.multiSortMeta = resolved.length ? resolved : undefined;
+        writeStoredJson(this.filterStorage, this.resolvedStateKey, state);
+    }
     //#endregion
     /**
-     * The declared default as PrimeNG sort meta, or null when none is declared. Applies even
-     * while its column is hidden: the sort chip names the ordering whether or not the column
-     * is on screen (decision 2b).
+     * The DECLARED default in the current context: the active view's own sort when it declares
+     * one, else the table-level `defaultSortField`. Every "fall back to the declared default"
+     * site — tri-state un-sort, Clear filters, the unsorted-load safety net — reads this, so
+     * un-sorting inside a view lands on the view's ordering, not the table's.
      */
     defaultMultiSortMeta() {
+        return this.viewDeclaredMultiSortMeta() ?? this.tableDefaultMultiSortMeta();
+    }
+    /**
+     * The active view's declared sort, sanitized: a non-sortable field would answer every load
+     * with a 400 (`keepSortableMeta`'s rationale), so it is dropped rather than sent; a view
+     * whose declaration sanitizes to nothing falls through to the table default.
+     */
+    viewDeclaredMultiSortMeta() {
+        return this.sanitizedSortMeta(this.activeView()?.sort);
+    }
+    /**
+     * The table-level declared default as PrimeNG sort meta, or null when none is declared. On a
+     * store table it applies even while its column is hidden — the sort chip names the ordering
+     * whether or not the column is on screen (decision 2b). A STORELESS table has no chip, so a
+     * hidden default would order the grid with nothing on screen naming it; there the default
+     * dies with the column, exactly as the legacy invariant had it (see `dropHiddenColumnSort`).
+     */
+    tableDefaultMultiSortMeta() {
         if (!this.defaultSortField)
             return null;
         const defaultSortCol = this.cols?.find((col) => col.field === this.defaultSortField);
+        if (defaultSortCol &&
+            !this.filters &&
+            !this.isColumnVisible(defaultSortCol))
+            return null;
         // A declared default on a non-sortable column is a consumer mistake the backend answers
         // with a 400 on every load; fall back to its implicit Id DESC instead (see keepSortableMeta).
         if (defaultSortCol && !this.isColumnSortable(defaultSortCol))
             return null;
         return [{ field: this.defaultSortField, order: this.defaultSortOrder }];
     }
-    persistedMultiSortMeta() {
-        const state = this.persistedTableState();
-        const sortable = this.keepSortableMeta(state?.multiSortMeta);
+    /**
+     * `keepSortableMeta` with "sanitized to nothing" surfaced as null — the rule every sort
+     * SOURCE shares ("a sort that sanitizes to nothing is no sort"), so the resolution chains
+     * can `??` past an empty answer instead of stopping on an empty array.
+     */
+    sanitizedSortMeta(multiSortMeta) {
+        const sortable = this.keepSortableMeta(multiSortMeta);
         return sortable.length ? sortable : null;
     }
     /**
@@ -5393,10 +5627,13 @@ class SpiderlyDataTableComponent {
         if (defaultSort == null)
             return;
         event.multiSortMeta = defaultSort;
-        if (this.table) {
-            this.table._multiSortMeta = defaultSort;
-            this.table.tableService.onSort(defaultSort);
-        }
+        if (this.table)
+            this.broadcastSort(defaultSort);
+    }
+    /** Puts `meta` on the grid and tells the header icons — no fetch; the caller owns that. */
+    broadcastSort(meta) {
+        this.table._multiSortMeta = meta;
+        this.table.tableService.onSort(meta);
     }
     onPageChange(container) {
         scrollElementIntoViewIfAboveViewport(container);
@@ -5558,25 +5795,35 @@ class SpiderlyDataTableComponent {
      */
     selectView(view) {
         this.activeViewId = view.id;
+        // Always writes — including the first view, so a deliberate "Sve" during a deploy race
+        // sticks, and so an explicit pick beats a stored id whose view has not arrived yet
+        // (`adoptStoredView` compares against this key).
+        this.persistActiveView();
         // The keys just changed under us, so the layout has to be re-read for the view being entered
         // — otherwise the one being left keeps rendering until something else forces a reload.
         this.restoreColumnVisibility();
         this.restoreColumnLayout();
         this.refreshVisibleCols();
-        if (!this.filters)
+        // Sort is view state too (decision 10's sort half). Swapped BEFORE the filter transition so
+        // the one request the requery effect sends carries both.
+        const sortChanged = this.applyViewSort();
+        if (!this.filters) {
+            if (sortChanged)
+                this.table.sortMultiple();
             return;
-        // The filter key moved with the view too, so this view's own stored answer wins over whatever
-        // the last one left applied; `apply` runs only when the view has nothing stored yet. A
-        // TRANSIENT view inverts that: its apply is a function of now, so it always re-derives —
-        // restoring would put yesterday's date under a tab claiming "today".
+        }
+        const appliedBefore = this.filters.applied();
+        // The filter key moved with the view too; `enterViewFilters` holds the stored-wins and
+        // transient rules.
         this.filters.clear();
-        const stored = !view.transient && this.filtersStateKey
-            ? readStoredJson(this.filterStorage, this.filtersStateKey)
-            : null;
-        if (stored)
-            this.filters.restore(stored);
-        else
-            view.apply?.(this.filters);
+        this.enterViewFilters(view, 'click');
+        // The requery effect runs only when the applied set actually changed — `clear()` on an
+        // already-empty store writes nothing (two views sharing one filter answer are exactly that)
+        // — so a sort-only switch fetches here. `applied` is a computed: reference equality across
+        // the transition means none of its sources moved.
+        if (sortChanged && this.filters.applied() === appliedBefore) {
+            this.refetchFromFirstPage();
+        }
     }
     /**
      * The filter this column stands for. Defaults to the column's own `field`, because a store id
@@ -5627,6 +5874,7 @@ class SpiderlyDataTableComponent {
             return;
         this.table._multiSortMeta = [{ field: col.field, order }];
         this.table.sortMultiple();
+        this.persistActiveViewSort();
     }
     /**
      * Sizes the column to the widest thing in it. The cheaper escape from a cramped column: no
@@ -6003,11 +6251,24 @@ class SpiderlyDataTableComponent {
                 return;
             }
             this.persistAppliedFilters();
-            this.table.first = 0;
-            this.table.firstChange.emit(0);
-            this.lazyLoad(this.table.createLazyLoadMetadata());
+            this.refetchFromFirstPage();
         }, { injector: this.injector });
     }
+    /**
+     * Back to page one, state saved, one fetch off FRESH metadata — the shared tail of the
+     * requery effect and `selectView`'s sort-only switch. The save is load-bearing: PrimeNG
+     * saves state only from its own interactions, so without it the pre-change page offset
+     * survives in storage and the NEXT visit replays it against a narrowed result set — the
+     * backend answers data=[] for an offset the filtered total no longer reaches, and the grid
+     * renders empty under chips claiming matches.
+     */
+    refetchFromFirstPage() {
+        this.table.first = 0;
+        this.table.firstChange.emit(0);
+        if (this.table.isStateful())
+            this.table.saveState();
+        this.lazyLoad(this.table.createLazyLoadMetadata());
+    }
     reload() {
         // Nothing to replay before the table's own initial load, which is already on its way.
         if (this.lastLazyLoadEvent == null)
@@ -6116,6 +6377,10 @@ class SpiderlyDataTableComponent {
         this.filters?.clear();
         table.clear();
         table.clearState();
+        // `table.clear()` landed the grid on the declared default (`applyDefaultSortIfUnsorted`),
+        // so the view's sort override must go with it — or F5 would bring back the sort Clear
+        // visibly removed.
+        this.persistActiveViewSort();
     }
     //#region Selection
     setFakeIsAllSelected() {
@@ -6415,12 +6680,13 @@ class Action {
     }
 }
 class Column {
-    constructor({ name, field, filterType, filterId, showMatchModes, dropdownOrMultiselectValues, actions, editable, showTime, decimalPlaces, sortable, visible, lockVisible, width, onCellClick, } = {}) {
+    constructor({ name, field, filterType, filterId, showMatchModes, filterField, dropdownOrMultiselectValues, actions, editable, showTime, decimalPlaces, sortable, visible, lockVisible, width, onCellClick, } = {}) {
         this.name = name;
         this.field = field;
         this.filterType = filterType;
         this.filterId = filterId;
         this.showMatchModes = showMatchModes;
+        this.filterField = filterField;
         this.dropdownOrMultiselectValues = dropdownOrMultiselectValues;
         this.actions = actions;
         this.editable = editable;
@@ -6462,10 +6728,11 @@ var MatchModeCodes;
  * paginator implements per type (`PaginatedResultGenerator`): `In` on a string column answers
  * with InvalidMatchMode, PrimeNG's own text list adds three modes the backend 400s, and so on.
  *
- * Deliberately a LEAF module (imports nothing but the codes) so both consumers can derive from
- * it without a cycle: the store's runtime validation and offered lists (`filter-store.ts`), and
- * the compile-time `FilterRule.matchMode` union (`entities/filter-rule.ts`). These used to be
- * hand-kept copies; edit the table here and every surface follows.
+ * Deliberately a LEAF module (imports nothing but the codes) so every consumer can derive from
+ * it without a cycle: the store's runtime validation and offered lists (`filter-store.ts`), the
+ * compile-time `FilterRule.matchMode` union (`entities/filter-rule.ts`), and the data view's
+ * kind-level lists (via `operatorOptionsForKind`). These used to be hand-kept copies; edit the
+ * table here and every surface follows.
  *
  * Tuple order is DISPLAY order for every operator picker (Equals, then "less/before", then
  * "more/after" — the order the header dropdowns always shipped).
@@ -6563,6 +6830,17 @@ function toOperatorOptions(kind, operators) {
         labelKey: OPERATOR_WORDS[kind][value]?.pickerKey ?? value,
     }));
 }
+/**
+ * A KIND's operator picker options, for callers with no filter behind them — today that is
+ * `spiderly-data-view`, whose own filter config derives its operator lists here instead of
+ * hand-keeping copies (the drift `allowed-operators.ts` exists to end). Per-FILTER narrowing
+ * lives in the store (`createFilterStore` resolves it once per declaration), so this cannot be
+ * handed a fake definition to satisfy — that shape shipped once and interpolated an empty
+ * filter name into its own error message.
+ */
+function operatorOptionsForKind(kind, hasOptions = false) {
+    return toOperatorOptions(kind, baseOperators(kind, hasOptions));
+}
 /**
  * The operator applied when nobody picked one, which has to be what a person MEANS by filling in
  * the control. `Contains` for a fragment typed into a box; `GreaterThan` for a date, never
@@ -6916,34 +7194,15 @@ class SpiderlyDataViewComponent {
         };
     }
     ngOnInit() {
-        this.matchModeDateOptions = [
-            {
-                label: this.translocoService.translate('OnDate'),
-                value: MatchModeCodes.Equals,
-            },
-            {
-                label: this.translocoService.translate('DatesBefore'),
-                value: MatchModeCodes.LessThan,
-            },
-            {
-                label: this.translocoService.translate('DatesAfter'),
-                value: MatchModeCodes.GreaterThan,
-            },
-        ];
-        this.matchModeNumberOptions = [
-            {
-                label: this.translocoService.translate('Equals'),
-                value: MatchModeCodes.Equals,
-            },
-            {
-                label: this.translocoService.translate('LessThan'),
-                value: MatchModeCodes.LessThan,
-            },
-            {
-                label: this.translocoService.translate('MoreThan'),
-                value: MatchModeCodes.GreaterThan,
-            },
-        ];
+        // Derived from the ONE operator table (`filters/allowed-operators.ts`) rather than
+        // hand-kept: these were the last hand-written copies of the per-kind lists, and a backend
+        // operator change edited in the shared table would silently never have reached them.
+        const matchModeOptionsFor = (kind) => operatorOptionsForKind(kind).map((option) => ({
+            label: this.translocoService.translate(option.labelKey),
+            value: option.value,
+        }));
+        this.matchModeDateOptions = matchModeOptionsFor('date');
+        this.matchModeNumberOptions = matchModeOptionsFor('number');
     }
     // Paging semantics and the scroll-margin contract are documented once, on the data table:
     // spiderly-data-table/CLAUDE.md → "Scroll back to the table on page change".
@@ -7584,5 +7843,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.13", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { ALLOWED_OPERATORS, Action, AllClickEvent, ApiErrorCodes, ApiSecurityService, AppSidebarComponent, AuthCardComponent, AuthGuard, AuthResult, AuthResultWithCookies, AuthServiceBase, BaseAutocompleteControl, BaseControl, BaseDropdownControl, BaseEntity, BaseFormComponent, BaseFormService, CardSkeletonComponent, Codebook, Column, ConfigServiceBase, DEFAULT_EXTERNAL_PROVIDER_ICONS, DEFAULT_OPERATOR, ExternalLoginComponent, ExternalProvider, ExternalProviderPublic, Filter, FilterRule, FilterSortMeta, IndexCardComponent, InfoCardComponent, InitCompanyAuthDialogDetails, InitTopBarData, IsAuthorizedForSaveEvent, LastMenuIconIndexClicked, LayoutServiceBase, LazyLoadSelectedIdsResult, Login, LoginVerificationComponent, LoginVerificationToken, MatchModeCodes, MenuChangeEvent, MenuitemComponent, Namebook, NotAuthGuard, NotFoundComponent, PROPS_KEY, PaginatedResult, PanelBodyComponent, PanelFooterComponent, PanelHeaderComponent, PrimengOption, ProfileAvatarComponent, ReflectProp, RefreshTokenRequest, RequiredComponent, RowClickEvent, SecurityPermissionCodes, SendLoginVerificationEmailResult, SideMenuTopBarComponent, SidebarMenuComponent, SimpleSaveResult, SpiderlyAutocompleteComponent, SpiderlyButtonBaseComponent, SpiderlyButtonComponent, SpiderlyCalendarComponent, SpiderlyCardComponent, SpiderlyCellTemplateDirective, SpiderlyCheckboxComponent, SpiderlyColorPickerComponent, SpiderlyControlsModule, SpiderlyDataTableActionsDirective, SpiderlyDataTableComponent, SpiderlyDataViewComponent, SpiderlyDeleteConfirmationComponent, SpiderlyDropdownComponent, SpiderlyEditorComponent, SpiderlyErrorHandler, SpiderlyFileComponent, SpiderlyFileSelectEvent, SpiderlyFilterBarComponent, SpiderlyFilterTemplateDirective, SpiderlyFormArray, SpiderlyFormControl, SpiderlyFormGroup, SpiderlyLayoutComponent, SpiderlyLoginComponent, SpiderlyMarkdownComponent, SpiderlyMessageService, SpiderlyMultiAutocompleteComponent, SpiderlyMultiSelectComponent, SpiderlyNumberComponent, SpiderlyOverflowTitleDirective, SpiderlyPanelComponent, SpiderlyPanelsModule, SpiderlyPasswordComponent, SpiderlyReturnButtonComponent, SpiderlySplitButtonComponent, SpiderlyTab, SpiderlyTemplateTypeDirective, SpiderlyTextareaComponent, SpiderlyTextboxComponent, SpiderlyTranslocoLoader, TopBarComponent, UserBase, UserRole, ValidatorAbstractService, VerificationTokenRequest, VerificationTypeCodes, VerificationWrapperComponent, adjustColor, authInitializer, booleanFilter, capitalizeFirstChar, createFilterStore, dateFilter, deleteAction, exportListToExcel, firstCharToUpper, foldForSearch, getFileNameFromContentDisposition, getFilterOptions, getHtmlImgDisplayString64, getImageDimensions, getMimeTypeForFileName, getMonth, getParentUrl, getPrimengAutocompleteCodebookOptions, getPrimengAutocompleteNamebookOptions, getPrimengDropdownCodebookOptions, getPrimengDropdownNamebookOptions, getPrimengNamebookOptions, httpLoadingInterceptor, isExcelFileType, isFileImageType, isNullOrEmpty, jsonHttpInterceptor, jwtInterceptor, kebabToTitleCase, nameOf, nameof, numberFilter, parseDateOnlyLocal, pushAction, saveResponseAsFile, scrollElementIntoViewIfAboveViewport, selectedTab, singleOrDefault, splitPascalCase, textFilter, toCommaSeparatedString, unauthorizedInterceptor, validatePrecisionScale };
+export { ALLOWED_OPERATORS, Action, AllClickEvent, ApiErrorCodes, ApiSecurityService, AppSidebarComponent, AuthCardComponent, AuthGuard, AuthResult, AuthResultWithCookies, AuthServiceBase, BaseAutocompleteControl, BaseControl, BaseDropdownControl, BaseEntity, BaseFormComponent, BaseFormService, CardSkeletonComponent, Codebook, Column, ConfigServiceBase, DEFAULT_EXTERNAL_PROVIDER_ICONS, DEFAULT_OPERATOR, ExternalLoginComponent, ExternalProvider, ExternalProviderPublic, Filter, FilterRule, FilterSortMeta, IndexCardComponent, InfoCardComponent, InitCompanyAuthDialogDetails, InitTopBarData, IsAuthorizedForSaveEvent, LastMenuIconIndexClicked, LayoutServiceBase, LazyLoadSelectedIdsResult, Login, LoginVerificationComponent, LoginVerificationToken, MatchModeCodes, MenuChangeEvent, MenuitemComponent, Namebook, NotAuthGuard, NotFoundComponent, PROPS_KEY, PaginatedResult, PanelBodyComponent, PanelFooterComponent, PanelHeaderComponent, PrimengOption, ProfileAvatarComponent, ReflectProp, RefreshTokenRequest, RequiredComponent, RowClickEvent, SecurityPermissionCodes, SendLoginVerificationEmailResult, SideMenuTopBarComponent, SidebarMenuComponent, SimpleSaveResult, SpiderlyAutocompleteComponent, SpiderlyButtonBaseComponent, SpiderlyButtonComponent, SpiderlyCalendarComponent, SpiderlyCardComponent, SpiderlyCellTemplateDirective, SpiderlyCheckboxComponent, SpiderlyColorPickerComponent, SpiderlyControlsModule, SpiderlyDataTableActionsDirective, SpiderlyDataTableComponent, SpiderlyDataViewComponent, SpiderlyDeleteConfirmationComponent, SpiderlyDropdownComponent, SpiderlyEditorComponent, SpiderlyErrorHandler, SpiderlyFileComponent, SpiderlyFileSelectEvent, SpiderlyFilterBarComponent, SpiderlyFilterTemplateDirective, SpiderlyFormArray, SpiderlyFormControl, SpiderlyFormGroup, SpiderlyLayoutComponent, SpiderlyLoginComponent, SpiderlyMarkdownComponent, SpiderlyMessageService, SpiderlyMultiAutocompleteComponent, SpiderlyMultiSelectComponent, SpiderlyNumberComponent, SpiderlyOverflowTitleDirective, SpiderlyPanelComponent, SpiderlyPanelsModule, SpiderlyPasswordComponent, SpiderlyReturnButtonComponent, SpiderlySplitButtonComponent, SpiderlyTab, SpiderlyTemplateTypeDirective, SpiderlyTextareaComponent, SpiderlyTextboxComponent, SpiderlyTranslocoLoader, TopBarComponent, UserBase, UserRole, ValidatorAbstractService, VerificationTokenRequest, VerificationTypeCodes, VerificationWrapperComponent, adjustColor, authInitializer, booleanFilter, capitalizeFirstChar, createFilterStore, dateFilter, deleteAction, exportListToExcel, firstCharToUpper, foldForSearch, getFileNameFromContentDisposition, getFilterOptions, getHtmlImgDisplayString64, getImageDimensions, getMimeTypeForFileName, getMonth, getParentUrl, getPrimengAutocompleteCodebookOptions, getPrimengAutocompleteNamebookOptions, getPrimengDropdownCodebookOptions, getPrimengDropdownNamebookOptions, getPrimengNamebookOptions, httpLoadingInterceptor, isExcelFileType, isFileImageType, isNullOrEmpty, jsonHttpInterceptor, jwtInterceptor, kebabToTitleCase, nameOf, nameof, numberFilter, operatorOptionsForKind, parseDateOnlyLocal, pushAction, saveResponseAsFile, scrollElementIntoViewIfAboveViewport, selectedTab, singleOrDefault, splitPascalCase, textFilter, toCommaSeparatedString, unauthorizedInterceptor, validatePrecisionScale };
 //# sourceMappingURL=spiderly.mjs.map