@aglyn/shared-ui-jsx 1.0.0-beta.229 → 1.0.0-beta.231

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

@@ -14,110 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */ /*
- * How a list's filter clauses read as words, for the chips over a list and
- * the notices that say a clause was not applied (AGL-3321).
- *
- * ⛔ No `@mui/x-data-grid` here, and no runtime import of `list-filter` or
- * `list-grid-filter`, which build the data grid's operators. The storefront's
- * product grid shows these notices on customers' published pages, and
- * reaching the grid's operators from here would ship the grid's filter
- * inputs with every storefront page.
- */ /**
- * 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;
-    }
-}
-/** Operators that carry no value. */ const VALUELESS_OPERATORS = new Set([
-    'isEmpty',
-    'isNotEmpty'
-]);
-/** Operators that take several values, comma-joined the way the grammar splits them. */ const MULTI_OPERATORS = new Set([
-    'isAnyOf'
-]);
-/**
- * The calendar day a date clause names, as a LOCAL date.
- *
- * The panel's date input holds a day, not an instant, and hands it over as
- * `YYYY-MM-DD` — which `new Date` reads as UTC midnight, the previous
- * evening anywhere west of UTC. Travelled through `toISOString`, the same
- * day arrives as `YYYY-MM-DDT00:00:00.000Z`. Either spelling is read by its
- * date parts, so "on or after Sep 17" starts on Sep 17 wherever the reader
- * is. Any other value is an instant and is read as one. The query
- * translators read a date clause through it too, so the day a query asks for
- * is the day the rows are matched by.
- */ const DAY_ONLY = /^(\d{4})-(\d{2})-(\d{2})(?:T00:00:00(?:\.000)?Z)?$/;
-export const listFilterDay = (raw)=>{
-    const day = DAY_ONLY.exec(raw);
-    return day ? new Date(Number(day[1]), Number(day[2]) - 1, Number(day[3])) : new Date(raw);
-};
-/** A date clause's value as the day it names, read the way the query reads it. */ const dayLabel = (raw)=>{
-    const at = listFilterDay(raw);
-    return Number.isNaN(at.getTime()) ? raw : at.toLocaleDateString();
-};
-/**
- * How a clause reads as a sentence — "Owner is Dana", "Created on or after
- * 1 Jan", "Reason is any of Bounced, Complained": its header, its operator,
- * and its value by the label of the option it names.
- *
- * ONE wording, used by the chips over a list and by the notices that say a
- * clause was not applied (`listQueryRefusals`), so the two cannot describe
- * the same clause differently.
- */ export function listFilterClauseSentence(clause, context) {
-    var _ref, _clause_label;
-    var _context_headers, _context_options;
-    const field = context.fields.find((entry)=>entry.column === clause.field);
-    const header = (_ref = (_context_headers = context.headers) == null ? void 0 : _context_headers[clause.field]) != null ? _ref : clause.field;
-    const choices = (_context_options = context.options) == null ? void 0 : _context_options[clause.field];
-    const named = (value)=>{
-        var _ref;
-        var _choices_find;
-        return (_ref = choices == null ? void 0 : (_choices_find = choices.find((option)=>option.value === value)) == null ? void 0 : _choices_find.label) != null ? _ref : value;
-    };
-    const value = VALUELESS_OPERATORS.has(clause.op) ? '' : MULTI_OPERATORS.has(clause.op) ? clause.value.split(',').map((entry)=>entry.trim()).filter(Boolean).map(named).join(', ') : (_clause_label = clause.label) != null ? _clause_label : (field == null ? void 0 : field.kind) === 'date' ? dayLabel(clause.value) : named(clause.value);
-    return `${header} ${listFilterOperatorLabel(clause.op)}${value ? ` ${value}` : ''}`;
-}
+ * The list filter grammar lives in a pure module, so a surface with no web UI
+ * (the native app) plans the same queries; this path stays its web entry.
+ */ export * from "@aglyn/shared-util-tools/list-query/list-filter-sentence";
 
 //# sourceMappingURL=list-filter-sentence.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../libs/shared/ui/jsx/src/lib/const/list-filter-sentence.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 type { ListFilterField } from './list-filter'\nimport type { ListFilterClause, ListFilterOption } from './list-grid-filter'\n\n/*\n * How a list's filter clauses read as words, for the chips over a list and\n * the notices that say a clause was not applied (AGL-3321).\n *\n * ⛔ No `@mui/x-data-grid` here, and no runtime import of `list-filter` or\n * `list-grid-filter`, which build the data grid's operators. The storefront's\n * product grid shows these notices on customers' published pages, and\n * reaching the grid's operators from here would ship the grid's filter\n * inputs with every storefront page.\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/** Operators that carry no value. */\nconst VALUELESS_OPERATORS = new Set(['isEmpty', 'isNotEmpty'])\n/** Operators that take several values, comma-joined the way the grammar splits them. */\nconst MULTI_OPERATORS = new Set(['isAnyOf'])\n\n/**\n * The calendar day a date clause names, as a LOCAL date.\n *\n * The panel's date input holds a day, not an instant, and hands it over as\n * `YYYY-MM-DD` — which `new Date` reads as UTC midnight, the previous\n * evening anywhere west of UTC. Travelled through `toISOString`, the same\n * day arrives as `YYYY-MM-DDT00:00:00.000Z`. Either spelling is read by its\n * date parts, so \"on or after Sep 17\" starts on Sep 17 wherever the reader\n * is. Any other value is an instant and is read as one. The query\n * translators read a date clause through it too, so the day a query asks for\n * is the day the rows are matched by.\n */\nconst DAY_ONLY = /^(\\d{4})-(\\d{2})-(\\d{2})(?:T00:00:00(?:\\.000)?Z)?$/\nexport const listFilterDay = (raw: string): Date => {\n  const day = DAY_ONLY.exec(raw)\n  return day ? new Date(Number(day[1]), Number(day[2]) - 1, Number(day[3])) : new Date(raw)\n}\n\n/** A date clause's value as the day it names, read the way the query reads it. */\nconst dayLabel = (raw: string): string => {\n  const at = listFilterDay(raw)\n  return Number.isNaN(at.getTime()) ? raw : at.toLocaleDateString()\n}\n\n/**\n * How a clause reads as a sentence — \"Owner is Dana\", \"Created on or after\n * 1 Jan\", \"Reason is any of Bounced, Complained\": its header, its operator,\n * and its value by the label of the option it names.\n *\n * ONE wording, used by the chips over a list and by the notices that say a\n * clause was not applied (`listQueryRefusals`), so the two cannot describe\n * the same clause differently.\n */\nexport function listFilterClauseSentence(\n  clause: ListFilterClause,\n  context: {\n    fields: readonly ListFilterField[]\n    headers?: Readonly<Record<string, string>>\n    options?: Readonly<Record<string, readonly ListFilterOption[]>>\n  },\n): string {\n  const field = context.fields.find((entry) => entry.column === clause.field)\n  const header = context.headers?.[clause.field] ?? clause.field\n  const choices = context.options?.[clause.field]\n  const named = (value: string) =>\n    choices?.find((option) => option.value === value)?.label ?? value\n  const value = VALUELESS_OPERATORS.has(clause.op)\n    ? ''\n    : MULTI_OPERATORS.has(clause.op)\n      ? clause.value\n          .split(',')\n          .map((entry) => entry.trim())\n          .filter(Boolean)\n          .map(named)\n          .join(', ')\n      : clause.label ?? (field?.kind === 'date' ? dayLabel(clause.value) : named(clause.value))\n  return `${header} ${listFilterOperatorLabel(clause.op)}${value ? ` ${value}` : ''}`\n}\n"],"names":["listFilterOperatorLabel","op","VALUELESS_OPERATORS","Set","MULTI_OPERATORS","DAY_ONLY","listFilterDay","raw","day","exec","Date","Number","dayLabel","at","isNaN","getTime","toLocaleDateString","listFilterClauseSentence","clause","context","field","fields","find","entry","column","header","headers","choices","options","named","value","option","label","has","split","map","trim","filter","Boolean","join","kind"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAKD;;;;;;;;;CASC,GAED;;;;;CAKC,GACD,OAAO,SAASA,wBAAwBC,EAAU;IAChD,OAAQA;QACN,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT,KAAK;QACL,KAAK;QACL,KAAK;YACH,OAAO;QACT,KAAK;QACL,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT,KAAK;YACH,OAAO;QACT;YACE,OAAOA;IACX;AACF;AAEA,mCAAmC,GACnC,MAAMC,sBAAsB,IAAIC,IAAI;IAAC;IAAW;CAAa;AAC7D,sFAAsF,GACtF,MAAMC,kBAAkB,IAAID,IAAI;IAAC;CAAU;AAE3C;;;;;;;;;;;CAWC,GACD,MAAME,WAAW;AACjB,OAAO,MAAMC,gBAAgB,CAACC;IAC5B,MAAMC,MAAMH,SAASI,IAAI,CAACF;IAC1B,OAAOC,MAAM,IAAIE,KAAKC,OAAOH,GAAG,CAAC,EAAE,GAAGG,OAAOH,GAAG,CAAC,EAAE,IAAI,GAAGG,OAAOH,GAAG,CAAC,EAAE,KAAK,IAAIE,KAAKH;AACvF,EAAC;AAED,gFAAgF,GAChF,MAAMK,WAAW,CAACL;IAChB,MAAMM,KAAKP,cAAcC;IACzB,OAAOI,OAAOG,KAAK,CAACD,GAAGE,OAAO,MAAMR,MAAMM,GAAGG,kBAAkB;AACjE;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASC,yBACdC,MAAwB,EACxBC,OAIC;cAgBKD;QAbSC,kBACCA;IAFhB,MAAMC,QAAQD,QAAQE,MAAM,CAACC,IAAI,CAAC,CAACC,QAAUA,MAAMC,MAAM,KAAKN,OAAOE,KAAK;IAC1E,MAAMK,kBAASN,mBAAAA,QAAQO,OAAO,qBAAfP,gBAAiB,CAACD,OAAOE,KAAK,CAAC,mBAAIF,OAAOE,KAAK;IAC9D,MAAMO,WAAUR,mBAAAA,QAAQS,OAAO,qBAAfT,gBAAiB,CAACD,OAAOE,KAAK,CAAC;IAC/C,MAAMS,QAAQ,CAACC;;YACbH;uBAAAA,4BAAAA,gBAAAA,QAASL,IAAI,CAAC,CAACS,SAAWA,OAAOD,KAAK,KAAKA,2BAA3CH,cAAmDK,KAAK,mBAAIF;;IAC9D,MAAMA,QAAQ5B,oBAAoB+B,GAAG,CAACf,OAAOjB,EAAE,IAC3C,KACAG,gBAAgB6B,GAAG,CAACf,OAAOjB,EAAE,IAC3BiB,OAAOY,KAAK,CACTI,KAAK,CAAC,KACNC,GAAG,CAAC,CAACZ,QAAUA,MAAMa,IAAI,IACzBC,MAAM,CAACC,SACPH,GAAG,CAACN,OACJU,IAAI,CAAC,SACRrB,gBAAAA,OAAOc,KAAK,YAAZd,gBAAiBE,CAAAA,yBAAAA,MAAOoB,IAAI,MAAK,SAAS5B,SAASM,OAAOY,KAAK,IAAID,MAAMX,OAAOY,KAAK;IAC3F,OAAO,GAAGL,OAAO,CAAC,EAAEzB,wBAAwBkB,OAAOjB,EAAE,IAAI6B,QAAQ,CAAC,CAAC,EAAEA,OAAO,GAAG,IAAI;AACrF"}
+{"version":3,"sources":["../../../../../../../../libs/shared/ui/jsx/src/lib/const/list-filter-sentence.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\n/*\n * The list filter grammar lives in a pure module, so a surface with no web UI\n * (the native app) plans the same queries; this path stays its web entry.\n */\nexport * from '@aglyn/shared-util-tools/list-query/list-filter-sentence'\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;CAGC,GACD,cAAc,2DAA0D"}

package/src/lib/const/list-filter.d.ts

@@ -14,222 +14,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/**
- * ONE declaration of what a paged list can be filtered by (AGL-2501).
- *
- * A paged list filters on the SERVER or it does not filter: `filterMode="server"`
- * stops the grid narrowing anything itself, so the panel shows the rows already
- * fetched — ten of them by default — and an operator the route does not answer
- * becomes a control that quietly does nothing. On a staff list whose whole job
- * is that nobody is missing, "no matches" is the one answer it must never give
- * wrongly.
- *
- * So a list declares its filterable fields ONCE, in a module both its route and
- * its page import. The declaration decides two things that must never disagree:
- * which operators the menu offers (here) and which predicates the query builds
- * (`applyListFilter`, server-side, which needs firebase-admin and so cannot
- * live in this file).
- *
- * ⛔ No runtime import of `@mui/x-data-grid` here. This grammar is read by
- * `list-query-plan`, which the storefront's server-side catalog query reaches
- * from a published page, and the grid's filter inputs are `'use client'`
- * modules: imported from the server graph they become client references that
- * every published page downloads. The grid's own operator objects are built
- * in `list-grid-filter` (`listFilterColumn`, `hiddenFilterColumns`).
- *
- * ## Why the menu is shorter than MUI's
- *
- * Firestore has equality, `in`, ranges and `array-contains`. Everything below
- * is built from those four:
- *
- *   equals / isAnyOf   equality and `in` (Firestore caps `in` at 30 values)
- *   startsWith         a range over the normalized lower-case key
- *   endsWith           a range over the key stored REVERSED — a range is
- *                      anchored at the FRONT of a value, so storing the value
- *                      backwards is the only way to ask about its end
- *   contains           `array-contains` over word-prefix tokens, so it is
- *                      WORD-level: "coffee" finds "Acme Coffee", "offee" does
- *                      not find anything
- *   before / after     ranges on a timestamp or a number
- *   isNotEmpty         `!= null`, which in Firestore also requires the field to
- *                      EXIST — which is the meaning wanted
- *
- * ⛔ `doesNotContain` is offered nowhere and cannot be. Firestore has no
- * negated substring match, and no denormalization fixes it: the inverse of a
- * token array is every string the value does not contain, which is unbounded.
- *
- * ⚠️ The two empty operators depend on how a field's WRITERS behave, which is
- * what `presence` declares. Firestore cannot query for absence at all:
- * `where(path, '==', null)` matches an explicit null and never a missing field,
- * while `where(path, '!=', null)` additionally requires the field to exist.
- * So a field that writers omit can answer `isNotEmpty` exactly and can never
- * answer `isEmpty` — it would say "none" to a question with real answers — and
- * a field that is always written answers both, but each with a foregone
- * result. Only a `nullable` field earns both operators for real.
- */
-/** How a field can be queried, which decides which operators it offers. */
-export type ListFilterKind = 'text' | 'exact' | 'boolean' | 'number' | 'date' | 'id';
-export interface ListFilterField {
-    /** The grid column's `field` — what the client sends back. */
-    column: string;
-    kind: ListFilterKind;
-    /** The Firestore field path the predicate targets. */
-    path: string;
-    /**
-     * The normalized lower-case twin, for `equals` and `startsWith` on text.
-     * Without one a text field offers neither: a raw value is case-sensitive, so
-     * it would miss rather than fail.
-     */
-    lowerPath?: string;
-    /** Word-prefix token array, for `contains`. */
-    tokensPath?: string;
-    /**
-     * The token array holds OPAQUE IDS, matched byte for byte.
-     *
-     * A word token array is lower-cased by its writer, so a `contains` folds
-     * the typed value the same way before it looks. An id array — the forms a
-     * contact came in through, the companies they are linked to — is not: the
-     * ids are minted with mixed case, and folding one would look up an id
-     * nothing wrote. A field that says so is matched on the value exactly as
-     * given, in the query and in memory alike.
-     */
-    verbatimTokens?: boolean;
-    /**
-     * What a `contains` orders by. Defaults to `lowerPath`, then `path`.
-     *
-     * A field whose `tokensPath` IS its own value — a real tag array, matched
-     * whole rather than by word prefix — has no lower-case twin to sort by, and
-     * defaulting to `path` would order by the array itself. Naming a scalar here
-     * keeps the composite index that combination needs an ordinary one.
-     */
-    containsOrderBy?: string;
-    /**
-     * Which way a `contains` orders by `containsOrderBy`. Ascending unless the
-     * field says otherwise; a list sorted newest-first orders its `contains`
-     * the same way, so the composite it needs is the one it already declares
-     * (AGL-3321).
-     */
-    containsOrderDirection?: 'asc' | 'desc';
-    /** The reversed key, for `endsWith`. */
-    reversedPath?: string;
-    /**
-     * How the field's writers treat "no value", which is the only thing that
-     * decides whether the empty operators mean anything:
-     *
-     *   `sparse`   (default) writers OMIT the field. `isNotEmpty` is exact;
-     *              `isEmpty` is unanswerable and so is not offered.
-     *   `nullable` writers store `null`. Both operators are exact and both can
-     *              return rows — the only case where offering them is useful.
-     *   `always`   the field is never absent and never null. Both operators have
-     *              a foregone answer (all rows, then none), so neither is
-     *              offered: a control whose result is known is a control that
-     *              wastes the reader's time.
-     */
-    presence?: 'sparse' | 'nullable' | 'always';
-    /**
-     * The operators this field offers, replacing the derived list.
-     *
-     * Not every list is a Firestore query. The staff account list is Firebase
-     * Auth, which cannot filter at ALL — so a filter there is answered by
-     * scanning the pools and matching in memory, and plain JavaScript can do
-     * things no index can: a mid-string `contains`, and `doesNotContain`. A
-     * list whose substrate is more capable says so here rather than being held
-     * to Firestore's limits by a shared default.
-     *
-     * Pair with {@link matchListFilter}, which is the matcher those lists use.
-     */
-    operators?: readonly string[];
-    /**
-     * Where to read this field from a ROW, when the list matches in memory.
-     * Defaults to `path`. Only needed when the row's shape differs from the
-     * document's — an Auth record's `staff` lives under `customClaims`.
-     */
-    rowPath?: string;
-    /**
-     * The field lives where no query can reach it, so the list matches it
-     * over the rows it has loaded and the translators refuse it.
-     *
-     * A contact's owner, stage and custom values sit on the viewing group's
-     * FACET — a map keyed per group — and a `where` on a per-group path would
-     * need an index per group. Declaring the field at all is what puts it in
-     * the menu and in a saved view; saying it is window-only is what keeps a
-     * clause on it from being sent to a query that would answer with a
-     * permission error or nothing. The list says which clauses narrowed only
-     * the window — see `listFilterPlan`.
-     */
-    windowOnly?: boolean;
-    /**
-     * A `date` field stored as epoch MILLISECONDS (`…AtMs`) rather than as a
-     * Timestamp. The query twins compare numbers for it, and the matcher reads
-     * both already (AGL-3321).
-     */
-    storedAs?: 'timestamp' | 'millis';
-    /**
-     * The stored value is a PRESENCE MAP — `{ form: true, order: true }` —
-     * and the filter asks about its keys.
-     *
-     * A contact's `sources` is such a map: one key per door the person came
-     * in through, never an array. Matched as though it were the array of its
-     * truthy keys, so `equals form` and `isAnyOf form,order` read the way a
-     * reader expects; a query can serve `equals` as `sources.form == true`.
-     */
-    keysOf?: boolean;
-}
-/** The operators a field offers, derived from the paths it actually has. */
-export declare function listFilterOperators(field: ListFilterField): string[];
-/** What a page sends the route: one field, one operator, one value. */
-export interface ListFilterRequest {
-    field: string;
-    op: string;
-    value: string;
-}
-/**
- * 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 declare function gridFilterRequest(model: {
-    items?: Array<{
-        field?: unknown;
-        operator?: unknown;
-        value?: unknown;
-    }>;
-}): ListFilterRequest | null;
-/**
- * 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 declare function gridFilterRequests(model: {
-    items?: Array<{
-        field?: unknown;
-        operator?: unknown;
-        value?: unknown;
-    }>;
-}): ListFilterRequest[];
-export { listFilterDay, listFilterOperatorLabel } from './list-filter-sentence';
-/**
- * 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 declare function matchListFilter(row: unknown, fields: readonly ListFilterField[], input: ListFilterRequest | null): boolean;
-/** The visibility model that hides what {@link hiddenFilterColumns} added. */
-export declare function hiddenFilterVisibility(fields: readonly ListFilterField[], visible: readonly string[]): Record<string, boolean>;
+export * from '@aglyn/shared-util-tools/list-query/list-filter';

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

@@ -13,287 +13,9 @@
  * 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 { listFilterDay } from "./list-filter-sentence.js";
-/** 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 [];
-    }
-}
-/** 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);
-}
-export { listFilterDay, listFilterOperatorLabel } from "./list-filter-sentence.js";
-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 = listFilterDay(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
-        ]));
-}
+ */ /*
+ * The list filter grammar lives in a pure module, so a surface with no web UI
+ * (the native app) plans the same queries; this path stays its web entry.
+ */ export * from "@aglyn/shared-util-tools/list-query/list-filter";
 
 //# sourceMappingURL=list-filter.js.map