spiderly 19.13.0 → 19.14.0

package/fesm2022/spiderly.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { Input, Component, EventEmitter, Output, Injectable, ViewChild, NgModule, PLATFORM_ID, Inject, HostBinding, Directive, inject, ElementRef, NgZone, input, output, LOCALE_ID, signal, computed, Injector, viewChild, effect, TemplateRef, ContentChildren, ContentChild } from '@angular/core';
+import { Input, Component, EventEmitter, Output, Injectable, ViewChild, NgModule, PLATFORM_ID, Inject, HostBinding, Directive, inject, ElementRef, NgZone, signal, computed, input, output, LOCALE_ID, Injector, viewChild, untracked, effect, TemplateRef, ContentChildren, ContentChild } from '@angular/core';
 import * as i1 from '@jsverse/transloco';
 import { TranslocoDirective, TranslocoService } from '@jsverse/transloco';
 import * as i2 from '@angular/common';
@@ -4024,157 +4024,612 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.13", ngImpo
                 }]
         }], ctorParameters: () => [] });
 
+var MatchModeCodes;
+(function (MatchModeCodes) {
+    MatchModeCodes["StartsWith"] = "startsWith";
+    MatchModeCodes["Contains"] = "contains";
+    MatchModeCodes["Equals"] = "equals";
+    MatchModeCodes["LessThan"] = "lessThan";
+    MatchModeCodes["GreaterThan"] = "greaterThan";
+    MatchModeCodes["In"] = "in";
+})(MatchModeCodes || (MatchModeCodes = {}));
+
 /**
- * Renders the editor for ONE filter of a `spiderly-data-table`'s bar, replacing the control the
- * bar would have drawn for that filter's kind. Bind it to the filter's id; filters with no
- * matching template keep the built-in control, so a table opts in one filter at a time.
+ * What each value type may be asked — the ONE operator table, mirroring what the generated
+ * 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.
  *
- * This is the narrow job the directive has. Placing a filter ANYWHERE else — a drawer, a modal,
- * a header cell — needs no directive at all: `store.get(id)` returns the same handle and depends
- * on nothing in the component tree, which is why the store is the consumer's to own.
+ * 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).
  */
-class SpiderlyFilterTemplateDirective {
-    constructor(template) {
-        this.template = template;
-    }
-    /**
-     * Without this the `let-` variable is `any` at every consumer, however well the context is
-     * declared — a directive's injected `TemplateRef<C>` never reaches the template that declares
-     * it. Same mechanism as `SpiderlyCellTemplateDirective`.
-     */
-    static ngTemplateContextGuard(dir, ctx) {
-        return true;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: SpiderlyFilterTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.13", type: SpiderlyFilterTemplateDirective, isStandalone: true, selector: "ng-template[spiderlyFilterTemplate]", inputs: { filterId: ["spiderlyFilterTemplate", "filterId"] }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: SpiderlyFilterTemplateDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: 'ng-template[spiderlyFilterTemplate]',
-                }]
-        }], ctorParameters: () => [{ type: i0.TemplateRef }], propDecorators: { filterId: [{
-                type: Input,
-                args: ['spiderlyFilterTemplate']
-            }] } });
+const ALLOWED_OPERATORS = {
+    text: [
+        MatchModeCodes.StartsWith,
+        MatchModeCodes.Contains,
+        MatchModeCodes.Equals,
+    ],
+    number: [
+        MatchModeCodes.Equals,
+        MatchModeCodes.LessThan,
+        MatchModeCodes.GreaterThan,
+        MatchModeCodes.In,
+    ],
+    boolean: [MatchModeCodes.Equals],
+    date: [
+        MatchModeCodes.Equals,
+        MatchModeCodes.LessThan,
+        MatchModeCodes.GreaterThan,
+    ],
+};
 
-/** One option's word for one value — the honest raw value when no option matches (failed lookup). */
-function spellOptionValue(options, value) {
-    return String(options?.find((option) => option.value === value)?.label ?? value);
-}
+const OPERATOR_WORDS = {
+    text: {
+        [MatchModeCodes.StartsWith]: {
+            pickerKey: 'StartsWith',
+            phraseKey: 'FilterChipStartsWith',
+        },
+        [MatchModeCodes.Contains]: {
+            pickerKey: 'Contains',
+            phraseKey: 'FilterChipContains',
+        },
+        [MatchModeCodes.Equals]: {
+            pickerKey: 'Equals',
+            phraseKey: 'FilterChipEquals',
+        },
+        // No `In` for text: ALLOWED_OPERATORS.text does not carry it, so the entry was unreachable —
+        // and it made `textFilter({ options })` look supported when the store throws on it.
+    },
+    number: {
+        [MatchModeCodes.Equals]: {
+            pickerKey: 'Equals',
+            phraseKey: 'FilterChipEquals',
+        },
+        [MatchModeCodes.GreaterThan]: {
+            pickerKey: 'MoreThan',
+            phraseKey: 'FilterChipGreaterThan',
+        },
+        [MatchModeCodes.LessThan]: {
+            pickerKey: 'LessThan',
+            phraseKey: 'FilterChipLessThan',
+        },
+        // The picker never renders for a pick-list (one operator), but the CHIP always does.
+        [MatchModeCodes.In]: { pickerKey: 'In', phraseKey: 'FilterChipIn' },
+    },
+    boolean: {
+        [MatchModeCodes.Equals]: {
+            pickerKey: 'Equals',
+            phraseKey: 'FilterChipEquals',
+        },
+    },
+    date: {
+        [MatchModeCodes.Equals]: {
+            pickerKey: 'OnDate',
+            phraseKey: 'FilterChipEquals',
+        },
+        [MatchModeCodes.LessThan]: {
+            pickerKey: 'DatesBefore',
+            phraseKey: 'FilterChipBefore',
+        },
+        [MatchModeCodes.GreaterThan]: {
+            pickerKey: 'DatesAfter',
+            phraseKey: 'FilterChipAfter',
+        },
+    },
+};
 /**
- * Lowercased and stripped of diacritics for matching. NFD decomposition handles č/ć/š/ž, but NOT
- * đ — it is its own letter (U+0111), not a d carrying a mark, so it decomposes to nothing and has
- * to be mapped by hand.
+ * `In` and options are the same fact seen from two sides: `In` needs a list of values, and the
+ * editor only draws one when the filter declares options. So options mean `In` and nothing else,
+ * and their absence rules `In` out — offering it on a plain number filter would hand the
+ * operator a mode with no control behind it.
  *
- * It maps to "dj", which is what the rest of this workspace already does (pa-cms's
- * `normalizePlaceQuery` and `toAscii`, the backend's `PlaceNameNormalizer`) and what someone
- * without a Serbian layout actually types. Mapping it to "d" — as this first shipped — folds
- * "Đorđe" to "dorde", so typing "djordje" finds nothing: the exact case the comment claimed to
- * fix, and one no spec covered because the test used "drzava", which has no đ in it.
+ * Widened first: the per-kind tuples are literal, so `boolean`'s `[Equals]` makes the `In`
+ * comparison a "no overlap" error rather than an empty result.
  */
-function foldForSearch(value) {
-    return value
-        .normalize('NFD')
-        .replace(/[\u0300-\u036f]/g, '')
-        .replace(/\u0111/g, 'dj')
-        .replace(/\u0110/g, 'Dj')
-        .toLowerCase()
-        .trim();
+function baseOperators(kind, hasOptions) {
+    const accepted = ALLOWED_OPERATORS[kind];
+    return accepted.filter((value) => hasOptions ? value === MatchModeCodes.In : value !== MatchModeCodes.In);
+}
+function toOperatorOptions(kind, operators) {
+    return operators.map((value) => ({
+        value,
+        labelKey: OPERATOR_WORDS[kind][value]?.pickerKey ?? value,
+    }));
 }
 /**
- * The visible home of every applied constraint. This is what licenses a hidden column keeping its
- * filter: the header is no longer the only place a filter can be seen, so hiding a column stops
- * meaning "silently drop what it was filtering by".
- *
- * Everything drawn here comes from `applied()`, never from a draft — a chip over a half-typed
- * value would repeat the mistake the header's filter icon shipped, claiming the grid is narrowed
- * while it still shows every row.
+ * 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.
  */
-class SpiderlyFilterBarComponent {
-    constructor() {
-        this.filters = input.required();
-        /** The current query's row count, supplied by whoever owns the query. Null hides the counter. */
-        this.totalRecords = input(null);
-        /**
-         * What the grid is ordered by, in priority order and already LABELLED — the bar knows nothing
-         * about columns, so whoever owns the sort resolves the names.
-         */
-        this.sort = input([]);
-        /**
-         * What the picker offers, labelled by the owner — every sortable column, HIDDEN ones
-         * included (their ordering is otherwise unreachable, which is the trap the picker closes).
-         * Empty keeps the chip read-only and the picker off.
-         */
-        this.sortOptions = input([]);
-        /** Whether the grid already sits on its default ordering — gates the reset row, nothing else. */
-        this.sortIsDefault = input(true);
-        /** Asked for, never done here — see the button's comment. */
-        this.clearAll = output();
-        /** A single-sort ask. Multi-sort stays a header gesture (ctrl-click); the picker replaces. */
-        this.sortPick = output();
-        /** Back to the owner's default ordering — the owner knows what that resolves to, not the bar. */
-        this.sortReset = output();
-        this.transloco = inject(TranslocoService);
-        /** For the chip's date wording — the same locale mechanism the table's cells format with. */
-        this.locale = inject(LOCALE_ID);
-        /**
-         * Controls a consumer projected for specific filters, collected by whoever hosts this bar. A
-         * filter with no template keeps the control the bar draws for its kind, so a table opts in one
-         * filter at a time.
-         */
-        this.controlTemplates = input(undefined);
-        this.isAddOpen = signal(false);
-        this.isSortOpen = signal(false);
-        /** Cleared when the popover closes, so reopening never starts inside someone's old query. */
-        this.addSearch = signal('');
-        /** The filter whose control is open. One at a time: the bar edits, it is not a form. */
-        this.editing = signal(null);
-        /**
-         * `addable` narrowed by the search box. Matching is unaccented and case-folded because that is
-         * how the label gets typed: "drzava" for "Država" on any keyboard without a Serbian layout. The
-         * backend's own product search is unaccented for the same reason.
-         */
-        this.offered = computed(() => {
-            const needle = foldForSearch(this.addSearch());
-            if (!needle)
-                return this.addable();
-            return this.addable().filter((option) => foldForSearch(option.label).includes(needle));
-        });
-        /**
-         * What "+ Filter" offers: every declared filter that is not already on the bar. Sourced from the
-         * DEFINITIONS, so a filter reaches this list whether or not it has a column, and whether or not
-         * that column is visible. That is the whole reason the bar exists.
-         *
-         * `offered: false` filters stay out — they have a dedicated control of their own on the page
-         * (PACMS's order search box), so the generic entry point would give one question two homes.
-         * Their chips still render: the applied list above reads no such flag.
-         */
-        this.addable = computed(() => {
-            const onBar = new Set(this.filters().applied().map((chip) => chip.id));
-            return Object.entries(this.filters().definitions)
-                .filter(([id, definition]) => !onBar.has(id) && definition.offered !== false)
-                .map(([id, definition]) => ({ id, ...definition }));
-        });
-        /**
-         * The menu's rows: each option decorated with its ACTIVE direction's arrow (any key, not
-         * just the primary), or null. A `computed`, not a per-row method call in the binding — the
-         * popover's content is projected, so it change-detects even while closed, and a `find` per
-         * option per pass is exactly what `operatorChoices` documents against.
-         */
-        this.sortRows = computed(() => {
-            const active = new Map(this.sort().map((key) => [key.field, key.descending]));
-            return this.sortOptions().map((option) => {
-                const descending = active.get(option.field);
-                return {
-                    ...option,
-                    arrow: descending == null ? null : descending ? '↓' : '↑',
-                };
-            });
-        });
-        /**
-         * The open editor's operator options, already translated — p-select takes labels, not keys.
-         *
+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
+ * `Equals` — a date equality against a TIMESTAMP matches only the row written in that exact
+ * second, and answers with an empty grid rather than an error (PACMS ran into this on all three
+ * of its date columns, Filip 2026-08-28).
+ */
+const DEFAULT_OPERATOR = {
+    text: MatchModeCodes.Contains,
+    number: MatchModeCodes.Equals,
+    boolean: MatchModeCodes.Equals,
+    date: MatchModeCodes.GreaterThan,
+};
+function textFilter(config) {
+    return {
+        kind: 'text',
+        label: config.label,
+        operators: config.operators,
+        offered: config.offered,
+    };
+}
+/**
+ * Only a NUMBER filter accepts options, and the asymmetry is forced rather than chosen: options
+ * mean `In`, and `In` is the one operator ALLOWED_OPERATORS grants to numbers alone — because the
+ * generated paginator answers it with InvalidMatchMode on a string column. A text pick-list used
+ * to type-check and then throw at the first `set`.
+ */
+function numberFilter(config) {
+    return {
+        kind: 'number',
+        label: config.label,
+        options: config.options,
+        operators: config.operators,
+        offered: config.offered,
+    };
+}
+function booleanFilter(config) {
+    return {
+        kind: 'boolean',
+        label: config.label,
+        operators: config.operators,
+        offered: config.offered,
+    };
+}
+function dateFilter(config) {
+    return {
+        kind: 'date',
+        label: config.label,
+        operators: config.operators,
+        offered: config.offered,
+    };
+}
+/** The shape `Date.toJSON` writes, which is the only value here JSON cannot round-trip itself. */
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+function reviveValue(value) {
+    if (typeof value === 'string' && ISO_DATE.test(value))
+        return new Date(value);
+    if (Array.isArray(value))
+        return value.map(reviveValue);
+    return value;
+}
+/**
+ * A blanked value is NOT a constraint. `contains ''` matches every row, so emitting one would
+ * narrow nothing while the bar claims the grid is filtered.
+ */
+function isBlank(value) {
+    if (value === null || value === undefined)
+        return true;
+    if (typeof value === 'string')
+        return value.trim() === '';
+    if (Array.isArray(value))
+        return value.length === 0;
+    // A half-typed datepicker yields an Invalid Date, which JSON.stringify writes as `null`.
+    if (value instanceof Date)
+        return Number.isNaN(value.getTime());
+    return false;
+}
+/**
+ * Whether two constraint values are the same QUESTION. Identity is not it: every `set` builds a
+ * fresh draft, a multiselect hands back a fresh array per change, and two Dates at one instant
+ * are one constraint. This is what `commit` bails on, so a paste-over-itself or a double Apply
+ * cannot spend a request — the rule PACMS's order list used to hand-roll as `lastCommittedTerm`.
+ */
+function valueEquals(a, b) {
+    if (a === b)
+        return true;
+    if (a instanceof Date && b instanceof Date)
+        return a.getTime() === b.getTime();
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((item, i) => valueEquals(item, b[i]));
+    }
+    return false;
+}
+function constraintEquals(a, b) {
+    return a != null && a.operator === b.operator && valueEquals(a.value, b.value);
+}
+/**
+ * The filter engine. It knows nothing about columns: a filter has an id, a value type and a
+ * constraint, and that is the entire vocabulary.
+ */
+function createFilterStore(definitions) {
+    // Per-filter offered operators, resolved ONCE per declaration — so an invalid narrowing is
+    // said once, not on every editor open — and re-resolved only where the inputs can actually
+    // change: `setOptions`, because options' PRESENCE flips a filter between pick-list (`In`) and
+    // plain operators. A per-store Map rather than the module-level WeakMap this first shipped
+    // as: that memo was keyed on a definition object consumers mutate, so late-filled options
+    // could freeze a filter's operators at the wrong answer.
+    const resolveOffered = (id) => {
+        const definition = definitions[id];
+        const base = baseOperators(definition.kind, definition.options != null);
+        let codes = base;
+        if (definition.operators?.length) {
+            const survivors = definition.operators.filter((operator) => base.includes(operator));
+            // Same polarity as the column path's computeMatchModes: a bad entry is dropped and said
+            // out loud, and a narrowing that leaves nothing falls back to the full list — an editor
+            // with no operators would be unusable, which is worse than an unwanted one. Mostly
+            // unreachable now that FilterConfig types `operators` per kind; kept for dynamically
+            // built arrays.
+            if (survivors.length < definition.operators.length) {
+                console.error(`Filter '${definition.label}' narrows to operators its ${definition.kind} kind does not ` +
+                    `offer (${definition.operators.join(', ')}; offered: ${base.join(', ')}). ` +
+                    `Unsupported entries are ignored${survivors.length ? '' : '; falling back to the full list'}.`);
+            }
+            codes = survivors.length ? survivors : base;
+        }
+        return { codes, options: toOperatorOptions(definition.kind, codes) };
+    };
+    const offered = new Map();
+    for (const id of Object.keys(definitions)) {
+        offered.set(id, resolveOffered(id));
+    }
+    /**
+     * The operator applied when nobody picked one. Options mean `In`, whatever the kind's default;
+     * a narrowed filter defaults to its FIRST declared operator.
+     */
+    const defaultOperatorFor = (id) => {
+        const definition = definitions[id];
+        if (definition.options != null)
+            return MatchModeCodes.In;
+        return definition.operators?.length
+            ? offered.get(id).codes[0]
+            : DEFAULT_OPERATOR[definition.kind];
+    };
+    // Two stores, and the split is the whole point: `set` writes a DRAFT, `commit` publishes it.
+    // A chip drawn off a draft would repeat the mistake the header's filter icon already shipped —
+    // claiming the grid is narrowed on the first keystroke. Controls that apply on change
+    // (multiselect, boolean, date) call both at once; a text box commits on Enter or blur.
+    const drafts = signal(new Map());
+    const writeDraft = (id, constraint) => {
+        const next = new Map(drafts());
+        if (constraint === null)
+            next.delete(id);
+        else
+            next.set(id, constraint);
+        drafts.set(next);
+    };
+    const committed = signal(new Map());
+    const applied = computed(() => [...committed()].map(([id, constraint]) => ({
+        id: id,
+        label: definitions[id].label,
+        kind: definitions[id].kind,
+        operator: constraint.operator,
+        operatorPhraseKey: OPERATOR_WORDS[definitions[id].kind][constraint.operator]?.phraseKey ??
+            constraint.operator,
+        value: constraint.value,
+    })));
+    const store = {
+        definitions,
+        applied,
+        /**
+         * A handle bound to one filter. This is the PLACEMENT api: it needs nothing from the component
+         * tree, so the same filter can be driven from the bar, from a header cell, or from a drawer
+         * rendered at app root. `value` is the DRAFT — a control shows what was typed, not what was
+         * applied; `applied()` is the other question and the bar asks that one.
+         */
+        get(id) {
+            return {
+                id: id,
+                label: definitions[id].label,
+                kind: definitions[id].kind,
+                value: computed(() => drafts().get(id)?.value),
+                operator: computed(() => drafts().get(id)?.operator),
+                // Getters, not snapshots: options can land AFTER a handle is taken — the bar's editor
+                // holds one for the life of the popover, and PACMS fills its lookups asynchronously —
+                // and a snapshot left an already-open pick-list empty until it was reopened. The
+                // operator list rides along, since setOptions can flip it to `In`.
+                get operators() {
+                    return offered.get(id).options;
+                },
+                get defaultOperator() {
+                    return defaultOperatorFor(id);
+                },
+                get options() {
+                    return definitions[id].options;
+                },
+                set: (constraint) => store.set(id, constraint),
+                commit: () => store.commit(id),
+                reset: () => store.reset(id),
+            };
+        },
+        /**
+         * The ONE seam for choices that arrive after the store is built (PACMS fills its pick-lists
+         * from lookups that race a deploy). Never write `definitions[id].options` by hand: options'
+         * PRESENCE is what makes a filter a pick-list, so the setter also re-resolves the offered
+         * operators — a hand write would leave a late-filled filter offering `Equals` on a control
+         * that emits a list.
+         */
+        setOptions(id, options) {
+            definitions[id].options = options;
+            offered.set(id, resolveOffered(id));
+        },
+        set(id, constraint) {
+            const kind = definitions[id].kind;
+            // Throws rather than logging and ignoring, which is what `computeMatchModes` does for a
+            // column's OFFERED match modes. Different stakes: that one narrows a dropdown, so a bad
+            // entry merely fails to show, while this one assembles a QUERY — dropping it silently would
+            // leave the operator looking at unfiltered rows believing they are filtered.
+            if (!ALLOWED_OPERATORS[kind].includes(constraint.operator)) {
+                throw new Error(`Filter '${String(id)}' is ${kind}, which does not accept the '${constraint.operator}' ` +
+                    `operator (allowed: ${ALLOWED_OPERATORS[kind].join(', ')}). The generated paginator ` +
+                    `answers an unsupported match mode with InvalidMatchMode.`);
+            }
+            writeDraft(id, constraint);
+        },
+        /**
+         * `set` + `commit` in one breath — the shape every PROGRAMMATIC write takes (a view's
+         * `apply`, the sheet flow). The split API stays for controls, where draft-on-type /
+         * publish-on-Apply is the point; but a bare `set` whose `commit` is forgotten (or written
+         * with the wrong id — the pair repeats the string twice) fails silently: the draft is
+         * written, nothing is published, and a view narrows by nothing under a labelled tab.
+         */
+        setAndCommit(id, constraint) {
+            store.set(id, constraint);
+            store.commit(id);
+        },
+        /**
+         * Publishes the draft. A blanked draft REMOVES the constraint rather than committing an empty
+         * one, so `applied()` and the payload agree: no chip, no key, no `contains ''`.
+         */
+        commit(id) {
+            const draft = drafts().get(id);
+            const current = committed();
+            const shouldRemove = draft === undefined || isBlank(draft.value);
+            // A new Map is a new identity even with identical contents, and everything downstream
+            // reacts to identity — so a no-op commit would spend a request. The bail compares the
+            // CONSTRAINT, not the draft object: every set() builds a fresh draft, and the case that
+            // matters is an identical value re-committed (see valueEquals).
+            if (shouldRemove ? !current.has(id) : constraintEquals(current.get(id), draft))
+                return;
+            const next = new Map(current);
+            if (shouldRemove)
+                next.delete(id);
+            else
+                next.set(id, draft);
+            committed.set(next);
+        },
+        /**
+         * The chip's `x`. Drops the DRAFT as well as the committed constraint: a surviving draft
+         * leaves the control still showing the cleared text, and the next commit would restore a
+         * filter nobody re-typed.
+         */
+        reset(id) {
+            if (drafts().has(id))
+                writeDraft(id, null);
+            if (!committed().has(id))
+                return;
+            const next = new Map(committed());
+            next.delete(id);
+            committed.set(next);
+        },
+        /**
+         * The applied set, plain enough to store. Drafts are deliberately NOT included: a half-typed
+         * value is not a state anyone should come back to, and the bar's whole claim is that what it
+         * shows is what narrows the grid.
+         */
+        snapshot() {
+            const snapshot = {};
+            for (const [id, constraint] of committed()) {
+                snapshot[id] = {
+                    operator: constraint.operator,
+                    value: constraint.value,
+                };
+            }
+            return snapshot;
+        },
+        /**
+         * Replaces the applied set. The drafts are written too, so reopening a restored chip shows
+         * the value it is filtering by rather than an empty control.
+         *
+         * Ids the store no longer declares are dropped rather than carried: a filter removed from the
+         * declaration in a later release would otherwise ride every request from anyone whose storage
+         * still held it, with no chip able to name it and no way to clear it from the UI.
+         */
+        restore(snapshot) {
+            const next = new Map();
+            for (const [id, constraint] of Object.entries(snapshot ?? {})) {
+                if (!(id in definitions))
+                    continue;
+                next.set(id, {
+                    operator: constraint.operator,
+                    value: reviveValue(constraint.value),
+                });
+            }
+            drafts.set(new Map(next));
+            committed.set(next);
+        },
+        /** The bar's "Clear all". `reset` for every filter, drafts included. */
+        clear() {
+            if (drafts().size > 0)
+                drafts.set(new Map());
+            if (committed().size > 0)
+                committed.set(new Map());
+        },
+        /** The `filters` half of `Filter` — what the generated paginator reads. */
+        toFilterPayload() {
+            const payload = {};
+            for (const [id, constraint] of committed()) {
+                payload[id] = [
+                    { matchMode: constraint.operator, value: constraint.value },
+                ];
+            }
+            return payload;
+        },
+    };
+    return store;
+}
+
+/**
+ * Renders the editor for ONE filter of a `spiderly-data-table`'s bar, replacing the control the
+ * bar would have drawn for that filter's kind. Bind it to the filter's id; filters with no
+ * matching template keep the built-in control, so a table opts in one filter at a time.
+ *
+ * This is the narrow job the directive has. Placing a filter ANYWHERE else — a drawer, a modal,
+ * a header cell — needs no directive at all: `store.get(id)` returns the same handle and depends
+ * on nothing in the component tree, which is why the store is the consumer's to own.
+ */
+class SpiderlyFilterTemplateDirective {
+    constructor(template) {
+        this.template = template;
+    }
+    /**
+     * Without this the `let-` variable is `any` at every consumer, however well the context is
+     * declared — a directive's injected `TemplateRef<C>` never reaches the template that declares
+     * it. Same mechanism as `SpiderlyCellTemplateDirective`.
+     */
+    static ngTemplateContextGuard(dir, ctx) {
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: SpiderlyFilterTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.13", type: SpiderlyFilterTemplateDirective, isStandalone: true, selector: "ng-template[spiderlyFilterTemplate]", inputs: { filterId: ["spiderlyFilterTemplate", "filterId"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: SpiderlyFilterTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ng-template[spiderlyFilterTemplate]',
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }], propDecorators: { filterId: [{
+                type: Input,
+                args: ['spiderlyFilterTemplate']
+            }] } });
+
+/** One option's word for one value — the honest raw value when no option matches (failed lookup). */
+function spellOptionValue(options, value) {
+    return String(options?.find((option) => option.value === value)?.label ?? value);
+}
+/**
+ * Lowercased and stripped of diacritics for matching. NFD decomposition handles č/ć/š/ž, but NOT
+ * đ — it is its own letter (U+0111), not a d carrying a mark, so it decomposes to nothing and has
+ * to be mapped by hand.
+ *
+ * It maps to "dj", which is what the rest of this workspace already does (pa-cms's
+ * `normalizePlaceQuery` and `toAscii`, the backend's `PlaceNameNormalizer`) and what someone
+ * without a Serbian layout actually types. Mapping it to "d" — as this first shipped — folds
+ * "Đorđe" to "dorde", so typing "djordje" finds nothing: the exact case the comment claimed to
+ * fix, and one no spec covered because the test used "drzava", which has no đ in it.
+ */
+function foldForSearch(value) {
+    return value
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/\u0111/g, 'dj')
+        .replace(/\u0110/g, 'Dj')
+        .toLowerCase()
+        .trim();
+}
+/**
+ * The visible home of every applied constraint. This is what licenses a hidden column keeping its
+ * filter: the header is no longer the only place a filter can be seen, so hiding a column stops
+ * meaning "silently drop what it was filtering by".
+ *
+ * Everything drawn here comes from `applied()`, never from a draft — a chip over a half-typed
+ * value would repeat the mistake the header's filter icon shipped, claiming the grid is narrowed
+ * while it still shows every row.
+ */
+class SpiderlyFilterBarComponent {
+    constructor() {
+        this.filters = input.required();
+        /** The current query's row count, supplied by whoever owns the query. Null hides the counter. */
+        this.totalRecords = input(null);
+        /**
+         * What the grid is ordered by, in priority order and already LABELLED — the bar knows nothing
+         * about columns, so whoever owns the sort resolves the names.
+         */
+        this.sort = input([]);
+        /**
+         * What the picker offers, labelled by the owner — every sortable column, HIDDEN ones
+         * included (their ordering is otherwise unreachable, which is the trap the picker closes).
+         * Empty keeps the chip read-only and the picker off.
+         */
+        this.sortOptions = input([]);
+        /** Whether the grid already sits on its default ordering — gates the reset row, nothing else. */
+        this.sortIsDefault = input(true);
+        /** Asked for, never done here — see the button's comment. */
+        this.clearAll = output();
+        /** A single-sort ask. Multi-sort stays a header gesture (ctrl-click); the picker replaces. */
+        this.sortPick = output();
+        /** Back to the owner's default ordering — the owner knows what that resolves to, not the bar. */
+        this.sortReset = output();
+        this.transloco = inject(TranslocoService);
+        /** For the chip's date wording — the same locale mechanism the table's cells format with. */
+        this.locale = inject(LOCALE_ID);
+        /**
+         * Controls a consumer projected for specific filters, collected by whoever hosts this bar. A
+         * filter with no template keeps the control the bar draws for its kind, so a table opts in one
+         * filter at a time.
+         */
+        this.controlTemplates = input(undefined);
+        this.isAddOpen = signal(false);
+        this.isSortOpen = signal(false);
+        /** Cleared when the popover closes, so reopening never starts inside someone's old query. */
+        this.addSearch = signal('');
+        /** The filter whose control is open. One at a time: the bar edits, it is not a form. */
+        this.editing = signal(null);
+        /**
+         * `addable` narrowed by the search box. Matching is unaccented and case-folded because that is
+         * how the label gets typed: "drzava" for "Država" on any keyboard without a Serbian layout. The
+         * backend's own product search is unaccented for the same reason.
+         */
+        this.offered = computed(() => {
+            const needle = foldForSearch(this.addSearch());
+            if (!needle)
+                return this.addable();
+            return this.addable().filter((option) => foldForSearch(option.label).includes(needle));
+        });
+        /**
+         * What "+ Filter" offers: every declared filter that is not already on the bar. Sourced from the
+         * DEFINITIONS, so a filter reaches this list whether or not it has a column, and whether or not
+         * that column is visible. That is the whole reason the bar exists.
+         *
+         * `offered: false` filters stay out — they have a dedicated control of their own on the page
+         * (PACMS's order search box), so the generic entry point would give one question two homes.
+         * Their chips still render: the applied list above reads no such flag.
+         */
+        this.addable = computed(() => {
+            const onBar = new Set(this.filters().applied().map((chip) => chip.id));
+            return Object.entries(this.filters().definitions)
+                .filter(([id, definition]) => !onBar.has(id) && definition.offered !== false)
+                .map(([id, definition]) => ({ id, ...definition }));
+        });
+        /**
+         * The menu's rows: each option decorated with its ACTIVE direction's arrow (any key, not
+         * just the primary), or null. A `computed`, not a per-row method call in the binding — the
+         * popover's content is projected, so it change-detects even while closed, and a `find` per
+         * option per pass is exactly what `operatorChoices` documents against.
+         */
+        this.sortRows = computed(() => {
+            const active = new Map(this.sort().map((key) => [key.field, key.descending]));
+            return this.sortOptions().map((option) => {
+                const descending = active.get(option.field);
+                return {
+                    ...option,
+                    arrow: descending == null ? null : descending ? '↓' : '↑',
+                };
+            });
+        });
+        /**
+         * The open editor's operator options, already translated — p-select takes labels, not keys.
+         *
          * A `computed`, not a method in the binding: both inputs are fixed for the life of an open
          * editor, and PrimeNG's `Select.options` setter deep-compares whatever it is handed — so a
          * freshly mapped array per change-detection pass paid for a recursive structural compare to
@@ -5501,7 +5956,10 @@ class SpiderlyDataTableComponent {
      * reading exactly the keys they already wrote.
      */
     get viewScope() {
-        return this.activeViewId ? `:${this.activeViewId}` : '';
+        return this.viewScopeOf(this.activeViewId);
+    }
+    viewScopeOf(viewId) {
+        return viewId ? `:${viewId}` : '';
     }
     /**
      * Where the applied filters live. Follows `stateStorage` rather than the layout's always-local
@@ -5511,8 +5969,11 @@ class SpiderlyDataTableComponent {
      * durable preference like a column's width.
      */
     get filtersStateKey() {
+        return this.filtersStateKeyOf(this.activeViewId);
+    }
+    filtersStateKeyOf(viewId) {
         return this.resolvedStateKey
-            ? `${this.resolvedStateKey}${this.viewScope}:filters`
+            ? `${this.resolvedStateKey}${this.viewScopeOf(viewId)}:filters`
             : null;
     }
     get filterStorage() {
@@ -5605,17 +6066,18 @@ class SpiderlyDataTableComponent {
      * 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.
+     *
+     * `viewFilterPayload` passes a scratch store and another view's key, to read what entering
+     * that view would send.
      */
-    enterViewFilters(view, semantics) {
-        if (!this.filters)
+    enterViewFilters(view, semantics, store = this.filters, key = this.filtersStateKey) {
+        if (!store)
             return;
-        const stored = !view?.transient && this.filtersStateKey
-            ? readStoredJson(this.filterStorage, this.filtersStateKey)
-            : null;
+        const stored = !view?.transient && key ? readStoredJson(this.filterStorage, key) : null;
         if (stored)
-            this.filters.restore(stored);
+            store.restore(stored);
         else if (view?.transient || semantics === 'click')
-            view?.apply?.(this.filters);
+            view?.apply?.(store);
     }
     get layoutStateKey() {
         return this.resolvedStateKey
@@ -6035,6 +6497,39 @@ class SpiderlyDataTableComponent {
             this.refetchFromFirstPage();
         }
     }
+    /**
+     * The `filters` payload a view's own list request carries — the same shape the store's
+     * `toFilterPayload()` emits — so a consumer's count query can narrow each view by the bar
+     * filters the operator saved on it, and a `TableView.count` stays the number of rows that tab
+     * lists: on screen for the active view, after a click for the others (spiderly#439).
+     *
+     * - The ACTIVE view answers with the live filters. Not with what a click would enter: clicking
+     *   the active tab re-asks its question when the operator has cleared the bar, but the list on
+     *   screen, and so its count, has not.
+     * - Any other view answers with what a click would enter (`enterViewFilters`): the filters
+     *   saved on it, else its `apply` — always `apply` for a transient view. That runs on a scratch
+     *   `createFilterStore` of the same declarations, so nothing switches, persists or re-queries.
+     *   Untracked: the scratch store's signal writes would otherwise make a read inside a
+     *   `computed` throw NG0600.
+     *
+     * `{}` on a table without `[filters]`, whose requests carry none; `null` for an id that is not
+     * in `[views]`.
+     */
+    viewFilterPayload(viewId) {
+        const view = this.viewById(viewId);
+        if (!view)
+            return null;
+        if (!this.filters)
+            return {};
+        if (view.id === this.activeViewId)
+            return this.filters.toFilterPayload();
+        const definitions = this.filters.definitions;
+        return untracked(() => {
+            const scratch = createFilterStore(definitions);
+            this.enterViewFilters(view, 'click', scratch, this.filtersStateKeyOf(view.id));
+            return scratch.toFilterPayload();
+        });
+    }
     /**
      * The filter this column stands for. Defaults to the column's own `field`, because a store id
      * IS a backend property name — `toFilterPayload` emits it straight into `Filter.filters`. So
@@ -6933,490 +7428,35 @@ class Action {
 class Column {
     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;
-        this.showTime = showTime;
-        this.decimalPlaces = decimalPlaces;
-        this.sortable = sortable;
-        this.visible = visible;
-        this.lockVisible = lockVisible;
-        this.width = width;
-        this.onCellClick = onCellClick;
-    }
-}
-class RowClickEvent {
-    constructor({ index, id, additionalIndexes, } = {}) {
-        this.index = index;
-        this.id = id;
-        this.additionalIndexes = additionalIndexes;
-    }
-}
-class AllClickEvent {
-    constructor({ checked, additionalIndexes, } = {}) {
-        this.checked = checked;
-        this.additionalIndexes = additionalIndexes;
-    }
-}
-
-var MatchModeCodes;
-(function (MatchModeCodes) {
-    MatchModeCodes["StartsWith"] = "startsWith";
-    MatchModeCodes["Contains"] = "contains";
-    MatchModeCodes["Equals"] = "equals";
-    MatchModeCodes["LessThan"] = "lessThan";
-    MatchModeCodes["GreaterThan"] = "greaterThan";
-    MatchModeCodes["In"] = "in";
-})(MatchModeCodes || (MatchModeCodes = {}));
-
-/**
- * What each value type may be asked — the ONE operator table, mirroring what the generated
- * 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 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).
- */
-const ALLOWED_OPERATORS = {
-    text: [
-        MatchModeCodes.StartsWith,
-        MatchModeCodes.Contains,
-        MatchModeCodes.Equals,
-    ],
-    number: [
-        MatchModeCodes.Equals,
-        MatchModeCodes.LessThan,
-        MatchModeCodes.GreaterThan,
-        MatchModeCodes.In,
-    ],
-    boolean: [MatchModeCodes.Equals],
-    date: [
-        MatchModeCodes.Equals,
-        MatchModeCodes.LessThan,
-        MatchModeCodes.GreaterThan,
-    ],
-};
-
-const OPERATOR_WORDS = {
-    text: {
-        [MatchModeCodes.StartsWith]: {
-            pickerKey: 'StartsWith',
-            phraseKey: 'FilterChipStartsWith',
-        },
-        [MatchModeCodes.Contains]: {
-            pickerKey: 'Contains',
-            phraseKey: 'FilterChipContains',
-        },
-        [MatchModeCodes.Equals]: {
-            pickerKey: 'Equals',
-            phraseKey: 'FilterChipEquals',
-        },
-        // No `In` for text: ALLOWED_OPERATORS.text does not carry it, so the entry was unreachable —
-        // and it made `textFilter({ options })` look supported when the store throws on it.
-    },
-    number: {
-        [MatchModeCodes.Equals]: {
-            pickerKey: 'Equals',
-            phraseKey: 'FilterChipEquals',
-        },
-        [MatchModeCodes.GreaterThan]: {
-            pickerKey: 'MoreThan',
-            phraseKey: 'FilterChipGreaterThan',
-        },
-        [MatchModeCodes.LessThan]: {
-            pickerKey: 'LessThan',
-            phraseKey: 'FilterChipLessThan',
-        },
-        // The picker never renders for a pick-list (one operator), but the CHIP always does.
-        [MatchModeCodes.In]: { pickerKey: 'In', phraseKey: 'FilterChipIn' },
-    },
-    boolean: {
-        [MatchModeCodes.Equals]: {
-            pickerKey: 'Equals',
-            phraseKey: 'FilterChipEquals',
-        },
-    },
-    date: {
-        [MatchModeCodes.Equals]: {
-            pickerKey: 'OnDate',
-            phraseKey: 'FilterChipEquals',
-        },
-        [MatchModeCodes.LessThan]: {
-            pickerKey: 'DatesBefore',
-            phraseKey: 'FilterChipBefore',
-        },
-        [MatchModeCodes.GreaterThan]: {
-            pickerKey: 'DatesAfter',
-            phraseKey: 'FilterChipAfter',
-        },
-    },
-};
-/**
- * `In` and options are the same fact seen from two sides: `In` needs a list of values, and the
- * editor only draws one when the filter declares options. So options mean `In` and nothing else,
- * and their absence rules `In` out — offering it on a plain number filter would hand the
- * operator a mode with no control behind it.
- *
- * Widened first: the per-kind tuples are literal, so `boolean`'s `[Equals]` makes the `In`
- * comparison a "no overlap" error rather than an empty result.
- */
-function baseOperators(kind, hasOptions) {
-    const accepted = ALLOWED_OPERATORS[kind];
-    return accepted.filter((value) => hasOptions ? value === MatchModeCodes.In : value !== MatchModeCodes.In);
-}
-function toOperatorOptions(kind, operators) {
-    return operators.map((value) => ({
-        value,
-        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
- * `Equals` — a date equality against a TIMESTAMP matches only the row written in that exact
- * second, and answers with an empty grid rather than an error (PACMS ran into this on all three
- * of its date columns, Filip 2026-08-28).
- */
-const DEFAULT_OPERATOR = {
-    text: MatchModeCodes.Contains,
-    number: MatchModeCodes.Equals,
-    boolean: MatchModeCodes.Equals,
-    date: MatchModeCodes.GreaterThan,
-};
-function textFilter(config) {
-    return {
-        kind: 'text',
-        label: config.label,
-        operators: config.operators,
-        offered: config.offered,
-    };
-}
-/**
- * Only a NUMBER filter accepts options, and the asymmetry is forced rather than chosen: options
- * mean `In`, and `In` is the one operator ALLOWED_OPERATORS grants to numbers alone — because the
- * generated paginator answers it with InvalidMatchMode on a string column. A text pick-list used
- * to type-check and then throw at the first `set`.
- */
-function numberFilter(config) {
-    return {
-        kind: 'number',
-        label: config.label,
-        options: config.options,
-        operators: config.operators,
-        offered: config.offered,
-    };
-}
-function booleanFilter(config) {
-    return {
-        kind: 'boolean',
-        label: config.label,
-        operators: config.operators,
-        offered: config.offered,
-    };
-}
-function dateFilter(config) {
-    return {
-        kind: 'date',
-        label: config.label,
-        operators: config.operators,
-        offered: config.offered,
-    };
-}
-/** The shape `Date.toJSON` writes, which is the only value here JSON cannot round-trip itself. */
-const ISO_DATE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
-function reviveValue(value) {
-    if (typeof value === 'string' && ISO_DATE.test(value))
-        return new Date(value);
-    if (Array.isArray(value))
-        return value.map(reviveValue);
-    return value;
-}
-/**
- * A blanked value is NOT a constraint. `contains ''` matches every row, so emitting one would
- * narrow nothing while the bar claims the grid is filtered.
- */
-function isBlank(value) {
-    if (value === null || value === undefined)
-        return true;
-    if (typeof value === 'string')
-        return value.trim() === '';
-    if (Array.isArray(value))
-        return value.length === 0;
-    // A half-typed datepicker yields an Invalid Date, which JSON.stringify writes as `null`.
-    if (value instanceof Date)
-        return Number.isNaN(value.getTime());
-    return false;
-}
-/**
- * Whether two constraint values are the same QUESTION. Identity is not it: every `set` builds a
- * fresh draft, a multiselect hands back a fresh array per change, and two Dates at one instant
- * are one constraint. This is what `commit` bails on, so a paste-over-itself or a double Apply
- * cannot spend a request — the rule PACMS's order list used to hand-roll as `lastCommittedTerm`.
- */
-function valueEquals(a, b) {
-    if (a === b)
-        return true;
-    if (a instanceof Date && b instanceof Date)
-        return a.getTime() === b.getTime();
-    if (Array.isArray(a) && Array.isArray(b)) {
-        return a.length === b.length && a.every((item, i) => valueEquals(item, b[i]));
+        this.field = field;
+        this.filterType = filterType;
+        this.filterId = filterId;
+        this.showMatchModes = showMatchModes;
+        this.filterField = filterField;
+        this.dropdownOrMultiselectValues = dropdownOrMultiselectValues;
+        this.actions = actions;
+        this.editable = editable;
+        this.showTime = showTime;
+        this.decimalPlaces = decimalPlaces;
+        this.sortable = sortable;
+        this.visible = visible;
+        this.lockVisible = lockVisible;
+        this.width = width;
+        this.onCellClick = onCellClick;
     }
-    return false;
 }
-function constraintEquals(a, b) {
-    return a != null && a.operator === b.operator && valueEquals(a.value, b.value);
+class RowClickEvent {
+    constructor({ index, id, additionalIndexes, } = {}) {
+        this.index = index;
+        this.id = id;
+        this.additionalIndexes = additionalIndexes;
+    }
 }
-/**
- * The filter engine. It knows nothing about columns: a filter has an id, a value type and a
- * constraint, and that is the entire vocabulary.
- */
-function createFilterStore(definitions) {
-    // Per-filter offered operators, resolved ONCE per declaration — so an invalid narrowing is
-    // said once, not on every editor open — and re-resolved only where the inputs can actually
-    // change: `setOptions`, because options' PRESENCE flips a filter between pick-list (`In`) and
-    // plain operators. A per-store Map rather than the module-level WeakMap this first shipped
-    // as: that memo was keyed on a definition object consumers mutate, so late-filled options
-    // could freeze a filter's operators at the wrong answer.
-    const resolveOffered = (id) => {
-        const definition = definitions[id];
-        const base = baseOperators(definition.kind, definition.options != null);
-        let codes = base;
-        if (definition.operators?.length) {
-            const survivors = definition.operators.filter((operator) => base.includes(operator));
-            // Same polarity as the column path's computeMatchModes: a bad entry is dropped and said
-            // out loud, and a narrowing that leaves nothing falls back to the full list — an editor
-            // with no operators would be unusable, which is worse than an unwanted one. Mostly
-            // unreachable now that FilterConfig types `operators` per kind; kept for dynamically
-            // built arrays.
-            if (survivors.length < definition.operators.length) {
-                console.error(`Filter '${definition.label}' narrows to operators its ${definition.kind} kind does not ` +
-                    `offer (${definition.operators.join(', ')}; offered: ${base.join(', ')}). ` +
-                    `Unsupported entries are ignored${survivors.length ? '' : '; falling back to the full list'}.`);
-            }
-            codes = survivors.length ? survivors : base;
-        }
-        return { codes, options: toOperatorOptions(definition.kind, codes) };
-    };
-    const offered = new Map();
-    for (const id of Object.keys(definitions)) {
-        offered.set(id, resolveOffered(id));
+class AllClickEvent {
+    constructor({ checked, additionalIndexes, } = {}) {
+        this.checked = checked;
+        this.additionalIndexes = additionalIndexes;
     }
-    /**
-     * The operator applied when nobody picked one. Options mean `In`, whatever the kind's default;
-     * a narrowed filter defaults to its FIRST declared operator.
-     */
-    const defaultOperatorFor = (id) => {
-        const definition = definitions[id];
-        if (definition.options != null)
-            return MatchModeCodes.In;
-        return definition.operators?.length
-            ? offered.get(id).codes[0]
-            : DEFAULT_OPERATOR[definition.kind];
-    };
-    // Two stores, and the split is the whole point: `set` writes a DRAFT, `commit` publishes it.
-    // A chip drawn off a draft would repeat the mistake the header's filter icon already shipped —
-    // claiming the grid is narrowed on the first keystroke. Controls that apply on change
-    // (multiselect, boolean, date) call both at once; a text box commits on Enter or blur.
-    const drafts = signal(new Map());
-    const writeDraft = (id, constraint) => {
-        const next = new Map(drafts());
-        if (constraint === null)
-            next.delete(id);
-        else
-            next.set(id, constraint);
-        drafts.set(next);
-    };
-    const committed = signal(new Map());
-    const applied = computed(() => [...committed()].map(([id, constraint]) => ({
-        id: id,
-        label: definitions[id].label,
-        kind: definitions[id].kind,
-        operator: constraint.operator,
-        operatorPhraseKey: OPERATOR_WORDS[definitions[id].kind][constraint.operator]?.phraseKey ??
-            constraint.operator,
-        value: constraint.value,
-    })));
-    const store = {
-        definitions,
-        applied,
-        /**
-         * A handle bound to one filter. This is the PLACEMENT api: it needs nothing from the component
-         * tree, so the same filter can be driven from the bar, from a header cell, or from a drawer
-         * rendered at app root. `value` is the DRAFT — a control shows what was typed, not what was
-         * applied; `applied()` is the other question and the bar asks that one.
-         */
-        get(id) {
-            return {
-                id: id,
-                label: definitions[id].label,
-                kind: definitions[id].kind,
-                value: computed(() => drafts().get(id)?.value),
-                operator: computed(() => drafts().get(id)?.operator),
-                // Getters, not snapshots: options can land AFTER a handle is taken — the bar's editor
-                // holds one for the life of the popover, and PACMS fills its lookups asynchronously —
-                // and a snapshot left an already-open pick-list empty until it was reopened. The
-                // operator list rides along, since setOptions can flip it to `In`.
-                get operators() {
-                    return offered.get(id).options;
-                },
-                get defaultOperator() {
-                    return defaultOperatorFor(id);
-                },
-                get options() {
-                    return definitions[id].options;
-                },
-                set: (constraint) => store.set(id, constraint),
-                commit: () => store.commit(id),
-                reset: () => store.reset(id),
-            };
-        },
-        /**
-         * The ONE seam for choices that arrive after the store is built (PACMS fills its pick-lists
-         * from lookups that race a deploy). Never write `definitions[id].options` by hand: options'
-         * PRESENCE is what makes a filter a pick-list, so the setter also re-resolves the offered
-         * operators — a hand write would leave a late-filled filter offering `Equals` on a control
-         * that emits a list.
-         */
-        setOptions(id, options) {
-            definitions[id].options = options;
-            offered.set(id, resolveOffered(id));
-        },
-        set(id, constraint) {
-            const kind = definitions[id].kind;
-            // Throws rather than logging and ignoring, which is what `computeMatchModes` does for a
-            // column's OFFERED match modes. Different stakes: that one narrows a dropdown, so a bad
-            // entry merely fails to show, while this one assembles a QUERY — dropping it silently would
-            // leave the operator looking at unfiltered rows believing they are filtered.
-            if (!ALLOWED_OPERATORS[kind].includes(constraint.operator)) {
-                throw new Error(`Filter '${String(id)}' is ${kind}, which does not accept the '${constraint.operator}' ` +
-                    `operator (allowed: ${ALLOWED_OPERATORS[kind].join(', ')}). The generated paginator ` +
-                    `answers an unsupported match mode with InvalidMatchMode.`);
-            }
-            writeDraft(id, constraint);
-        },
-        /**
-         * `set` + `commit` in one breath — the shape every PROGRAMMATIC write takes (a view's
-         * `apply`, the sheet flow). The split API stays for controls, where draft-on-type /
-         * publish-on-Apply is the point; but a bare `set` whose `commit` is forgotten (or written
-         * with the wrong id — the pair repeats the string twice) fails silently: the draft is
-         * written, nothing is published, and a view narrows by nothing under a labelled tab.
-         */
-        setAndCommit(id, constraint) {
-            store.set(id, constraint);
-            store.commit(id);
-        },
-        /**
-         * Publishes the draft. A blanked draft REMOVES the constraint rather than committing an empty
-         * one, so `applied()` and the payload agree: no chip, no key, no `contains ''`.
-         */
-        commit(id) {
-            const draft = drafts().get(id);
-            const current = committed();
-            const shouldRemove = draft === undefined || isBlank(draft.value);
-            // A new Map is a new identity even with identical contents, and everything downstream
-            // reacts to identity — so a no-op commit would spend a request. The bail compares the
-            // CONSTRAINT, not the draft object: every set() builds a fresh draft, and the case that
-            // matters is an identical value re-committed (see valueEquals).
-            if (shouldRemove ? !current.has(id) : constraintEquals(current.get(id), draft))
-                return;
-            const next = new Map(current);
-            if (shouldRemove)
-                next.delete(id);
-            else
-                next.set(id, draft);
-            committed.set(next);
-        },
-        /**
-         * The chip's `x`. Drops the DRAFT as well as the committed constraint: a surviving draft
-         * leaves the control still showing the cleared text, and the next commit would restore a
-         * filter nobody re-typed.
-         */
-        reset(id) {
-            if (drafts().has(id))
-                writeDraft(id, null);
-            if (!committed().has(id))
-                return;
-            const next = new Map(committed());
-            next.delete(id);
-            committed.set(next);
-        },
-        /**
-         * The applied set, plain enough to store. Drafts are deliberately NOT included: a half-typed
-         * value is not a state anyone should come back to, and the bar's whole claim is that what it
-         * shows is what narrows the grid.
-         */
-        snapshot() {
-            const snapshot = {};
-            for (const [id, constraint] of committed()) {
-                snapshot[id] = {
-                    operator: constraint.operator,
-                    value: constraint.value,
-                };
-            }
-            return snapshot;
-        },
-        /**
-         * Replaces the applied set. The drafts are written too, so reopening a restored chip shows
-         * the value it is filtering by rather than an empty control.
-         *
-         * Ids the store no longer declares are dropped rather than carried: a filter removed from the
-         * declaration in a later release would otherwise ride every request from anyone whose storage
-         * still held it, with no chip able to name it and no way to clear it from the UI.
-         */
-        restore(snapshot) {
-            const next = new Map();
-            for (const [id, constraint] of Object.entries(snapshot ?? {})) {
-                if (!(id in definitions))
-                    continue;
-                next.set(id, {
-                    operator: constraint.operator,
-                    value: reviveValue(constraint.value),
-                });
-            }
-            drafts.set(new Map(next));
-            committed.set(next);
-        },
-        /** The bar's "Clear all". `reset` for every filter, drafts included. */
-        clear() {
-            if (drafts().size > 0)
-                drafts.set(new Map());
-            if (committed().size > 0)
-                committed.set(new Map());
-        },
-        /** The `filters` half of `Filter` — what the generated paginator reads. */
-        toFilterPayload() {
-            const payload = {};
-            for (const [id, constraint] of committed()) {
-                payload[id] = [
-                    { matchMode: constraint.operator, value: constraint.value },
-                ];
-            }
-            return payload;
-        },
-    };
-    return store;
 }
 
 class SpiderlyDataViewComponent {