spiderly 19.13.0 → 19.15.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,6 +4024,461 @@ 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 = {}));
+
+/**
+ * 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]));
+    }
+    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
@@ -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
@@ -6945,478 +7440,23 @@ class Column {
         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.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 {
@@ -8070,24 +8110,6 @@ function authInitializer(authService, platformId) {
     };
 }
 
-class SpiderlyTranslocoLoader {
-    constructor(http, config) {
-        this.http = http;
-        this.config = config;
-    }
-    getTranslation(lang) {
-        return this.http.get(`${this.config.frontendUrl}/assets/i18n/${lang}.json`);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: SpiderlyTranslocoLoader, deps: [{ token: i1$2.HttpClient }, { token: ConfigServiceBase }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: SpiderlyTranslocoLoader, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: SpiderlyTranslocoLoader, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: i1$2.HttpClient }, { type: ConfigServiceBase }] });
-
 class SpiderlyTemplateTypeDirective {
     static ngTemplateContextGuard(dir, ctx) {
         return true;
@@ -8112,5 +8134,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, operatorOptionsForKind, 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, 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