@aglyn/plugins-data 1.0.0-beta.199 → 1.0.0-beta.200

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aglyn/plugins-data",
-  "version": "1.0.0-beta.199",
+  "version": "1.0.0-beta.200",
   "license": "Apache-2.0",
   "homepage": "https://aglyn.com",
   "repository": {
@@ -25,14 +25,14 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@aglyn/aglyn": "1.0.0-beta.199",
-    "@aglyn/shared-data-mdi": "1.0.0-beta.199",
-    "@aglyn/shared-ui-jsx": "1.0.0-beta.199",
-    "@aglyn/shared-ui-snackstack": "1.0.0-beta.199",
-    "@aglyn/shared-util-http": "1.0.0-beta.199",
-    "@aglyn/shared-util-timestamp": "1.0.0-beta.199",
-    "@aglyn/tenant-feature-instance": "1.0.0-beta.199",
-    "@aglyn/tenant-runtime": "1.0.0-beta.199",
+    "@aglyn/aglyn": "1.0.0-beta.200",
+    "@aglyn/shared-data-mdi": "1.0.0-beta.200",
+    "@aglyn/shared-ui-jsx": "1.0.0-beta.200",
+    "@aglyn/shared-ui-snackstack": "1.0.0-beta.200",
+    "@aglyn/shared-util-http": "1.0.0-beta.200",
+    "@aglyn/shared-util-timestamp": "1.0.0-beta.200",
+    "@aglyn/tenant-feature-instance": "1.0.0-beta.200",
+    "@aglyn/tenant-runtime": "1.0.0-beta.200",
     "@swc/helpers": "0.5.23"
   },
   "peerDependencies": {

package/src/lib/components/dataset-record-filter.d.ts

@@ -16,62 +16,58 @@
  */
 import { type DatasetModel } from '@aglyn/aglyn';
 import type { ListFilterField } from '@aglyn/shared-ui-jsx/const/list-filter';
-import { type ListFilterClause, type ListFilterOption } from '@aglyn/shared-ui-jsx/const/list-grid-filter';
-/**
- * How many records a filter the query cannot serve on its own is matched
- * over. Past it the card says the window was full; a single clause or a
- * single search word reaches every record without one.
- */
-export declare const RECORD_FILTER_WINDOW = 1000;
+import type { ListFilterClause, ListFilterOption } from '@aglyn/shared-ui-jsx/const/list-grid-filter';
+import { type ListQueryDeclaration, type ListQueryNormalizers, type ListQueryPlan } from '@aglyn/shared-ui-jsx/const/list-query-plan';
 /**
  * The grid column a dataset field is shown in. Prefixed, because field ids
  * are the dataset author's and may be any name, `actions` included.
  */
 export declare const recordColumn: (fieldId: string) => string;
+/**
+ * How the records' filter fields were normalized (`dataset-models.ts`): a
+ * typed text value becomes its `filterValues` key, and a search word its
+ * `s:` token — so the query asks for exactly what the writers stored.
+ */
+export declare const datasetRecordNormalizers: ListQueryNormalizers;
 /** What the records grid's Filters panel offers for one dataset model. */
 export interface DatasetRecordFilter {
+    /** The query declaration: every field below, the id order, the search. */
+    declaration: ListQueryDeclaration;
     fields: ListFilterField[];
     options: Record<string, ListFilterOption[]>;
     headers: Record<string, string>;
     selectFields: string[];
 }
 /**
- * The model's fields as filter fields, each reading the record row at
- * `values.<fieldId>`: an enum is a select over its options, a boolean a
- * true/false select, numbers and timestamps number and date fields, a list a
- * member match, and plain text a text field. References, maps, bytes,
- * coordinates and nil fields offer no filter.
+ * The model's fields as query fields, each shown in column
+ * `values.<fieldId>`:
+ *
+ *   enum text     picked: is, is any of          `filterValues.<id>`
+ *   plain text    contains (one word), equals,   `filterKeys`,
+ *                 is any of (ignoring case)      `filterValues.<id>`
+ *   bool          picked: is                     `filterValues.<id>`
+ *   numbers       =                              `filterValues.<id>`
+ *   list          contains (a whole member)      `filterKeys`
+ *
+ * Timestamps, references, maps, bytes, coordinates and nil fields offer no
+ * filter. A field whose id no query path can name (a v1 column with a `.`
+ * in it — `datasetFilterValuePath`) offers only its `contains`.
  */
 export declare function datasetRecordFilter(model: DatasetModel): DatasetRecordFilter;
-/** Which condition the query serves, and what is left to match in memory. */
-export interface RecordFilterPlan {
-    /** The `filterKeys` token the query narrows by, or null for the plain walk. */
-    token: string | null;
-    /** The column of the served clause; null when a search word is served. */
-    servedField: string | null;
-    /** Whether anything is left for the window to match. */
-    windowed: boolean;
-    /** Every token each token-served clause needs, by clause index. */
-    clauseTokens: Array<string[] | null>;
-    /** Every quick-search token, one per word. */
-    searchTokens: string[];
-    clauses: readonly ListFilterClause[];
+/** The records query, and what it says to the reader. */
+export interface DatasetRecordPlan {
+    plan: ListQueryPlan;
+    /** What was not put on the query, as the reader asked it, and why. */
+    refused: Array<{
+        clause: ListFilterClause | 'search';
+        reason: string;
+    }>;
+    /** What WAS served, where it differs from what was typed. */
+    notices: string[];
 }
 /**
- * The served condition is the first clause a token answers, else the first
- * search word; the walk is windowed whenever anything else is in force.
- */
-export declare function planRecordFilter(model: DatasetModel, clauses: readonly ListFilterClause[], searchWords: readonly string[]): RecordFilterPlan;
-/**
- * The window's records that answer every condition.
- *
- * A token-served clause and the quick search are matched by the SAME tokens
- * the query uses, computed from the record's values under the current model,
- * so a record answers in memory exactly when it would answer on the server —
- * a text `contains` is a word-prefix match either way. Everything else
- * (ranges, dates, empty checks, negations, `isAnyOf`) is matched by the
- * shared grammar over `values.<fieldId>`.
+ * The clauses and search words as ONE records query (`planListQuery`), with
+ * the refusals mapped back to the clauses as the reader typed them, and the
+ * notices said in the reader's words rather than as stored tokens.
  */
-export declare function matchRecordWindow<Row extends {
-    values?: Record<string, unknown>;
-}>(model: DatasetModel, fields: readonly ListFilterField[], rows: readonly Row[], plan: RecordFilterPlan): Row[];
+export declare function planRecordQuery(model: DatasetModel, filter: DatasetRecordFilter, clauses: readonly ListFilterClause[], searchWords: readonly string[]): DatasetRecordPlan;

package/src/lib/components/dataset-record-filter.js

@@ -1,3 +1,4 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
 /**
  * @license
  * Copyright 2026 Aglyn LLC
@@ -13,19 +14,65 @@
  * 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 { datasetFilterKeys, datasetFilterToken, datasetFilterTokens, datasetFilterWords, datasetSearchToken } from "@aglyn/aglyn";
-import { filterListRows, inMemoryListField } from "@aglyn/shared-ui-jsx/const/list-grid-filter";
-/**
- * How many records a filter the query cannot serve on its own is matched
- * over. Past it the card says the window was full; a single clause or a
- * single search word reaches every record without one.
- */ export const RECORD_FILTER_WINDOW = 1000;
+ */ import { DATASET_FILTER_PREFIX_MAX, datasetFilterTextKey, datasetFilterToken, datasetFilterValuePath, datasetFilterWords, datasetSearchToken } from "@aglyn/aglyn";
+import { LIST_QUERY_ID_PATH, planListQuery } from "@aglyn/shared-ui-jsx/const/list-query-plan";
+/*
+ * THE RECORDS TABLE IS ONE QUERY (AGL-3321).
+ *
+ * Every clause in the Filters panel and the quick-search word are
+ * predicates on the records query, planned by the shared `planListQuery`
+ * and answered by Firestore; nothing is matched over rows already loaded.
+ *
+ * A record's fields live under `values`, which is exempt from indexing (see
+ * `datasetFilterKeys`), so the query reads the two fields every writer
+ * stamps beside it:
+ *
+ *   `filterValues.<fieldId> ==`       an equality — a picked option, a
+ *                                     boolean, a number, plain text (by its
+ *                                     lower-cased key);
+ *   `filterKeys array-contains`       ONE word-level clause — a text
+ *                                     `contains` (`f:<id>^<prefix>`), a list
+ *                                     member (`f:<id>=<member>`), or the
+ *                                     quick-search word (`s:<prefix>`).
+ *
+ * Firestore's automatic single-field indexes compose any number of those
+ * equalities and one `array-contains` under `orderBy(documentId())` by index
+ * merging, so the table needs NO composite index — which it could not have:
+ * every dataset's fields are its author's, and a composite per field per
+ * dataset is not something an index file can list.
+ *
+ * What one such query cannot hold is not offered, or refused by name:
+ *
+ *   - no ranges. `>` on a number or a date on a timestamp is one inequality,
+ *     which must then lead the order, and beside any equality it needs a
+ *     composite per dataset. Numbers offer `=`, timestamps nothing.
+ *   - no negations and no empty checks: Firestore has neither for a field a
+ *     writer omits.
+ *   - one array clause: a `contains` beside the search, or a second
+ *     `contains`, is refused through `ListQueryNotices`, never half-applied.
+ *   - one word of a `contains` or a search: the first word is asked, and the
+ *     table says so for the rest.
+ */ /** The array the word-level clauses and the quick search ask. */ const TOKENS_PATH = 'filterKeys';
 /**
  * The grid column a dataset field is shown in. Prefixed, because field ids
  * are the dataset author's and may be any name, `actions` included.
  */ export const recordColumn = (fieldId)=>`values.${fieldId}`;
 const COLUMN_PREFIX = recordColumn('');
 const fieldIdOf = (column)=>column.startsWith(COLUMN_PREFIX) ? column.slice(COLUMN_PREFIX.length) : column;
+/**
+ * How the records' filter fields were normalized (`dataset-models.ts`): a
+ * typed text value becomes its `filterValues` key, and a search word its
+ * `s:` token — so the query asks for exactly what the writers stored.
+ */ export const datasetRecordNormalizers = {
+    key: datasetFilterTextKey,
+    token: (value)=>{
+        var _datasetSearchToken;
+        return (_datasetSearchToken = datasetSearchToken(value)) != null ? _datasetSearchToken : '';
+    },
+    // No field offers `endsWith`, so nothing is ever reversed.
+    reversed: (value)=>value,
+    maxPrefix: DATASET_FILTER_PREFIX_MAX
+};
 const BOOLEAN_OPTIONS = [
     {
         value: 'true',
@@ -37,11 +84,19 @@ const BOOLEAN_OPTIONS = [
     }
 ];
 /**
- * The model's fields as filter fields, each reading the record row at
- * `values.<fieldId>`: an enum is a select over its options, a boolean a
- * true/false select, numbers and timestamps number and date fields, a list a
- * member match, and plain text a text field. References, maps, bytes,
- * coordinates and nil fields offer no filter.
+ * The model's fields as query fields, each shown in column
+ * `values.<fieldId>`:
+ *
+ *   enum text     picked: is, is any of          `filterValues.<id>`
+ *   plain text    contains (one word), equals,   `filterKeys`,
+ *                 is any of (ignoring case)      `filterValues.<id>`
+ *   bool          picked: is                     `filterValues.<id>`
+ *   numbers       =                              `filterValues.<id>`
+ *   list          contains (a whole member)      `filterKeys`
+ *
+ * Timestamps, references, maps, bytes, coordinates and nil fields offer no
+ * filter. A field whose id no query path can name (a v1 column with a `.`
+ * in it — `datasetFilterValuePath`) offers only its `contains`.
  */ export function datasetRecordFilter(model) {
     var _model_order;
     const fields = [];
@@ -54,35 +109,75 @@ const BOOLEAN_OPTIONS = [
         const field = (_model_fields = model.fields) == null ? void 0 : _model_fields[fieldId];
         if (!field) continue;
         const column = recordColumn(fieldId);
+        const valuePath = datasetFilterValuePath(fieldId);
         const choices = field.type === 'text' ? (_ref = (_field_validation = field.validation) == null ? void 0 : _field_validation.options) != null ? _ref : [] : [];
         let declared = null;
         if (field.type === 'text' && choices.length) {
-            declared = inMemoryListField(column, 'select');
-            options[column] = choices.map((choice)=>({
-                    value: choice,
-                    label: choice
-                }));
+            if (valuePath) {
+                declared = {
+                    column,
+                    kind: 'exact',
+                    path: valuePath,
+                    operators: [
+                        'equals',
+                        'isAnyOf'
+                    ]
+                };
+                options[column] = choices.map((choice)=>({
+                        value: choice,
+                        label: choice
+                    }));
+            }
         } else if (field.type === 'text') {
-            declared = inMemoryListField(column, 'text');
+            // A `contains` asks the token the clause's value is turned into
+            // (`recordQueryClause`), matched as given.
+            declared = _extends({
+                column,
+                kind: 'text',
+                path: valuePath != null ? valuePath : column,
+                tokensPath: TOKENS_PATH,
+                verbatimTokens: true
+            }, valuePath ? {
+                lowerPath: valuePath
+            } : {}, {
+                operators: valuePath ? [
+                    'contains',
+                    'equals',
+                    'isAnyOf'
+                ] : [
+                    'contains'
+                ]
+            });
         } else if (field.type === 'bool') {
-            declared = inMemoryListField(column, 'select');
-            options[column] = BOOLEAN_OPTIONS;
+            if (valuePath) {
+                declared = {
+                    column,
+                    kind: 'boolean',
+                    path: valuePath,
+                    operators: [
+                        'equals'
+                    ]
+                };
+                options[column] = BOOLEAN_OPTIONS;
+            }
         } else if (field.type === 'int32' || field.type === 'int64' || field.type === 'float') {
-            declared = inMemoryListField(column, 'number');
-        } else if (field.type === 'timestamp') {
-            declared = inMemoryListField(column, 'date');
+            if (valuePath) declared = {
+                column,
+                kind: 'number',
+                path: valuePath,
+                operators: [
+                    '='
+                ]
+            };
         } else if (field.type === 'sorted') {
-            // A list matches by whole member, as its `=` tokens do.
             declared = {
                 column,
-                path: column,
                 kind: 'text',
-                tokensPath: column,
+                path: column,
+                tokensPath: TOKENS_PATH,
                 verbatimTokens: true,
                 operators: [
-                    'contains',
-                    'isEmpty',
-                    'isNotEmpty'
+                    'contains'
                 ]
             };
         }
@@ -92,63 +187,95 @@ const BOOLEAN_OPTIONS = [
         if (options[column]) selectFields.push(column);
     }
     return {
+        declaration: {
+            fields,
+            // The document name: the one order no record can be missing (see the
+            // card), and the one every automatic index already ends in.
+            sorts: [
+                {
+                    path: LIST_QUERY_ID_PATH,
+                    direction: 'asc'
+                }
+            ],
+            search: {
+                tokensPath: TOKENS_PATH
+            }
+        },
         fields,
         options,
         headers,
         selectFields
     };
 }
-const asFieldClause = (clause)=>({
-        field: fieldIdOf(clause.field),
+/**
+ * A clause as the query asks it: a `contains` becomes the `filterKeys`
+ * token of its first word (text) or of its member (list). Everything else
+ * goes as typed — the planner applies the text key, the number, the boolean.
+ */ function recordQueryClause(model, clause) {
+    if (clause.op !== 'contains') return {
+        field: clause.field,
         op: clause.op,
         value: clause.value
+    };
+    const token = datasetFilterToken(model, {
+        field: fieldIdOf(clause.field),
+        op: 'contains',
+        value: clause.value
     });
-/**
- * The served condition is the first clause a token answers, else the first
- * search word; the walk is windowed whenever anything else is in force.
- */ export function planRecordFilter(model, clauses, searchWords) {
-    var _searchTokens_;
-    var _clauseTokens_servedAt;
-    const clauseTokens = clauses.map((clause)=>datasetFilterTokens(model, asFieldClause(clause)));
-    const searchTokens = [
-        ...new Set(searchWords.flatMap((word)=>datasetFilterWords(word)).map((word)=>datasetSearchToken(word)).filter((token)=>Boolean(token)))
-    ];
-    const servedAt = clauses.findIndex((clause)=>Boolean(datasetFilterToken(model, asFieldClause(clause))));
-    const token = servedAt >= 0 ? datasetFilterToken(model, asFieldClause(clauses[servedAt])) : (_searchTokens_ = searchTokens[0]) != null ? _searchTokens_ : null;
-    const complete = servedAt >= 0 ? clauses.length === 1 && searchTokens.length === 0 && ((_clauseTokens_servedAt = clauseTokens[servedAt]) == null ? void 0 : _clauseTokens_servedAt.length) === 1 : clauses.length === 0 && searchTokens.length <= 1;
     return {
-        token,
-        servedField: servedAt >= 0 ? clauses[servedAt].field : null,
-        windowed: !complete,
-        clauseTokens,
-        searchTokens,
-        clauses
+        field: clause.field,
+        op: clause.op,
+        value: token != null ? token : ''
     };
 }
+const clipWord = (word)=>Array.from(word).slice(0, DATASET_FILTER_PREFIX_MAX).join('');
 /**
- * The window's records that answer every condition.
- *
- * A token-served clause and the quick search are matched by the SAME tokens
- * the query uses, computed from the record's values under the current model,
- * so a record answers in memory exactly when it would answer on the server —
- * a text `contains` is a word-prefix match either way. Everything else
- * (ranges, dates, empty checks, negations, `isAnyOf`) is matched by the
- * shared grammar over `values.<fieldId>`.
- */ export function matchRecordWindow(model, fields, rows, plan) {
-    const served = new Set(plan.clauses.filter((_clause, at)=>plan.clauseTokens[at] !== null));
-    const needed = [
-        ...plan.clauseTokens.flatMap((tokens)=>tokens != null ? tokens : []),
-        ...plan.searchTokens
-    ];
-    const rest = filterListRows(rows, fields, plan.clauses, {
-        paths: [],
-        words: []
-    }, (clause)=>served.has(clause));
-    if (!needed.length) return rest;
-    return rest.filter((row)=>{
-        const keys = new Set(datasetFilterKeys(model, row.values));
-        return needed.every((token)=>keys.has(token));
+ * The clauses and search words as ONE records query (`planListQuery`), with
+ * the refusals mapped back to the clauses as the reader typed them, and the
+ * notices said in the reader's words rather than as stored tokens.
+ */ export function planRecordQuery(model, filter, clauses, searchWords) {
+    const asked = new Map();
+    const queryClauses = clauses.map((clause)=>{
+        const queryClause = recordQueryClause(model, clause);
+        asked.set(queryClause, clause);
+        return queryClause;
+    });
+    const plan = planListQuery(filter.declaration, {
+        clauses: queryClauses,
+        search: searchWords
+    }, datasetRecordNormalizers);
+    const refused = plan.refused.map((entry)=>{
+        var _asked_get;
+        return {
+            clause: entry.clause === 'search' ? 'search' : (_asked_get = asked.get(entry.clause)) != null ? _asked_get : entry.clause,
+            reason: entry.reason
+        };
     });
+    const notices = [];
+    const oneWord = (label, text)=>{
+        const words = datasetFilterWords(text);
+        if (words.length > 1) {
+            notices.push(`${label} matches one word at a time: showing records with a word starting "${clipWord(words[0])}".`);
+        }
+        if (words.some((word)=>Array.from(word).length > DATASET_FILTER_PREFIX_MAX)) {
+            notices.push(`${label} reads the first ${DATASET_FILTER_PREFIX_MAX} letters of a word.`);
+        }
+    };
+    if (plan.searched) oneWord('Search', searchWords.join(' '));
+    for (const served of plan.served){
+        var _filter_headers_clause_field;
+        var _model_fields_fieldIdOf, _model_fields;
+        const clause = asked.get(served);
+        // A list's `contains` is a whole member; only text is asked by word.
+        if ((clause == null ? void 0 : clause.op) !== 'contains') continue;
+        if (((_model_fields = model.fields) == null ? void 0 : (_model_fields_fieldIdOf = _model_fields[fieldIdOf(clause.field)]) == null ? void 0 : _model_fields_fieldIdOf.type) !== 'text') continue;
+        oneWord(`${(_filter_headers_clause_field = filter.headers[clause.field]) != null ? _filter_headers_clause_field : clause.field} contains`, clause.value);
+    }
+    return {
+        plan,
+        refused,
+        notices
+    };
 }
 
 //# sourceMappingURL=dataset-record-filter.js.map

package/src/lib/components/dataset-record-filter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/plugins/data/src/lib/components/dataset-record-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  type DatasetModel,\n  datasetFilterKeys,\n  datasetFilterToken,\n  datasetFilterTokens,\n  datasetFilterWords,\n  datasetSearchToken,\n} from '@aglyn/aglyn'\nimport type { ListFilterField } from '@aglyn/shared-ui-jsx/const/list-filter'\nimport {\n  filterListRows,\n  inMemoryListField,\n  type ListFilterClause,\n  type ListFilterOption,\n} from '@aglyn/shared-ui-jsx/const/list-grid-filter'\n\n/**\n * How many records a filter the query cannot serve on its own is matched\n * over. Past it the card says the window was full; a single clause or a\n * single search word reaches every record without one.\n */\nexport const RECORD_FILTER_WINDOW = 1000\n\n/**\n * The grid column a dataset field is shown in. Prefixed, because field ids\n * are the dataset author's and may be any name, `actions` included.\n */\nexport const recordColumn = (fieldId: string) => `values.${fieldId}`\nconst COLUMN_PREFIX = recordColumn('')\nconst fieldIdOf = (column: string) =>\n  column.startsWith(COLUMN_PREFIX) ? column.slice(COLUMN_PREFIX.length) : column\n\n/** What the records grid's Filters panel offers for one dataset model. */\nexport interface DatasetRecordFilter {\n  fields: ListFilterField[]\n  options: Record<string, ListFilterOption[]>\n  headers: Record<string, string>\n  selectFields: string[]\n}\n\nconst BOOLEAN_OPTIONS: ListFilterOption[] = [\n  { value: 'true', label: 'True' },\n  { value: 'false', label: 'False' },\n]\n\n/**\n * The model's fields as filter fields, each reading the record row at\n * `values.<fieldId>`: an enum is a select over its options, a boolean a\n * true/false select, numbers and timestamps number and date fields, a list a\n * member match, and plain text a text field. References, maps, bytes,\n * coordinates and nil fields offer no filter.\n */\nexport function datasetRecordFilter(model: DatasetModel): DatasetRecordFilter {\n  const fields: ListFilterField[] = []\n  const options: Record<string, ListFilterOption[]> = {}\n  const headers: Record<string, string> = {}\n  const selectFields: string[] = []\n  for (const fieldId of model.order ?? []) {\n    const field = model.fields?.[fieldId]\n    if (!field) continue\n    const column = recordColumn(fieldId)\n    const choices = field.type === 'text' ? (field.validation?.options ?? []) : []\n    let declared: ListFilterField | null = null\n    if (field.type === 'text' && choices.length) {\n      declared = inMemoryListField(column, 'select')\n      options[column] = choices.map((choice) => ({ value: choice, label: choice }))\n    } else if (field.type === 'text') {\n      declared = inMemoryListField(column, 'text')\n    } else if (field.type === 'bool') {\n      declared = inMemoryListField(column, 'select')\n      options[column] = BOOLEAN_OPTIONS\n    } else if (field.type === 'int32' || field.type === 'int64' || field.type === 'float') {\n      declared = inMemoryListField(column, 'number')\n    } else if (field.type === 'timestamp') {\n      declared = inMemoryListField(column, 'date')\n    } else if (field.type === 'sorted') {\n      // A list matches by whole member, as its `=` tokens do.\n      declared = {\n        column,\n        path: column,\n        kind: 'text',\n        tokensPath: column,\n        verbatimTokens: true,\n        operators: ['contains', 'isEmpty', 'isNotEmpty'],\n      }\n    }\n    if (!declared) continue\n    fields.push(declared)\n    headers[column] = field.name || fieldId\n    if (options[column]) selectFields.push(column)\n  }\n  return { fields, options, headers, selectFields }\n}\n\n/** Which condition the query serves, and what is left to match in memory. */\nexport interface RecordFilterPlan {\n  /** The `filterKeys` token the query narrows by, or null for the plain walk. */\n  token: string | null\n  /** The column of the served clause; null when a search word is served. */\n  servedField: string | null\n  /** Whether anything is left for the window to match. */\n  windowed: boolean\n  /** Every token each token-served clause needs, by clause index. */\n  clauseTokens: Array<string[] | null>\n  /** Every quick-search token, one per word. */\n  searchTokens: string[]\n  clauses: readonly ListFilterClause[]\n}\n\nconst asFieldClause = (clause: ListFilterClause) => ({\n  field: fieldIdOf(clause.field),\n  op: clause.op,\n  value: clause.value,\n})\n\n/**\n * The served condition is the first clause a token answers, else the first\n * search word; the walk is windowed whenever anything else is in force.\n */\nexport function planRecordFilter(\n  model: DatasetModel,\n  clauses: readonly ListFilterClause[],\n  searchWords: readonly string[],\n): RecordFilterPlan {\n  const clauseTokens = clauses.map((clause) =>\n    datasetFilterTokens(model, asFieldClause(clause)),\n  )\n  const searchTokens = [\n    ...new Set(\n      searchWords\n        .flatMap((word) => datasetFilterWords(word))\n        .map((word) => datasetSearchToken(word))\n        .filter((token): token is string => Boolean(token)),\n    ),\n  ]\n  const servedAt = clauses.findIndex((clause) =>\n    Boolean(datasetFilterToken(model, asFieldClause(clause))),\n  )\n  const token =\n    servedAt >= 0\n      ? datasetFilterToken(model, asFieldClause(clauses[servedAt]))\n      : (searchTokens[0] ?? null)\n  const complete =\n    servedAt >= 0\n      ? clauses.length === 1 &&\n        searchTokens.length === 0 &&\n        clauseTokens[servedAt]?.length === 1\n      : clauses.length === 0 && searchTokens.length <= 1\n  return {\n    token,\n    servedField: servedAt >= 0 ? clauses[servedAt].field : null,\n    windowed: !complete,\n    clauseTokens,\n    searchTokens,\n    clauses,\n  }\n}\n\n/**\n * The window's records that answer every condition.\n *\n * A token-served clause and the quick search are matched by the SAME tokens\n * the query uses, computed from the record's values under the current model,\n * so a record answers in memory exactly when it would answer on the server —\n * a text `contains` is a word-prefix match either way. Everything else\n * (ranges, dates, empty checks, negations, `isAnyOf`) is matched by the\n * shared grammar over `values.<fieldId>`.\n */\nexport function matchRecordWindow<Row extends { values?: Record<string, unknown> }>(\n  model: DatasetModel,\n  fields: readonly ListFilterField[],\n  rows: readonly Row[],\n  plan: RecordFilterPlan,\n): Row[] {\n  const served = new Set(\n    plan.clauses.filter((_clause, at) => plan.clauseTokens[at] !== null),\n  )\n  const needed = [\n    ...plan.clauseTokens.flatMap((tokens) => tokens ?? []),\n    ...plan.searchTokens,\n  ]\n  const rest = filterListRows(\n    rows,\n    fields,\n    plan.clauses,\n    { paths: [], words: [] },\n    (clause) => served.has(clause),\n  )\n  if (!needed.length) return rest\n  return rest.filter((row) => {\n    const keys = new Set(datasetFilterKeys(model, row.values))\n    return needed.every((token) => keys.has(token))\n  })\n}\n"],"names":["datasetFilterKeys","datasetFilterToken","datasetFilterTokens","datasetFilterWords","datasetSearchToken","filterListRows","inMemoryListField","RECORD_FILTER_WINDOW","recordColumn","fieldId","COLUMN_PREFIX","fieldIdOf","column","startsWith","slice","length","BOOLEAN_OPTIONS","value","label","datasetRecordFilter","model","fields","options","headers","selectFields","order","field","choices","type","validation","declared","map","choice","path","kind","tokensPath","verbatimTokens","operators","push","name","asFieldClause","clause","op","planRecordFilter","clauses","searchWords","searchTokens","clauseTokens","Set","flatMap","word","filter","token","Boolean","servedAt","findIndex","complete","servedField","windowed","matchRecordWindow","rows","plan","served","_clause","at","needed","tokens","rest","paths","words","has","row","keys","values","every"],"mappings":"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"}
+{"version":3,"sources":["../../../../../../../libs/plugins/data/src/lib/components/dataset-record-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  DATASET_FILTER_PREFIX_MAX,\n  type DatasetModel,\n  datasetFilterTextKey,\n  datasetFilterToken,\n  datasetFilterValuePath,\n  datasetFilterWords,\n  datasetSearchToken,\n} from '@aglyn/aglyn'\nimport type { ListFilterField, ListFilterRequest } from '@aglyn/shared-ui-jsx/const/list-filter'\nimport type {\n  ListFilterClause,\n  ListFilterOption,\n} from '@aglyn/shared-ui-jsx/const/list-grid-filter'\nimport {\n  LIST_QUERY_ID_PATH,\n  type ListQueryDeclaration,\n  type ListQueryNormalizers,\n  type ListQueryPlan,\n  planListQuery,\n} from '@aglyn/shared-ui-jsx/const/list-query-plan'\n\n/*\n * THE RECORDS TABLE IS ONE QUERY (AGL-3321).\n *\n * Every clause in the Filters panel and the quick-search word are\n * predicates on the records query, planned by the shared `planListQuery`\n * and answered by Firestore; nothing is matched over rows already loaded.\n *\n * A record's fields live under `values`, which is exempt from indexing (see\n * `datasetFilterKeys`), so the query reads the two fields every writer\n * stamps beside it:\n *\n *   `filterValues.<fieldId> ==`       an equality — a picked option, a\n *                                     boolean, a number, plain text (by its\n *                                     lower-cased key);\n *   `filterKeys array-contains`       ONE word-level clause — a text\n *                                     `contains` (`f:<id>^<prefix>`), a list\n *                                     member (`f:<id>=<member>`), or the\n *                                     quick-search word (`s:<prefix>`).\n *\n * Firestore's automatic single-field indexes compose any number of those\n * equalities and one `array-contains` under `orderBy(documentId())` by index\n * merging, so the table needs NO composite index — which it could not have:\n * every dataset's fields are its author's, and a composite per field per\n * dataset is not something an index file can list.\n *\n * What one such query cannot hold is not offered, or refused by name:\n *\n *   - no ranges. `>` on a number or a date on a timestamp is one inequality,\n *     which must then lead the order, and beside any equality it needs a\n *     composite per dataset. Numbers offer `=`, timestamps nothing.\n *   - no negations and no empty checks: Firestore has neither for a field a\n *     writer omits.\n *   - one array clause: a `contains` beside the search, or a second\n *     `contains`, is refused through `ListQueryNotices`, never half-applied.\n *   - one word of a `contains` or a search: the first word is asked, and the\n *     table says so for the rest.\n */\n\n/** The array the word-level clauses and the quick search ask. */\nconst TOKENS_PATH = 'filterKeys'\n\n/**\n * The grid column a dataset field is shown in. Prefixed, because field ids\n * are the dataset author's and may be any name, `actions` included.\n */\nexport const recordColumn = (fieldId: string) => `values.${fieldId}`\nconst COLUMN_PREFIX = recordColumn('')\nconst fieldIdOf = (column: string) =>\n  column.startsWith(COLUMN_PREFIX) ? column.slice(COLUMN_PREFIX.length) : column\n\n/**\n * How the records' filter fields were normalized (`dataset-models.ts`): a\n * typed text value becomes its `filterValues` key, and a search word its\n * `s:` token — so the query asks for exactly what the writers stored.\n */\nexport const datasetRecordNormalizers: ListQueryNormalizers = {\n  key: datasetFilterTextKey,\n  token: (value) => datasetSearchToken(value) ?? '',\n  // No field offers `endsWith`, so nothing is ever reversed.\n  reversed: (value) => value,\n  maxPrefix: DATASET_FILTER_PREFIX_MAX,\n}\n\n/** What the records grid's Filters panel offers for one dataset model. */\nexport interface DatasetRecordFilter {\n  /** The query declaration: every field below, the id order, the search. */\n  declaration: ListQueryDeclaration\n  fields: ListFilterField[]\n  options: Record<string, ListFilterOption[]>\n  headers: Record<string, string>\n  selectFields: string[]\n}\n\nconst BOOLEAN_OPTIONS: ListFilterOption[] = [\n  { value: 'true', label: 'True' },\n  { value: 'false', label: 'False' },\n]\n\n/**\n * The model's fields as query fields, each shown in column\n * `values.<fieldId>`:\n *\n *   enum text     picked: is, is any of          `filterValues.<id>`\n *   plain text    contains (one word), equals,   `filterKeys`,\n *                 is any of (ignoring case)      `filterValues.<id>`\n *   bool          picked: is                     `filterValues.<id>`\n *   numbers       =                              `filterValues.<id>`\n *   list          contains (a whole member)      `filterKeys`\n *\n * Timestamps, references, maps, bytes, coordinates and nil fields offer no\n * filter. A field whose id no query path can name (a v1 column with a `.`\n * in it — `datasetFilterValuePath`) offers only its `contains`.\n */\nexport function datasetRecordFilter(model: DatasetModel): DatasetRecordFilter {\n  const fields: ListFilterField[] = []\n  const options: Record<string, ListFilterOption[]> = {}\n  const headers: Record<string, string> = {}\n  const selectFields: string[] = []\n  for (const fieldId of model.order ?? []) {\n    const field = model.fields?.[fieldId]\n    if (!field) continue\n    const column = recordColumn(fieldId)\n    const valuePath = datasetFilterValuePath(fieldId)\n    const choices = field.type === 'text' ? (field.validation?.options ?? []) : []\n    let declared: ListFilterField | null = null\n    if (field.type === 'text' && choices.length) {\n      if (valuePath) {\n        declared = { column, kind: 'exact', path: valuePath, operators: ['equals', 'isAnyOf'] }\n        options[column] = choices.map((choice) => ({ value: choice, label: choice }))\n      }\n    } else if (field.type === 'text') {\n      // A `contains` asks the token the clause's value is turned into\n      // (`recordQueryClause`), matched as given.\n      declared = {\n        column,\n        kind: 'text',\n        path: valuePath ?? column,\n        tokensPath: TOKENS_PATH,\n        verbatimTokens: true,\n        ...(valuePath ? { lowerPath: valuePath } : {}),\n        operators: valuePath ? ['contains', 'equals', 'isAnyOf'] : ['contains'],\n      }\n    } else if (field.type === 'bool') {\n      if (valuePath) {\n        declared = { column, kind: 'boolean', path: valuePath, operators: ['equals'] }\n        options[column] = BOOLEAN_OPTIONS\n      }\n    } else if (field.type === 'int32' || field.type === 'int64' || field.type === 'float') {\n      if (valuePath) declared = { column, kind: 'number', path: valuePath, operators: ['='] }\n    } else if (field.type === 'sorted') {\n      declared = {\n        column,\n        kind: 'text',\n        path: column,\n        tokensPath: TOKENS_PATH,\n        verbatimTokens: true,\n        operators: ['contains'],\n      }\n    }\n    if (!declared) continue\n    fields.push(declared)\n    headers[column] = field.name || fieldId\n    if (options[column]) selectFields.push(column)\n  }\n  return {\n    declaration: {\n      fields,\n      // The document name: the one order no record can be missing (see the\n      // card), and the one every automatic index already ends in.\n      sorts: [{ path: LIST_QUERY_ID_PATH, direction: 'asc' }],\n      search: { tokensPath: TOKENS_PATH },\n    },\n    fields,\n    options,\n    headers,\n    selectFields,\n  }\n}\n\n/**\n * A clause as the query asks it: a `contains` becomes the `filterKeys`\n * token of its first word (text) or of its member (list). Everything else\n * goes as typed — the planner applies the text key, the number, the boolean.\n */\nfunction recordQueryClause(model: DatasetModel, clause: ListFilterClause): ListFilterRequest {\n  if (clause.op !== 'contains') return { field: clause.field, op: clause.op, value: clause.value }\n  const token = datasetFilterToken(model, {\n    field: fieldIdOf(clause.field),\n    op: 'contains',\n    value: clause.value,\n  })\n  return { field: clause.field, op: clause.op, value: token ?? '' }\n}\n\nconst clipWord = (word: string) =>\n  Array.from(word).slice(0, DATASET_FILTER_PREFIX_MAX).join('')\n\n/** The records query, and what it says to the reader. */\nexport interface DatasetRecordPlan {\n  plan: ListQueryPlan\n  /** What was not put on the query, as the reader asked it, and why. */\n  refused: Array<{ clause: ListFilterClause | 'search'; reason: string }>\n  /** What WAS served, where it differs from what was typed. */\n  notices: string[]\n}\n\n/**\n * The clauses and search words as ONE records query (`planListQuery`), with\n * the refusals mapped back to the clauses as the reader typed them, and the\n * notices said in the reader's words rather than as stored tokens.\n */\nexport function planRecordQuery(\n  model: DatasetModel,\n  filter: DatasetRecordFilter,\n  clauses: readonly ListFilterClause[],\n  searchWords: readonly string[],\n): DatasetRecordPlan {\n  const asked = new Map<ListFilterRequest, ListFilterClause>()\n  const queryClauses = clauses.map((clause) => {\n    const queryClause = recordQueryClause(model, clause)\n    asked.set(queryClause, clause)\n    return queryClause\n  })\n  const plan = planListQuery(\n    filter.declaration,\n    { clauses: queryClauses, search: searchWords },\n    datasetRecordNormalizers,\n  )\n  const refused = plan.refused.map((entry) => ({\n    clause: entry.clause === 'search' ? ('search' as const) : (asked.get(entry.clause) ?? entry.clause),\n    reason: entry.reason,\n  }))\n\n  const notices: string[] = []\n  const oneWord = (label: string, text: string) => {\n    const words = datasetFilterWords(text)\n    if (words.length > 1) {\n      notices.push(\n        `${label} matches one word at a time: showing records with a word starting \"${clipWord(words[0])}\".`,\n      )\n    }\n    if (words.some((word) => Array.from(word).length > DATASET_FILTER_PREFIX_MAX)) {\n      notices.push(`${label} reads the first ${DATASET_FILTER_PREFIX_MAX} letters of a word.`)\n    }\n  }\n  if (plan.searched) oneWord('Search', searchWords.join(' '))\n  for (const served of plan.served) {\n    const clause = asked.get(served)\n    // A list's `contains` is a whole member; only text is asked by word.\n    if (clause?.op !== 'contains') continue\n    if (model.fields?.[fieldIdOf(clause.field)]?.type !== 'text') continue\n    oneWord(`${filter.headers[clause.field] ?? clause.field} contains`, clause.value)\n  }\n  return { plan, refused, notices }\n}\n"],"names":["DATASET_FILTER_PREFIX_MAX","datasetFilterTextKey","datasetFilterToken","datasetFilterValuePath","datasetFilterWords","datasetSearchToken","LIST_QUERY_ID_PATH","planListQuery","TOKENS_PATH","recordColumn","fieldId","COLUMN_PREFIX","fieldIdOf","column","startsWith","slice","length","datasetRecordNormalizers","key","token","value","reversed","maxPrefix","BOOLEAN_OPTIONS","label","datasetRecordFilter","model","fields","options","headers","selectFields","order","field","valuePath","choices","type","validation","declared","kind","path","operators","map","choice","tokensPath","verbatimTokens","lowerPath","push","name","declaration","sorts","direction","search","recordQueryClause","clause","op","clipWord","word","Array","from","join","planRecordQuery","filter","clauses","searchWords","asked","Map","queryClauses","queryClause","set","plan","refused","entry","get","reason","notices","oneWord","text","words","some","searched","served"],"mappings":"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"}