@aglyn/shared-ui-jsx 1.0.0-beta.143

package/src/lib/const/list-filter.js

@@ -0,0 +1,409 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { getGridBooleanOperators, getGridDateOperators, getGridNumericOperators, getGridStringOperators } from "@mui/x-data-grid";
+/** The empty-operators a field can honestly offer. See `presence`. */ const emptyOperators = (field)=>{
+    var _field_presence;
+    switch((_field_presence = field.presence) != null ? _field_presence : 'sparse'){
+        case 'always':
+            return [];
+        case 'nullable':
+            return [
+                'isEmpty',
+                'isNotEmpty'
+            ];
+        default:
+            return [
+                'isNotEmpty'
+            ];
+    }
+};
+/** The operators a field offers, derived from the paths it actually has. */ export function listFilterOperators(field) {
+    if (field.operators) return [
+        ...field.operators
+    ];
+    const empties = emptyOperators(field);
+    switch(field.kind){
+        case 'text':
+            return [
+                ...field.tokensPath ? [
+                    'contains'
+                ] : [],
+                ...field.lowerPath ? [
+                    'equals',
+                    'startsWith'
+                ] : [],
+                ...field.reversedPath ? [
+                    'endsWith'
+                ] : [],
+                ...empties
+            ];
+        case 'exact':
+            return [
+                'equals',
+                'isAnyOf',
+                ...empties
+            ];
+        case 'id':
+            // An id is never absent, so the empty operators would answer nothing.
+            return [
+                'equals',
+                'startsWith',
+                'isAnyOf'
+            ];
+        case 'boolean':
+            return [
+                'is'
+            ];
+        case 'number':
+            return [
+                '=',
+                '!=',
+                '>',
+                '>=',
+                '<',
+                '<=',
+                ...empties
+            ];
+        case 'date':
+            return [
+                'is',
+                'after',
+                'onOrAfter',
+                'before',
+                'onOrBefore',
+                ...empties
+            ];
+        default:
+            return [];
+    }
+}
+const operatorPool = (kind)=>{
+    switch(kind){
+        case 'boolean':
+            return getGridBooleanOperators();
+        case 'number':
+            return getGridNumericOperators();
+        case 'date':
+            return getGridDateOperators();
+        default:
+            return getGridStringOperators();
+    }
+};
+/**
+ * The MUI operators for a field — the same list `listFilterOperators` names,
+ * resolved to the grid's own operator objects so the panel keeps its native
+ * inputs (a date picker for a date, a number field for a number).
+ */ export function gridFilterOperators(field) {
+    const allowed = listFilterOperators(field);
+    return operatorPool(field.kind).filter((operator)=>allowed.includes(operator.value));
+}
+/**
+ * Spread onto a `GridColDef` to make a column filterable exactly as far as the
+ * query can serve it. A column with NO declared field is turned off entirely —
+ * deliberately, because the alternative is a funnel icon that opens a panel
+ * nothing honours.
+ */ export function listFilterColumn(fields, column) {
+    const field = fields.find((entry)=>entry.column === column);
+    if (!field) return {
+        filterable: false
+    };
+    const operators = gridFilterOperators(field);
+    return operators.length ? {
+        filterable: true,
+        filterOperators: operators
+    } : {
+        filterable: false
+    };
+}
+/** Operators that carry no value — the grid leaves `item.value` undefined. */ const VALUELESS = [
+    'isEmpty',
+    'isNotEmpty'
+];
+/**
+ * The one filter item a server-paged list can act on, read off a grid model.
+ *
+ * ONE, because Firestore composes predicates only through indexes nobody built
+ * for every pair of columns; the first usable item wins and the rest are the
+ * reader's to remove. Every list read this off the model itself, and each did
+ * it slightly differently — the common miss being `isEmpty`, which sets no
+ * value at all and so was skipped by any check that required one.
+ */ export function gridFilterRequest(model) {
+    var _model_items;
+    const usable = ((_model_items = model.items) != null ? _model_items : []).find((item)=>{
+        if (!item.field || !item.operator) return false;
+        if (VALUELESS.includes(String(item.operator))) return true;
+        if (item.value === undefined || item.value === null) return false;
+        return Array.isArray(item.value) ? item.value.length > 0 : String(item.value).trim() !== '';
+    });
+    if (!usable) return null;
+    return gridItemRequest(usable);
+}
+/** Whether a grid filter item asks anything at all — see `gridFilterRequest`. */ const gridItemUsable = (item)=>{
+    if (!item.field || !item.operator) return false;
+    if (VALUELESS.includes(String(item.operator))) return true;
+    if (item.value === undefined || item.value === null) return false;
+    return Array.isArray(item.value) ? item.value.length > 0 : String(item.value).trim() !== '';
+};
+const gridItemRequest = (item)=>{
+    const raw = item.value;
+    const value = Array.isArray(raw) ? raw.join(',') : // locale rendering the server would have to guess at. ISO travels
+    // unambiguously and `new Date` reads it back exactly.
+    raw instanceof Date ? raw.toISOString() : raw === undefined || raw === null ? '' : String(raw);
+    return {
+        field: String(item.field),
+        op: String(item.operator),
+        value
+    };
+};
+/**
+ * EVERY usable filter item on a grid model, in the order the panel holds
+ * them — for a list that keeps more than one clause (AGL-2617).
+ *
+ * The singular reader above picks the first because a query serves one;
+ * a saved view carries a list of clauses and a list that applies it puts
+ * the first servable one on the query and matches the rest over the rows
+ * it loaded, which `listFilterPlan` in the instance library decides. The
+ * two readers share one notion of "usable", so a clause the singular one
+ * would take is a clause this one keeps.
+ */ export function gridFilterRequests(model) {
+    var _model_items;
+    return ((_model_items = model.items) != null ? _model_items : []).filter(gridItemUsable).map(gridItemRequest);
+}
+/**
+ * How an operator reads on a chip or in a sentence — "Owner is Dana",
+ * "Created on or after 1 Jan". One map so every list that shows its
+ * clauses back spells them the same way; an operator nothing here names
+ * is shown as itself rather than hidden.
+ */ export function listFilterOperatorLabel(op) {
+    switch(op){
+        case 'contains':
+            return 'contains';
+        case 'doesNotContain':
+            return 'does not contain';
+        case 'equals':
+        case 'is':
+        case '=':
+            return 'is';
+        case 'doesNotEqual':
+        case '!=':
+            return 'is not';
+        case 'startsWith':
+            return 'starts with';
+        case 'endsWith':
+            return 'ends with';
+        case 'isAnyOf':
+            return 'is any of';
+        case 'isEmpty':
+            return 'is empty';
+        case 'isNotEmpty':
+            return 'is set';
+        case 'after':
+            return 'after';
+        case 'onOrAfter':
+            return 'on or after';
+        case 'before':
+            return 'before';
+        case 'onOrBefore':
+            return 'on or before';
+        case '>':
+            return 'over';
+        case '>=':
+            return 'at least';
+        case '<':
+            return 'under';
+        case '<=':
+            return 'at most';
+        default:
+            return op;
+    }
+}
+/**
+ * Fields a reader can filter by that are NOT columns on the table.
+ *
+ * MUI's filter panel lists COLUMNS — `gridFilterableColumnDefinitionsSelector`
+ * reads every column definition, hidden ones included — so a filterable field
+ * with no column is a field nobody can reach however well the route answers it.
+ * Declaring it as a permanently hidden column keeps one source of truth, the
+ * field list, instead of a second list of "extra filters" that drifts from it.
+ *
+ * `hideable: false` keeps them out of Manage columns as well: a column with no
+ * `renderCell` and no width has nothing to show, and a reader who unhid one
+ * would get a strip of blank cells for their trouble.
+ *
+ * Pair with {@link hiddenFilterVisibility}, which is what actually hides them.
+ */ export function hiddenFilterColumns(fields, visible, headers = {}) {
+    return fields.filter((field)=>!visible.includes(field.column)).map((field)=>{
+        var _headers_field_column;
+        return _extends({
+            field: field.column,
+            headerName: (_headers_field_column = headers[field.column]) != null ? _headers_field_column : field.column,
+            hideable: false
+        }, listFilterColumn(fields, field.column));
+    }).filter((column)=>column.filterable);
+}
+const readPath = (row, path)=>path.split('.').reduce((value, key)=>value == null ? undefined : value[key], row);
+const asTime = (value)=>{
+    if (value == null) return null;
+    if (value instanceof Date) return value.getTime();
+    if (typeof value === 'number') return value;
+    // A Firestore timestamp, in either the admin shape or the serialized one.
+    const seconds = value.seconds;
+    if (typeof seconds === 'number') return seconds * 1000;
+    const parsed = new Date(String(value)).getTime();
+    return Number.isNaN(parsed) ? null : parsed;
+};
+/**
+ * Match ONE row against a filter, for a list that cannot push it to a query.
+ *
+ * The staff account list is the reason this exists: it is Firebase Auth, whose
+ * `listUsers` takes a page size and a cursor and nothing else — no predicate,
+ * no ordering, no search. A filter there is answered by walking the pools and
+ * matching here, which is why that list can offer a mid-string `contains` and
+ * a `doesNotContain` that a Firestore-backed list cannot.
+ *
+ * The declaration is still the same `ListFilterField`, so a list swapping
+ * substrates changes where the matching happens and not what it offers.
+ */ export function matchListFilter(row, fields, input) {
+    var _field_rowPath, _input_value;
+    if (!input) return true;
+    const field = fields.find((entry)=>entry.column === input.field);
+    if (!field) return true;
+    const stored = readPath(row, (_field_rowPath = field.rowPath) != null ? _field_rowPath : field.path);
+    // A presence map is matched as the array of its truthy keys — see `keysOf`.
+    const value = field.keysOf && stored && typeof stored === 'object' && !Array.isArray(stored) ? Object.keys(stored).filter((key)=>Boolean(stored[key])) : stored;
+    const op = input.op;
+    const blank = value == null || value === '' || Array.isArray(value) && value.length === 0;
+    if (op === 'isEmpty') return blank;
+    if (op === 'isNotEmpty') return !blank;
+    const raw = ((_input_value = input.value) != null ? _input_value : '').trim();
+    if (field.kind === 'boolean') {
+        if (raw !== 'true' && raw !== 'false') return true;
+        return Boolean(value) === (raw === 'true');
+    }
+    if (!raw) return true;
+    /*
+   * An array the QUERY serves whole is matched by whole member, never by
+   * substring of its joined form. A tag array asked `contains vip` holds the
+   * tag `vip` or it does not — `vip-gold` is a different tag, and the
+   * query's `array-contains` says so too, so the in-memory answer and the
+   * served answer agree. An id array keeps its case (`verbatimTokens`); a
+   * word array is folded the way its writer folded it. `isAnyOf` is any
+   * member in the asked list, which is what a saved segment's "any of these
+   * tags" becomes as a view clause. A presence map's keys are members too.
+   *
+   * A plain array with no token path is served by nothing, so there is no
+   * query to agree with, and it falls through to the scalar match over its
+   * joined text — the staff account list's providers, where `contains
+   * google` finding `google.com` is the mid-string answer that list
+   * documents (`operators`).
+   */ if (Array.isArray(value) && (field.tokensPath || field.keysOf)) {
+        const fold = (entry)=>field.verbatimTokens ? String(entry) : String(entry).toLowerCase();
+        const members = value.map(fold);
+        const asked = fold(raw);
+        switch(op){
+            case 'contains':
+            case 'equals':
+            case 'is':
+                return members.includes(asked);
+            case 'doesNotContain':
+            case 'doesNotEqual':
+                return !members.includes(asked);
+            case 'isAnyOf':
+                return asked.split(',').map((entry)=>entry.trim()).filter(Boolean).some((entry)=>members.includes(entry));
+            default:
+                return true;
+        }
+    }
+    if (field.kind === 'date') {
+        const at = asTime(value);
+        const day = new Date(raw);
+        if (at === null || Number.isNaN(day.getTime())) return false;
+        const start = new Date(day);
+        start.setHours(0, 0, 0, 0);
+        const end = new Date(start);
+        end.setDate(end.getDate() + 1);
+        switch(op){
+            // A day, not an instant — a stored time never equals midnight.
+            case 'is':
+                return at >= start.getTime() && at < end.getTime();
+            case 'after':
+                return at >= end.getTime();
+            case 'onOrAfter':
+                return at >= start.getTime();
+            case 'before':
+                return at < start.getTime();
+            case 'onOrBefore':
+                return at < end.getTime();
+            default:
+                return true;
+        }
+    }
+    if (field.kind === 'number') {
+        const asked = Number(raw);
+        const held = Number(value);
+        if (!Number.isFinite(asked) || !Number.isFinite(held)) return false;
+        switch(op){
+            case '=':
+                return held === asked;
+            case '!=':
+                return held !== asked;
+            case '>':
+                return held > asked;
+            case '>=':
+                return held >= asked;
+            case '<':
+                return held < asked;
+            case '<=':
+                return held <= asked;
+            default:
+                return true;
+        }
+    }
+    // A scalar id is matched as typed — see `verbatimTokens`; the array case
+    // was answered above.
+    if (field.verbatimTokens && op === 'contains') return value === raw;
+    const held = value == null ? '' : String(value).toLowerCase();
+    const asked = raw.toLowerCase();
+    switch(op){
+        case 'contains':
+            return held.includes(asked);
+        case 'doesNotContain':
+            return !held.includes(asked);
+        case 'equals':
+            return held === asked;
+        case 'doesNotEqual':
+            return held !== asked;
+        case 'startsWith':
+            return held.startsWith(asked);
+        case 'endsWith':
+            return held.endsWith(asked);
+        case 'isAnyOf':
+            return asked.split(',').map((entry)=>entry.trim()).filter(Boolean).includes(held);
+        default:
+            // An operator nothing here answers must not narrow the list to
+            // nothing — that reads as "no such record" rather than "not supported".
+            return true;
+    }
+}
+/** The visibility model that hides what {@link hiddenFilterColumns} added. */ export function hiddenFilterVisibility(fields, visible) {
+    return Object.fromEntries(fields.filter((field)=>!visible.includes(field.column)).map((field)=>[
+            field.column,
+            false
+        ]));
+}
+
+//# sourceMappingURL=list-filter.js.map

package/src/lib/const/list-filter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/shared/ui/jsx/src/lib/const/list-filter.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  getGridBooleanOperators,\n  getGridDateOperators,\n  getGridNumericOperators,\n  getGridStringOperators,\n  type GridFilterOperator,\n} from '@mui/x-data-grid'\n\n/**\n * ONE declaration of what a paged list can be filtered by (AGL-2501).\n *\n * A paged list filters on the SERVER or it does not filter: `filterMode=\"server\"`\n * stops the grid narrowing anything itself, so the panel shows the rows already\n * fetched — ten of them by default — and an operator the route does not answer\n * becomes a control that quietly does nothing. On a staff list whose whole job\n * is that nobody is missing, \"no matches\" is the one answer it must never give\n * wrongly.\n *\n * So a list declares its filterable fields ONCE, in a module both its route and\n * its page import. The declaration decides two things that must never disagree:\n * which operators the menu offers (here) and which predicates the query builds\n * (`applyListFilter`, server-side, which needs firebase-admin and so cannot\n * live in this file).\n *\n * ## Why the menu is shorter than MUI's\n *\n * Firestore has equality, `in`, ranges and `array-contains`. Everything below\n * is built from those four:\n *\n *   equals / isAnyOf   equality and `in` (Firestore caps `in` at 30 values)\n *   startsWith         a range over the normalized lower-case key\n *   endsWith           a range over the key stored REVERSED — a range is\n *                      anchored at the FRONT of a value, so storing the value\n *                      backwards is the only way to ask about its end\n *   contains           `array-contains` over word-prefix tokens, so it is\n *                      WORD-level: \"coffee\" finds \"Acme Coffee\", \"offee\" does\n *                      not find anything\n *   before / after     ranges on a timestamp or a number\n *   isNotEmpty         `!= null`, which in Firestore also requires the field to\n *                      EXIST — which is the meaning wanted\n *\n * ⛔ `doesNotContain` is offered nowhere and cannot be. Firestore has no\n * negated substring match, and no denormalization fixes it: the inverse of a\n * token array is every string the value does not contain, which is unbounded.\n *\n * ⚠️ The two empty operators depend on how a field's WRITERS behave, which is\n * what `presence` declares. Firestore cannot query for absence at all:\n * `where(path, '==', null)` matches an explicit null and never a missing field,\n * while `where(path, '!=', null)` additionally requires the field to exist.\n * So a field that writers omit can answer `isNotEmpty` exactly and can never\n * answer `isEmpty` — it would say \"none\" to a question with real answers — and\n * a field that is always written answers both, but each with a foregone\n * result. Only a `nullable` field earns both operators for real.\n */\n\n/** How a field can be queried, which decides which operators it offers. */\nexport type ListFilterKind =\n  | 'text'\n  | 'exact'\n  | 'boolean'\n  | 'number'\n  | 'date'\n  | 'id'\n\nexport interface ListFilterField {\n  /** The grid column's `field` — what the client sends back. */\n  column: string\n  kind: ListFilterKind\n  /** The Firestore field path the predicate targets. */\n  path: string\n  /**\n   * The normalized lower-case twin, for `equals` and `startsWith` on text.\n   * Without one a text field offers neither: a raw value is case-sensitive, so\n   * it would miss rather than fail.\n   */\n  lowerPath?: string\n  /** Word-prefix token array, for `contains`. */\n  tokensPath?: string\n  /**\n   * The token array holds OPAQUE IDS, matched byte for byte.\n   *\n   * A word token array is lower-cased by its writer, so a `contains` folds\n   * the typed value the same way before it looks. An id array — the forms a\n   * contact came in through, the companies they are linked to — is not: the\n   * ids are minted with mixed case, and folding one would look up an id\n   * nothing wrote. A field that says so is matched on the value exactly as\n   * given, in the query and in memory alike.\n   */\n  verbatimTokens?: boolean\n  /**\n   * What a `contains` orders by. Defaults to `lowerPath`, then `path`.\n   *\n   * A field whose `tokensPath` IS its own value — a real tag array, matched\n   * whole rather than by word prefix — has no lower-case twin to sort by, and\n   * defaulting to `path` would order by the array itself. Naming a scalar here\n   * keeps the composite index that combination needs an ordinary one.\n   */\n  containsOrderBy?: string\n  /** The reversed key, for `endsWith`. */\n  reversedPath?: string\n  /**\n   * How the field's writers treat \"no value\", which is the only thing that\n   * decides whether the empty operators mean anything:\n   *\n   *   `sparse`   (default) writers OMIT the field. `isNotEmpty` is exact;\n   *              `isEmpty` is unanswerable and so is not offered.\n   *   `nullable` writers store `null`. Both operators are exact and both can\n   *              return rows — the only case where offering them is useful.\n   *   `always`   the field is never absent and never null. Both operators have\n   *              a foregone answer (all rows, then none), so neither is\n   *              offered: a control whose result is known is a control that\n   *              wastes the reader's time.\n   */\n  presence?: 'sparse' | 'nullable' | 'always'\n  /**\n   * The operators this field offers, replacing the derived list.\n   *\n   * Not every list is a Firestore query. The staff account list is Firebase\n   * Auth, which cannot filter at ALL — so a filter there is answered by\n   * scanning the pools and matching in memory, and plain JavaScript can do\n   * things no index can: a mid-string `contains`, and `doesNotContain`. A\n   * list whose substrate is more capable says so here rather than being held\n   * to Firestore's limits by a shared default.\n   *\n   * Pair with {@link matchListFilter}, which is the matcher those lists use.\n   */\n  operators?: readonly string[]\n  /**\n   * Where to read this field from a ROW, when the list matches in memory.\n   * Defaults to `path`. Only needed when the row's shape differs from the\n   * document's — an Auth record's `staff` lives under `customClaims`.\n   */\n  rowPath?: string\n  /**\n   * The field lives where no query can reach it, so the list matches it\n   * over the rows it has loaded and the translators refuse it.\n   *\n   * A contact's owner, stage and custom values sit on the viewing group's\n   * FACET — a map keyed per group — and a `where` on a per-group path would\n   * need an index per group. Declaring the field at all is what puts it in\n   * the menu and in a saved view; saying it is window-only is what keeps a\n   * clause on it from being sent to a query that would answer with a\n   * permission error or nothing. The list says which clauses narrowed only\n   * the window — see `listFilterPlan`.\n   */\n  windowOnly?: boolean\n  /**\n   * The stored value is a PRESENCE MAP — `{ form: true, order: true }` —\n   * and the filter asks about its keys.\n   *\n   * A contact's `sources` is such a map: one key per door the person came\n   * in through, never an array. Matched as though it were the array of its\n   * truthy keys, so `equals form` and `isAnyOf form,order` read the way a\n   * reader expects; a query can serve `equals` as `sources.form == true`.\n   */\n  keysOf?: boolean\n}\n\n/** The empty-operators a field can honestly offer. See `presence`. */\nconst emptyOperators = (field: ListFilterField): string[] => {\n  switch (field.presence ?? 'sparse') {\n    case 'always':\n      return []\n    case 'nullable':\n      return ['isEmpty', 'isNotEmpty']\n    default:\n      return ['isNotEmpty']\n  }\n}\n\n/** The operators a field offers, derived from the paths it actually has. */\nexport function listFilterOperators(field: ListFilterField): string[] {\n  if (field.operators) return [...field.operators]\n  const empties = emptyOperators(field)\n  switch (field.kind) {\n    case 'text':\n      return [\n        ...(field.tokensPath ? ['contains'] : []),\n        ...(field.lowerPath ? ['equals', 'startsWith'] : []),\n        ...(field.reversedPath ? ['endsWith'] : []),\n        ...empties,\n      ]\n    case 'exact':\n      return ['equals', 'isAnyOf', ...empties]\n    case 'id':\n      // An id is never absent, so the empty operators would answer nothing.\n      return ['equals', 'startsWith', 'isAnyOf']\n    case 'boolean':\n      return ['is']\n    case 'number':\n      return ['=', '!=', '>', '>=', '<', '<=', ...empties]\n    case 'date':\n      return ['is', 'after', 'onOrAfter', 'before', 'onOrBefore', ...empties]\n    default:\n      return []\n  }\n}\n\nconst operatorPool = (kind: ListFilterKind): GridFilterOperator[] => {\n  switch (kind) {\n    case 'boolean':\n      return getGridBooleanOperators()\n    case 'number':\n      return getGridNumericOperators()\n    case 'date':\n      return getGridDateOperators()\n    default:\n      return getGridStringOperators()\n  }\n}\n\n/**\n * The MUI operators for a field — the same list `listFilterOperators` names,\n * resolved to the grid's own operator objects so the panel keeps its native\n * inputs (a date picker for a date, a number field for a number).\n */\nexport function gridFilterOperators(\n  field: ListFilterField,\n): GridFilterOperator[] {\n  const allowed = listFilterOperators(field)\n  return operatorPool(field.kind).filter((operator) =>\n    allowed.includes(operator.value),\n  )\n}\n\n/**\n * Spread onto a `GridColDef` to make a column filterable exactly as far as the\n * query can serve it. A column with NO declared field is turned off entirely —\n * deliberately, because the alternative is a funnel icon that opens a panel\n * nothing honours.\n */\nexport function listFilterColumn(\n  fields: readonly ListFilterField[],\n  column: string,\n): { filterable: boolean; filterOperators?: GridFilterOperator[] } {\n  const field = fields.find((entry) => entry.column === column)\n  if (!field) return { filterable: false }\n  const operators = gridFilterOperators(field)\n  return operators.length\n    ? { filterable: true, filterOperators: operators }\n    : { filterable: false }\n}\n\n/** What a page sends the route: one field, one operator, one value. */\nexport interface ListFilterRequest {\n  field: string\n  op: string\n  value: string\n}\n\n/** Operators that carry no value — the grid leaves `item.value` undefined. */\nconst VALUELESS = ['isEmpty', 'isNotEmpty']\n\n/**\n * The one filter item a server-paged list can act on, read off a grid model.\n *\n * ONE, because Firestore composes predicates only through indexes nobody built\n * for every pair of columns; the first usable item wins and the rest are the\n * reader's to remove. Every list read this off the model itself, and each did\n * it slightly differently — the common miss being `isEmpty`, which sets no\n * value at all and so was skipped by any check that required one.\n */\nexport function gridFilterRequest(model: {\n  items?: Array<{ field?: unknown; operator?: unknown; value?: unknown }>\n}): ListFilterRequest | null {\n  const usable = (model.items ?? []).find((item) => {\n    if (!item.field || !item.operator) return false\n    if (VALUELESS.includes(String(item.operator))) return true\n    if (item.value === undefined || item.value === null) return false\n    return Array.isArray(item.value)\n      ? item.value.length > 0\n      : String(item.value).trim() !== ''\n  })\n  if (!usable) return null\n  return gridItemRequest(usable)\n}\n\n/** Whether a grid filter item asks anything at all — see `gridFilterRequest`. */\nconst gridItemUsable = (item: {\n  field?: unknown\n  operator?: unknown\n  value?: unknown\n}): boolean => {\n  if (!item.field || !item.operator) return false\n  if (VALUELESS.includes(String(item.operator))) return true\n  if (item.value === undefined || item.value === null) return false\n  return Array.isArray(item.value)\n    ? item.value.length > 0\n    : String(item.value).trim() !== ''\n}\n\nconst gridItemRequest = (item: {\n  field?: unknown\n  operator?: unknown\n  value?: unknown\n}): ListFilterRequest => {\n  const raw = item.value\n  const value = Array.isArray(raw)\n    ? raw.join(',')\n    : // A date column hands back a `Date`, whose default string form is a\n      // locale rendering the server would have to guess at. ISO travels\n      // unambiguously and `new Date` reads it back exactly.\n      raw instanceof Date\n      ? raw.toISOString()\n      : raw === undefined || raw === null\n        ? ''\n        : String(raw)\n  return { field: String(item.field), op: String(item.operator), value }\n}\n\n/**\n * EVERY usable filter item on a grid model, in the order the panel holds\n * them — for a list that keeps more than one clause (AGL-2617).\n *\n * The singular reader above picks the first because a query serves one;\n * a saved view carries a list of clauses and a list that applies it puts\n * the first servable one on the query and matches the rest over the rows\n * it loaded, which `listFilterPlan` in the instance library decides. The\n * two readers share one notion of \"usable\", so a clause the singular one\n * would take is a clause this one keeps.\n */\nexport function gridFilterRequests(model: {\n  items?: Array<{ field?: unknown; operator?: unknown; value?: unknown }>\n}): ListFilterRequest[] {\n  return (model.items ?? []).filter(gridItemUsable).map(gridItemRequest)\n}\n\n/**\n * How an operator reads on a chip or in a sentence — \"Owner is Dana\",\n * \"Created on or after 1 Jan\". One map so every list that shows its\n * clauses back spells them the same way; an operator nothing here names\n * is shown as itself rather than hidden.\n */\nexport function listFilterOperatorLabel(op: string): string {\n  switch (op) {\n    case 'contains':\n      return 'contains'\n    case 'doesNotContain':\n      return 'does not contain'\n    case 'equals':\n    case 'is':\n    case '=':\n      return 'is'\n    case 'doesNotEqual':\n    case '!=':\n      return 'is not'\n    case 'startsWith':\n      return 'starts with'\n    case 'endsWith':\n      return 'ends with'\n    case 'isAnyOf':\n      return 'is any of'\n    case 'isEmpty':\n      return 'is empty'\n    case 'isNotEmpty':\n      return 'is set'\n    case 'after':\n      return 'after'\n    case 'onOrAfter':\n      return 'on or after'\n    case 'before':\n      return 'before'\n    case 'onOrBefore':\n      return 'on or before'\n    case '>':\n      return 'over'\n    case '>=':\n      return 'at least'\n    case '<':\n      return 'under'\n    case '<=':\n      return 'at most'\n    default:\n      return op\n  }\n}\n\n/**\n * Fields a reader can filter by that are NOT columns on the table.\n *\n * MUI's filter panel lists COLUMNS — `gridFilterableColumnDefinitionsSelector`\n * reads every column definition, hidden ones included — so a filterable field\n * with no column is a field nobody can reach however well the route answers it.\n * Declaring it as a permanently hidden column keeps one source of truth, the\n * field list, instead of a second list of \"extra filters\" that drifts from it.\n *\n * `hideable: false` keeps them out of Manage columns as well: a column with no\n * `renderCell` and no width has nothing to show, and a reader who unhid one\n * would get a strip of blank cells for their trouble.\n *\n * Pair with {@link hiddenFilterVisibility}, which is what actually hides them.\n */\nexport function hiddenFilterColumns(\n  fields: readonly ListFilterField[],\n  visible: readonly string[],\n  headers: Readonly<Record<string, string>> = {},\n): Array<{\n  field: string\n  headerName: string\n  hideable: boolean\n  filterable: boolean\n  filterOperators?: GridFilterOperator[]\n}> {\n  return fields\n    .filter((field) => !visible.includes(field.column))\n    .map((field) => ({\n      field: field.column,\n      headerName: headers[field.column] ?? field.column,\n      hideable: false,\n      ...listFilterColumn(fields, field.column),\n    }))\n    .filter((column) => column.filterable)\n}\n\nconst readPath = (row: unknown, path: string): unknown =>\n  path\n    .split('.')\n    .reduce<any>(\n      (value, key) => (value == null ? undefined : value[key]),\n      row as any,\n    )\n\nconst asTime = (value: unknown): number | null => {\n  if (value == null) return null\n  if (value instanceof Date) return value.getTime()\n  if (typeof value === 'number') return value\n  // A Firestore timestamp, in either the admin shape or the serialized one.\n  const seconds = (value as { seconds?: unknown }).seconds\n  if (typeof seconds === 'number') return seconds * 1000\n  const parsed = new Date(String(value)).getTime()\n  return Number.isNaN(parsed) ? null : parsed\n}\n\n/**\n * Match ONE row against a filter, for a list that cannot push it to a query.\n *\n * The staff account list is the reason this exists: it is Firebase Auth, whose\n * `listUsers` takes a page size and a cursor and nothing else — no predicate,\n * no ordering, no search. A filter there is answered by walking the pools and\n * matching here, which is why that list can offer a mid-string `contains` and\n * a `doesNotContain` that a Firestore-backed list cannot.\n *\n * The declaration is still the same `ListFilterField`, so a list swapping\n * substrates changes where the matching happens and not what it offers.\n */\nexport function matchListFilter(\n  row: unknown,\n  fields: readonly ListFilterField[],\n  input: ListFilterRequest | null,\n): boolean {\n  if (!input) return true\n  const field = fields.find((entry) => entry.column === input.field)\n  if (!field) return true\n  const stored = readPath(row, field.rowPath ?? field.path)\n  // A presence map is matched as the array of its truthy keys — see `keysOf`.\n  const value =\n    field.keysOf && stored && typeof stored === 'object' && !Array.isArray(stored)\n      ? Object.keys(stored as Record<string, unknown>).filter((key) =>\n          Boolean((stored as Record<string, unknown>)[key]),\n        )\n      : stored\n  const op = input.op\n\n  const blank =\n    value == null || value === '' || (Array.isArray(value) && value.length === 0)\n  if (op === 'isEmpty') return blank\n  if (op === 'isNotEmpty') return !blank\n\n  const raw = (input.value ?? '').trim()\n  if (field.kind === 'boolean') {\n    if (raw !== 'true' && raw !== 'false') return true\n    return Boolean(value) === (raw === 'true')\n  }\n  if (!raw) return true\n\n  /*\n   * An array the QUERY serves whole is matched by whole member, never by\n   * substring of its joined form. A tag array asked `contains vip` holds the\n   * tag `vip` or it does not — `vip-gold` is a different tag, and the\n   * query's `array-contains` says so too, so the in-memory answer and the\n   * served answer agree. An id array keeps its case (`verbatimTokens`); a\n   * word array is folded the way its writer folded it. `isAnyOf` is any\n   * member in the asked list, which is what a saved segment's \"any of these\n   * tags\" becomes as a view clause. A presence map's keys are members too.\n   *\n   * A plain array with no token path is served by nothing, so there is no\n   * query to agree with, and it falls through to the scalar match over its\n   * joined text — the staff account list's providers, where `contains\n   * google` finding `google.com` is the mid-string answer that list\n   * documents (`operators`).\n   */\n  if (Array.isArray(value) && (field.tokensPath || field.keysOf)) {\n    const fold = (entry: unknown) =>\n      field.verbatimTokens ? String(entry) : String(entry).toLowerCase()\n    const members = value.map(fold)\n    const asked = fold(raw)\n    switch (op) {\n      case 'contains':\n      case 'equals':\n      case 'is':\n        return members.includes(asked)\n      case 'doesNotContain':\n      case 'doesNotEqual':\n        return !members.includes(asked)\n      case 'isAnyOf':\n        return asked\n          .split(',')\n          .map((entry) => entry.trim())\n          .filter(Boolean)\n          .some((entry) => members.includes(entry))\n      default:\n        return true\n    }\n  }\n\n  if (field.kind === 'date') {\n    const at = asTime(value)\n    const day = new Date(raw)\n    if (at === null || Number.isNaN(day.getTime())) return false\n    const start = new Date(day)\n    start.setHours(0, 0, 0, 0)\n    const end = new Date(start)\n    end.setDate(end.getDate() + 1)\n    switch (op) {\n      // A day, not an instant — a stored time never equals midnight.\n      case 'is':\n        return at >= start.getTime() && at < end.getTime()\n      case 'after':\n        return at >= end.getTime()\n      case 'onOrAfter':\n        return at >= start.getTime()\n      case 'before':\n        return at < start.getTime()\n      case 'onOrBefore':\n        return at < end.getTime()\n      default:\n        return true\n    }\n  }\n\n  if (field.kind === 'number') {\n    const asked = Number(raw)\n    const held = Number(value)\n    if (!Number.isFinite(asked) || !Number.isFinite(held)) return false\n    switch (op) {\n      case '=':\n        return held === asked\n      case '!=':\n        return held !== asked\n      case '>':\n        return held > asked\n      case '>=':\n        return held >= asked\n      case '<':\n        return held < asked\n      case '<=':\n        return held <= asked\n      default:\n        return true\n    }\n  }\n\n  // A scalar id is matched as typed — see `verbatimTokens`; the array case\n  // was answered above.\n  if (field.verbatimTokens && op === 'contains') return value === raw\n  const held = value == null ? '' : String(value).toLowerCase()\n  const asked = raw.toLowerCase()\n  switch (op) {\n    case 'contains':\n      return held.includes(asked)\n    case 'doesNotContain':\n      return !held.includes(asked)\n    case 'equals':\n      return held === asked\n    case 'doesNotEqual':\n      return held !== asked\n    case 'startsWith':\n      return held.startsWith(asked)\n    case 'endsWith':\n      return held.endsWith(asked)\n    case 'isAnyOf':\n      return asked\n        .split(',')\n        .map((entry) => entry.trim())\n        .filter(Boolean)\n        .includes(held)\n    default:\n      // An operator nothing here answers must not narrow the list to\n      // nothing — that reads as \"no such record\" rather than \"not supported\".\n      return true\n  }\n}\n\n/** The visibility model that hides what {@link hiddenFilterColumns} added. */\nexport function hiddenFilterVisibility(\n  fields: readonly ListFilterField[],\n  visible: readonly string[],\n): Record<string, boolean> {\n  return Object.fromEntries(\n    fields\n      .filter((field) => !visible.includes(field.column))\n      .map((field) => [field.column, false]),\n  )\n}\n"],"names":["getGridBooleanOperators","getGridDateOperators","getGridNumericOperators","getGridStringOperators","emptyOperators","field","presence","listFilterOperators","operators","empties","kind","tokensPath","lowerPath","reversedPath","operatorPool","gridFilterOperators","allowed","filter","operator","includes","value","listFilterColumn","fields","column","find","entry","filterable","length","filterOperators","VALUELESS","gridFilterRequest","model","usable","items","item","String","undefined","Array","isArray","trim","gridItemRequest","gridItemUsable","raw","join","Date","toISOString","op","gridFilterRequests","map","listFilterOperatorLabel","hiddenFilterColumns","visible","headers","headerName","hideable","readPath","row","path","split","reduce","key","asTime","getTime","seconds","parsed","Number","isNaN","matchListFilter","input","stored","rowPath","keysOf","Object","keys","Boolean","blank","fold","verbatimTokens","toLowerCase","members","asked","some","at","day","start","setHours","end","setDate","getDate","held","isFinite","startsWith","endsWith","hiddenFilterVisibility","fromEntries"],"mappings":"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"}

package/src/lib/const/prebuilt-components.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2023 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare const LOADING_OVERLAY_ELEMENT: import("react").JSX.Element;

package/src/lib/const/prebuilt-components.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2023 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import LoadingModal from "../components/loading-modal.js";
+export const LOADING_OVERLAY_ELEMENT = /*#__PURE__*/ _jsx(LoadingModal, {
+    open: true
+});
+
+//# sourceMappingURL=prebuilt-components.js.map

package/src/lib/const/prebuilt-components.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/shared/ui/jsx/src/lib/const/prebuilt-components.tsx"],"sourcesContent":["/**\n * @license\n * Copyright 2023 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport LoadingModal from '../components/loading-modal'\n\nexport const LOADING_OVERLAY_ELEMENT = <LoadingModal open />\n"],"names":["LoadingModal","LOADING_OVERLAY_ELEMENT","open"],"mappings":";AAAA;;;;;;;;;;;;;;;CAeC,GAED,OAAOA,kBAAkB,iCAA6B;AAEtD,OAAO,MAAMC,wCAA0B,KAACD;IAAaE,IAAI;GAAG"}

package/src/lib/const/svg-icons.d.ts

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { SvgIconProps } from '@mui/material';
+import { type AglynLogoProps } from './aglyn-logo-class-keys';
+export * from './aglyn-besigner-logo-full';
+export * from './aglyn-console-logo-full';
+export * from './aglyn-logo-class-keys';
+export * from './aglyn-logo-full';
+/**
+ * ## The `<title>` on every wordmark below says `Aglyn`, deliberately
+ *
+ * The brand-literal ratchet learned to read JSX text in AGL-2350 and the
+ * `<title>` element in each of these wordmarks — and in `aglyn-logo-full.tsx`
+ * beside them — is what it found. They are baselined rather than rewritten,
+ * and a future sweep should leave them alone.
+ *
+ * A `<title>` inside an `<svg>` is the ACCESSIBLE NAME of the artwork around
+ * it, and this artwork is Aglyn's own compass mark and logotype, drawn as
+ * vector paths. Substituting `productName` would announce a white-label org's
+ * name over a picture that unmistakably draws ours — the label would become
+ * false to the only users who ever hear it, for no gain, since a screen-reader
+ * user and a sighted one would then be told different things about the same
+ * image. It is the `docs-self-host.mjs` line: *what must not survive is a
+ * value the software ACTS on*, and an accessible name for a fixed drawing is
+ * not one.
+ *
+ * The real question is not what these say but WHERE they render.
+ * `main.layout.tsx` already swaps the console chrome on `whiteLabel`; the open
+ * item is every other placement, the tenant admin bar's `<AglynMark />` most
+ * of all, which sits on a white-label customer's PUBLISHED site. That is
+ * tracked as AGL-2350 and is a product decision, not a lint fix — no detector
+ * that reads source can see a wordmark anyway, because the paths carry the
+ * brand with no string in them at all.
+ */
+export declare const AglynLogoMark: import("@emotion/styled").StyledComponent<import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme> & AglynLogoProps, {}, {}>;
+export declare const AglynLogoText: import("@emotion/styled").StyledComponent<import("@mui/material").SvgIconOwnProps & import("@mui/material/OverridableComponent").CommonProps & Omit<import("react").SVGProps<SVGSVGElement>, "children" | "style" | "className" | "color" | "fontSize" | "shapeRendering" | "classes" | "sx" | "htmlColor" | "inheritViewBox" | "titleAccess" | "viewBox"> & {
+    component?: React.ElementType | undefined;
+} & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme> & AglynLogoProps, {}, {}>;
+export declare const AGLYN_SVG_LOGO: {
+    path: string;
+    viewBox: string;
+};
+export declare const AGLYN_SVG_APP_ICON: {
+    path: string;
+    viewBox: string;
+};
+export declare const BESIGNER_SVG_LOGO: {
+    path: string;
+    viewBox: string;
+};
+export declare const AglynSvgLogo: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+export declare const BesignerSvgLogo: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+export interface AglynSvgIconProps extends SvgIconProps {
+    rectBgColor?: string;
+    a1Color?: string;
+    a2Color?: string;
+    a3Color?: string;
+    rounded?: boolean;
+    bordered?: boolean;
+}
+export declare const AglynSvgIcon: import("@emotion/styled").StyledComponent<Omit<AglynSvgIconProps, "ref"> & import("react").RefAttributes<any> & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme> & AglynSvgIconProps, {}, {}>;