@ahoo-wang/wow-view-engine 9.2.0-rc.0

package/dist/filter/kinds/deletion.d.ts

@@ -0,0 +1,42 @@
+import { DeletionState } from '@ahoo-wang/wow-client';
+import { FieldDefinition, FilterTree } from '../../model/index.js';
+import { FilterSummaryItem } from '../describe.js';
+import { FieldKind, FieldKindRegistry } from '../fieldKind.js';
+/** The three readings Wow's `DELETION` filter admits, in the order offered. */
+export declare const DELETION_STATES: readonly DeletionState[];
+export declare function isDeletionState(value: unknown): value is DeletionState;
+/**
+ * Whether soft-deleted records are shown: Wow's `DELETION` filter, as a
+ * dimension a definition declares (D4) rather than one every view carries.
+ *
+ * A Wow source answers a query with the records that are not deleted unless
+ * the query says otherwise, and that is the whole point of declaring this
+ * kind: a list that silently mixed deleted records into the live ones would
+ * be a wrong number said with confidence. Declared, it is a condition like
+ * any other — a field in the picker, a pill with one operator and three
+ * answers, a badge on the applied bar. Undeclared, nothing on screen says
+ * "deleted", because the definition did not make it the user's to decide.
+ *
+ * The default reading is D17-2: **not deleted**, for a view whose config
+ * never wrote this condition — an old config, a fresh one, a pill left
+ * blank — and the applied bar says so (`impliedDeletion`), because a reading
+ * in force that nobody wrote is still in force. "Deleted only" and "deleted
+ * included" are explicit choices.
+ *
+ * Fieldless, like the metadata kinds beside it: the field's `name` is a
+ * handle for the editor and the label, and it compiles to a filter that
+ * names no document field.
+ */
+export declare const deletionFieldKind: FieldKind;
+/**
+ * The deletion reading in force that nobody wrote (D17-2).
+ *
+ * For every declared deletion field that no tree in `trees` — the view's
+ * own conditions as they ran, the host's scope — answers with a value, the
+ * source's default applies: not deleted. The bar shows it beside the
+ * conditions that were written, with no way to remove it, because it is
+ * not a condition in the config; adding the field and choosing otherwise
+ * is how it changes.
+ */
+export declare function impliedDeletion(fields: readonly FieldDefinition[], trees: readonly (FilterTree | null | undefined)[], kinds: FieldKindRegistry): FilterSummaryItem[];
+//# sourceMappingURL=deletion.d.ts.map

package/dist/filter/kinds/deletion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deletion.d.ts","sourceRoot":"","sources":["../../../src/filter/kinds/deletion.ts"],"names":[],"mappings":"AAaA,OAAO,EACL,aAAa,EAGd,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,iBAAiB,EACvB,MAAM,iBAAiB,CAAC;AAGzB,+EAA+E;AAC/E,eAAO,MAAM,eAAe,EAAE,SAAS,aAAa,EAInD,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAiC/B,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,SAAS,eAAe,EAAE,EAClC,KAAK,EAAE,SAAS,CAAC,UAAU,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EACjD,KAAK,EAAE,iBAAiB,GACvB,iBAAiB,EAAE,CAwBrB"}

package/dist/filter/kinds/duration.d.ts

@@ -0,0 +1,27 @@
+import { FilterExpression } from '@ahoo-wang/wow-client';
+import { FieldDefinition, FilterOperatorName, Issue, IssuePath } from '../../model/index.js';
+import { FieldKindDescription } from '../describe.js';
+/**
+ * A time since another moment (N3, Wow's `EXPRESSION` over a `DATE_DIFF`),
+ * as a time field's own condition: the field is the later moment, the value
+ * names the earlier one, how the time between them compares, and the unit.
+ * Offered by the time kinds; the descriptor takes it away where the entry
+ * lists no `EXPRESSION` among its root operators.
+ */
+export declare const DURATION_OPERATOR: FilterOperatorName;
+export declare function isDurationOperator(operator: FilterOperatorName): boolean;
+/** Whether a field holds a moment a time since could run from or to. */
+export declare function holdsTime(field: Pick<FieldDefinition, 'kind'>): boolean;
+/** Still being written: no earlier moment picked yet. */
+export declare function isBlankDuration(value: unknown): boolean;
+/**
+ * The value's shape, and the earlier moment it names: a field of the same
+ * set, holding a time, other than the field itself — a time since itself is
+ * always nothing.
+ */
+export declare function validateDuration(value: unknown, field: FieldDefinition, fields: readonly FieldDefinition[] | undefined, path: IssuePath): Issue[];
+/** `DATE_DIFF(from, field, unit) comparison value`, as Wow reads it. */
+export declare function compileDuration(field: FieldDefinition, stored: unknown): FilterExpression;
+/** 「发货时间 since 付款时间 > 48 hours」: the parts `/ui` words. */
+export declare function describeDuration(stored: unknown, field: FieldDefinition, fields: readonly FieldDefinition[] | undefined): FieldKindDescription;
+//# sourceMappingURL=duration.d.ts.map

package/dist/filter/kinds/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../../src/filter/kinds/duration.ts"],"names":[],"mappings":"AAcA,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,KAAK,EACV,KAAK,SAAS,EACf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAI3D;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,kBAAiC,CAAC;AAElE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAExE;AAED,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,GAAG,OAAO,CAEvE;AAED,yDAAyD;AACzD,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAQvD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,EAC9C,IAAI,EAAE,SAAS,GACd,KAAK,EAAE,CAoBT;AAED,wEAAwE;AACxE,wBAAgB,eAAe,CAC7B,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,OAAO,GACd,gBAAgB,CAOlB;AAED,2DAA2D;AAC3D,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,GAC7C,oBAAoB,CAetB"}

package/dist/filter/kinds/elementMatch.d.ts

@@ -0,0 +1,34 @@
+import { FieldDefinition, FieldGroupDefinition } from '../../model/index.js';
+import { FieldKind } from '../fieldKind.js';
+/**
+ * The fields of one element, named as a condition names them.
+ *
+ * A config points at an element field from outside, so it writes the full
+ * `array.field`; the declaration inside the array writes the relative name.
+ * This is the one place the two meet.
+ */
+export declare function elementFields(field: FieldDefinition): readonly FieldDefinition[];
+/**
+ * A condition on the elements of an array: "some line has sku X and qty > 2".
+ *
+ * Its value is a condition rather than a scalar, which is what separates it
+ * from every other kind. Wow's `ELEMENT_MATCH` carries a whole predicate, and
+ * a predicate is what a user writes here — the same tree, the same editor,
+ * scoped to the fields the array's elements declare.
+ *
+ * The distinction it exists for: two conditions on `items.sku` and `items.qty`
+ * written side by side at the top level are satisfied by *any* elements, one
+ * matching each. Inside an element match they must be satisfied by the *same*
+ * element, which is almost always what someone asking the question meant.
+ */
+/**
+ * The groups a predicate's field picker lists an element's fields under
+ * when its elements differ by variant (#3519): one per variant, in the
+ * order the discriminator's options give (else by value), each naming the
+ * fields only that variant has, by the names `elementFields` gives them.
+ * A field several variants share, and every field of an element that does
+ * not vary, is listed before the groups.
+ */
+export declare function variantGroups(field: FieldDefinition): FieldGroupDefinition[];
+export declare const elementMatchFieldKind: FieldKind;
+//# sourceMappingURL=elementMatch.d.ts.map

package/dist/filter/kinds/elementMatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementMatch.d.ts","sourceRoot":"","sources":["../../../src/filter/kinds/elementMatch.ts"],"names":[],"mappings":"AAkBA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,oBAAoB,EAK1B,MAAM,sBAAsB,CAAC;AAQ9B,OAAO,EAGL,KAAK,SAAS,EAEf,MAAM,iBAAiB,CAAC;AAKzB;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,eAAe,GACrB,SAAS,eAAe,EAAE,CAK5B;AAED;;;;;;;;;;;;GAYG;AACH;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,eAAe,GAAG,oBAAoB,EAAE,CA8B5E;AAED,eAAO,MAAM,qBAAqB,EAAE,SAwInC,CAAC"}

package/dist/filter/kinds/entries.d.ts

@@ -0,0 +1,20 @@
+import { FilterExpression } from '@ahoo-wang/wow-client';
+import { FilterOperatorName } from '../../model/index.js';
+import { FilterSummaryRelation } from '../describe.js';
+/**
+ * A list's two questions of emptiness, and the only two a list offers
+ * (second review R1-P1-7: five 「空」 — 没有条目、为空、不为空、存在、不存在 —
+ * that nobody could tell apart). Stored under Wow's own operator names, so a
+ * saved condition reads as what it asks:
+ *
+ * - `IS_EMPTY` — 「没有条目」: an empty list, and a list that is absent or
+ *   null, which MongoDB's `$size: 0` alone would miss;
+ * - `IS_NOT_NULL` — 「有条目」: the rest, at least one entry.
+ */
+export declare const ENTRY_OPERATORS: readonly FilterOperatorName[];
+export declare function isEntryOperator(operator: FilterOperatorName): boolean;
+/** How the bar and the pill say it. */
+export declare function entryRelation(operator: FilterOperatorName): FilterSummaryRelation | null;
+/** What Wow is asked, or `null` for an operator that asks about entries. */
+export declare function compileEntries(field: string, operator: FilterOperatorName): FilterExpression | null;
+//# sourceMappingURL=entries.d.ts.map

package/dist/filter/kinds/entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entries.d.ts","sourceRoot":"","sources":["../../../src/filter/kinds/entries.ts"],"names":[],"mappings":"AAaA,OAAO,EAAU,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAE5D;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,kBAAkB,EAGxD,CAAC;AAEF,wBAAgB,eAAe,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAErE;AAED,uCAAuC;AACvC,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,kBAAkB,GAC3B,qBAAqB,GAAG,IAAI,CAI9B;AAED,4EAA4E;AAC5E,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,kBAAkB,GAC3B,gBAAgB,GAAG,IAAI,CAKzB"}

package/dist/filter/kinds/enum.d.ts

@@ -0,0 +1,7 @@
+import { FieldKind } from '../fieldKind.js';
+/**
+ * A closed set of values declared by the definition. Both `IN` and `NOT_IN`
+ * store a list, so switching between them keeps the selection.
+ */
+export declare const enumFieldKind: FieldKind;
+//# sourceMappingURL=enum.d.ts.map

package/dist/filter/kinds/enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.d.ts","sourceRoot":"","sources":["../../../src/filter/kinds/enum.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAejD;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,SAqD3B,CAAC"}

package/dist/filter/kinds/index.d.ts

@@ -0,0 +1,18 @@
+import { FieldKind } from '../fieldKind.js';
+export * from './boolean.js';
+export * from './dateTime.js';
+export * from './deletion.js';
+export * from './array.js';
+export * from './elementMatch.js';
+export * from './enum.js';
+export * from './metadata.js';
+export * from './number.js';
+export * from './presence.js';
+export * from './reference.js';
+export * from './search.js';
+export * from './string.js';
+/** The kinds this package ships, in the order `FieldKindId` lists them. */
+export declare const BUILTIN_FIELD_KINDS: readonly FieldKind[];
+/** Ready-to-use registry; extend it with `withFieldKinds`. */
+export declare const builtinFieldKinds: import('../fieldKind.js').FieldKindRegistry;
+//# sourceMappingURL=index.d.ts.map

package/dist/filter/kinds/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/filter/kinds/index.ts"],"names":[],"mappings":"AAaA,OAAO,EAA2B,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAa1E,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAE5B,2EAA2E;AAC3E,eAAO,MAAM,mBAAmB,EAAE,SAAS,SAAS,EAanD,CAAC;AAEF,8DAA8D;AAC9D,eAAO,MAAM,iBAAiB,6CAA+C,CAAC"}

package/dist/filter/kinds/metadata.d.ts

@@ -0,0 +1,3 @@
+import { FieldKind } from '../fieldKind.js';
+export declare const METADATA_FIELD_KINDS: readonly FieldKind[];
+//# sourceMappingURL=metadata.d.ts.map

package/dist/filter/kinds/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../src/filter/kinds/metadata.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAsPnE,eAAO,MAAM,oBAAoB,EAAE,SAAS,SAAS,EAMpD,CAAC"}

package/dist/filter/kinds/number.d.ts

@@ -0,0 +1,3 @@
+import { FieldKind } from '../fieldKind.js';
+export declare const numberFieldKind: FieldKind;
+//# sourceMappingURL=number.d.ts.map

package/dist/filter/kinds/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../../src/filter/kinds/number.ts"],"names":[],"mappings":"AAeA,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAgBnE,eAAO,MAAM,eAAe,EAAE,SAgH7B,CAAC"}

package/dist/filter/kinds/options.d.ts

@@ -0,0 +1,44 @@
+import { FieldOption, FieldDefinition, Issue } from '../../model/index.js';
+/**
+ * What `enum` and `array` share.
+ *
+ * Their values are different things — one picks from a closed set, the other
+ * holds several entries at once — but "a list of strings or numbers, and a
+ * declared `options` closes it" is one rule, and it was written twice. A
+ * change to what a candidate may be, or to how an unknown one is reported,
+ * belongs in one place or the two kinds drift.
+ */
+/**
+ * A candidate's label, strictly: `undefined` when the definition named none.
+ *
+ * The difference from `labelOf` matters wherever the answer travels rather
+ * than being printed. A summary item carries labels so the bar can show what
+ * the definition calls a value; handing it a stringified value as if it were
+ * a label makes the bar prefer it over the field's own formatting, and a
+ * currency entry shows as a bare number beside a column showing ¥.
+ */
+export declare function optionLabelOf(options: FieldOption[] | undefined, value: string | number): string | undefined;
+/** A candidate's label, or the raw value when the definition declares none. */
+export declare function labelOf(options: FieldOption[] | undefined, value: string | number): string;
+/**
+ * The values of one condition as the English line reads them: the label the
+ * definition gave each, or the value itself where it gave none.
+ */
+export declare function shownEntries(values: readonly (string | number)[], labels: readonly (string | undefined)[]): string;
+/**
+ * The `labels` a summary item carries, or nothing at all when the definition
+ * named none of them — an absent `labels` is what tells the bar to fall back
+ * on the field's own formatting rather than on a stringified value.
+ */
+export declare function namedLabels(labels: readonly (string | undefined)[]): {
+    labels?: readonly (string | undefined)[];
+};
+/**
+ * Admits a list of candidates against the field's declared set.
+ *
+ * `expected` is the kind's own code for "this is not a list of candidates at
+ * all", because a user choosing options and a user typing entries are being
+ * asked different questions and should read different sentences.
+ */
+export declare function validateOptionValues(value: unknown, field: FieldDefinition, path: Issue['path'], expected: string): Issue[];
+//# sourceMappingURL=options.d.ts.map

package/dist/filter/kinds/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/filter/kinds/options.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAIhF;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,WAAW,EAAE,GAAG,SAAS,EAClC,KAAK,EAAE,MAAM,GAAG,MAAM,GACrB,MAAM,GAAG,SAAS,CAEpB;AAED,+EAA+E;AAC/E,wBAAgB,OAAO,CACrB,OAAO,EAAE,WAAW,EAAE,GAAG,SAAS,EAClC,KAAK,EAAE,MAAM,GAAG,MAAM,GACrB,MAAM,CAER;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EACpC,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,GACtC,MAAM,CAIR;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,GAAG;IACpE,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAAC;CAC1C,CAEA;AAOD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,eAAe,EACtB,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,EACnB,QAAQ,EAAE,MAAM,GACf,KAAK,EAAE,CAgBT"}

package/dist/filter/kinds/presence.d.ts

@@ -0,0 +1,18 @@
+import { FilterExpression } from '@ahoo-wang/wow-client';
+import { FieldDefinition, FilterOperatorName } from '../../model/index.js';
+import { FieldKindDescription } from '../describe.js';
+/**
+ * Operators that ask about presence rather than about a value. Every kind
+ * offers them and none of them reads the leaf's value.
+ */
+export declare const PRESENCE_OPERATORS: readonly FilterOperatorName[];
+export declare function isPresenceOperator(operator: FilterOperatorName): boolean;
+export declare function compilePresence(field: string, operator: FilterOperatorName): FilterExpression | null;
+/**
+ * A presence question as one summary item: the operator is the whole
+ * condition, so the value says there is nothing beside it to read. `null`
+ * when the operator asks about a value after all.
+ */
+export declare function describePresenceParts(operator: FilterOperatorName, field: FieldDefinition): FieldKindDescription | null;
+export declare function describePresence(operator: FilterOperatorName): string | null;
+//# sourceMappingURL=presence.d.ts.map

package/dist/filter/kinds/presence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presence.d.ts","sourceRoot":"","sources":["../../../src/filter/kinds/presence.ts"],"names":[],"mappings":"AAaA,OAAO,EAAU,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAChF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS,kBAAkB,EAK3D,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAExE;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,kBAAkB,GAC3B,gBAAgB,GAAG,IAAI,CAazB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,kBAAkB,EAC5B,KAAK,EAAE,eAAe,GACrB,oBAAoB,GAAG,IAAI,CAK7B;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,GAAG,IAAI,CAa5E"}

package/dist/filter/kinds/reference.d.ts

@@ -0,0 +1,8 @@
+import { FieldKind } from '../fieldKind.js';
+/**
+ * Points at rows of another dataset. The value keeps each label next to its
+ * id, so reopening a saved view shows what was chosen without asking the
+ * remote source again; only editing needs `resolveOptions`.
+ */
+export declare const referenceFieldKind: FieldKind;
+//# sourceMappingURL=reference.d.ts.map

package/dist/filter/kinds/reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../../src/filter/kinds/reference.ts"],"names":[],"mappings":"AAcA,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAYnE;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAyDhC,CAAC"}

package/dist/filter/kinds/search.d.ts

@@ -0,0 +1,15 @@
+import { FieldKind } from '../fieldKind.js';
+/**
+ * Full-text search: the box at the top of a list page.
+ *
+ * Wow's `SEARCH` names no field, so this kind's `name` is a handle for the
+ * editor and the label rather than a path, the way the metadata kinds' names
+ * are. Which fields the query looks in, and whether it reads as words or as a
+ * phrase, belong to the definition — matching behaviour is a property of the
+ * field, and the value is only what someone typed.
+ *
+ * It offers no presence operators, because those carry a field name and this
+ * one has none to give them.
+ */
+export declare const searchFieldKind: FieldKind;
+//# sourceMappingURL=search.d.ts.map

package/dist/filter/kinds/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/filter/kinds/search.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEnE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,EAAE,SAqD7B,CAAC"}

package/dist/filter/kinds/string.d.ts

@@ -0,0 +1,3 @@
+import { FieldKind } from '../fieldKind.js';
+export declare const stringFieldKind: FieldKind;
+//# sourceMappingURL=string.d.ts.map

package/dist/filter/kinds/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../src/filter/kinds/string.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAWnE,eAAO,MAAM,eAAe,EAAE,SA+F7B,CAAC"}

package/dist/filter/marks.d.ts

@@ -0,0 +1,28 @@
+import { FilterTree, Issue } from '../model/index.js';
+/**
+ * The errors a condition editor is not already marking.
+ *
+ * A wrong condition is marked on its own pill and counted on the Apply
+ * button, which is both nearer to the mistake and the only place the mistake
+ * can be corrected; repeating it in a strip above says the same thing twice
+ * and further from the fix. Everything else — a column the definition
+ * dropped, a page size it no longer admits — has no pill to sit on, and a
+ * strip is the only way it is ever seen.
+ *
+ * Which is why the draft tree is asked rather than the path alone: a
+ * condition-shaped path is not the same thing as a pill. An editor draws a
+ * node only when the tree really holds one there — a malformed child is
+ * skipped, and a group carries no marker of its own — so an error addressing
+ * anything but a rendered condition is marked nowhere and belongs in the
+ * strip. Apply is still refused for it: `blocked` counts every
+ * condition-level error, whether or not a pill could be found for it.
+ *
+ * It lives here rather than beside the editor because it is a question about
+ * the tree and nothing else: which paths resolve to a condition a renderer
+ * can draw. `useFilterEditor` hands the answer out as `unmarked`, the pair of
+ * `blocked`.
+ */
+export declare function unmarkedErrors(issues: readonly Issue[], 
+/** The draft the editor beside this strip is showing. */
+tree: FilterTree): Issue[];
+//# sourceMappingURL=marks.d.ts.map

package/dist/filter/marks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marks.d.ts","sourceRoot":"","sources":["../../src/filter/marks.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAc,UAAU,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AASvE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,SAAS,KAAK,EAAE;AACxB,yDAAyD;AACzD,IAAI,EAAE,UAAU,GACf,KAAK,EAAE,CAIT"}

package/dist/filter/search.d.ts

@@ -0,0 +1,28 @@
+import { FieldDefinition, FilterTree } from '../model/index.js';
+/**
+ * The search a view keeps on hand: the text of the search condition on the
+ * tree's root, which is where a search box reads and writes it.
+ *
+ * One condition, on the root: a search box is one box, and a search nested
+ * in a group is a condition somebody composed in the editor — the box
+ * neither reads it as its own nor overwrites it. `''` when there is none.
+ */
+export declare function rootSearch(tree: FilterTree, field: string): string;
+/**
+ * The tree with its root search set to `text`: the condition's value
+ * replaced where it is, added at the end where there was none, and taken
+ * out when the text is blank — an empty search is no condition, and a pill
+ * left behind for it would be one the reader never added.
+ *
+ * A root that is not an `and` — an advanced tree whose top is an `or` —
+ * keeps its meaning: it becomes the first child of a new `and`, next to the
+ * search, so the search narrows it rather than joining its alternatives.
+ */
+export declare function withRootSearch(tree: FilterTree, field: string, text: string): FilterTree;
+/**
+ * The definition's search field — the first, where it declares several —
+ * that still searches: one narrowed to no operator (its source offers no
+ * search it can use, capabilities.md 4.2, G15) draws no search box.
+ */
+export declare function searchFieldOf(fields: readonly FieldDefinition[]): FieldDefinition | null;
+//# sourceMappingURL=search.d.ts.map

package/dist/filter/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/filter/search.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,eAAe,EAGf,UAAU,EACX,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAMlE;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GACX,UAAU,CAmBZ;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,eAAe,EAAE,GACjC,eAAe,GAAG,IAAI,CAMxB"}

package/dist/filter/time.d.ts

@@ -0,0 +1,57 @@
+import { AnalysisDateUnit } from '../model/index.js';
+import { DateTimeFilterValue } from './values.js';
+/**
+ * Resolving a relative or preset value happens at compile time against the
+ * injected moment: the kernel never reads the system clock, and the same
+ * config run tomorrow produces a different window on purpose.
+ */
+export interface InstantRange {
+    /** Inclusive lower bound, ISO 8601. */
+    from: string;
+    /** Inclusive upper bound, ISO 8601; absent means open-ended. */
+    to?: string;
+}
+/**
+ * Which side of a range a bound stands on. A string that names a whole day
+ * is a different instant on each side — its first millisecond as a lower
+ * bound, its last as an upper one — and only the side asking can tell which.
+ */
+export type RangeEdge = 'start' | 'end';
+/** Whether a runtime can resolve this zone; an unknown one makes dayjs throw. */
+export declare function isValidTimeZone(timeZone: string): boolean;
+/**
+ * The range a value names: `from` on its start edge, `to` on its end edge,
+ * so a date-only `to` reaches the end of that day. An absolute value without
+ * `to` stays open-ended.
+ */
+export declare function resolveDateTimeRange(value: DateTimeFilterValue, now: Date, timeZone: string): InstantRange;
+/**
+ * One instant of a value, for the operators that take a single bound: `GTE`
+ * asks for the start edge, `LTE` for the end. An absolute value with only
+ * `from` stands on `from` for both — read at the end edge, a date-only `from`
+ * is the end of its day, which is what "on or before the 31st" means.
+ *
+ * A relative value stands on its far edge whichever side asks. Its near edge
+ * is `now`, and "on or before now" is not what anyone typed: "7 days" is a
+ * distance from this moment, so `GTE` and `LTE` alike compare against the
+ * instant 7 days ago, or 7 days ahead when the window runs forwards. A
+ * preset is a calendar period and keeps the edge asked for: `LTE today` is
+ * the end of today.
+ */
+export declare function resolveDateTimeBound(value: DateTimeFilterValue, now: Date, timeZone: string, edge: RangeEdge): string;
+/**
+ * Which period of the calendar in `timeZone` a range is exactly, if any:
+ * the one a date bucket names (`bucketRange`), written as a closed range —
+ * its first instant to the last millisecond before the next period starts.
+ * A week is the seven days from a midnight, whichever day that is: it reads
+ * as 「9月21日 起的一周」, which is true of any seven such days, where a
+ * week day of our choosing would not match a source that starts weeks on
+ * another one. A calendar period is stepped on the zone's wall clock, as
+ * the bucket was, so a day a clock change makes 23 or 25 hours long is a day.
+ *
+ * Both edges must match to the millisecond, so an answer is never a
+ * rounding: a range a millisecond short of a day is a range. A string that
+ * names no instant, or a zone the runtime cannot resolve, is no period.
+ */
+export declare function periodOf(from: string, to: string, timeZone: string): AnalysisDateUnit | null;
+//# sourceMappingURL=time.d.ts.map

package/dist/filter/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../src/filter/time.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EACV,mBAAmB,EAIpB,MAAM,aAAa,CAAC;AAUrB;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAKD;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,KAAK,CAAC;AA+LxC,iFAAiF;AACjF,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAOzD;AAcD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,IAAI,EACT,QAAQ,EAAE,MAAM,GACf,YAAY,CAQd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,IAAI,EACT,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,SAAS,GACd,MAAM,CAWR;AA4BD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,GACf,gBAAgB,GAAG,IAAI,CAoBzB"}

package/dist/filter/tree.d.ts

@@ -0,0 +1,186 @@
+import { FilterGroup, FilterLeaf, FilterNode, FilterTree, IssuePath } from '../model/index.js';
+/**
+ * Whether a value is a node at all.
+ *
+ * Trees arrive from a store, so a child may be `null`, a number, or an object
+ * that is neither a group nor a leaf. Every predicate here is total over
+ * `unknown`, and the walk skips what fails this one, so a corrupt entry is
+ * reported by `validateFilter` at its path rather than thrown as a
+ * `TypeError` from whichever pass reached it first.
+ */
+export declare function isFilterNode(value: unknown): value is FilterNode;
+/**
+ * Asks what the node actually is rather than whether a property happens to
+ * be present: a leaf carrying a stray `children` of the wrong shape would
+ * otherwise be walked as a group.
+ */
+export declare function isFilterGroup(node: unknown): node is FilterGroup;
+export declare function isFilterLeaf(node: unknown): node is FilterLeaf;
+/** An empty tree. A config always carries a tree, never `null`. */
+export declare function emptyFilter(): FilterTree;
+/** Drops every condition while keeping the tree's shape valid. */
+export declare function clearFilter(): FilterTree;
+/**
+ * ANDs several trees into one, dropping the empty ones. The first tree is
+ * the base and keeps its shape: a plain AND group contributes its children
+ * as they are, so a path into it still leads to the same node. Every later
+ * tree is appended as one nested group, never flattened: a group holds one
+ * condition per field, and an injected scope on a field the base already
+ * asks about — a host narrowing to one region over a view saved for another
+ * — is a second question, not a duplicate. It costs one level of depth for
+ * the scope's own subtree, which a single condition does not even show on
+ * the wire, since a group of one compiles to that one.
+ *
+ * The runtime uses it for `setScopeFilter`, and the dashboard kernel for the
+ * global filter it maps onto each panel.
+ */
+export declare function mergeFilters(...trees: (FilterTree | null | undefined)[]): FilterTree;
+/**
+ * Where a node sits: child indexes from the root outwards, so `[1, 0]` is the
+ * first child of the second child. The root group itself is `[]`.
+ */
+export type FilterPath = number[];
+/** The node at a path, or `null` when the path leads nowhere. */
+export declare function nodeAt(tree: FilterTree, path: FilterPath): FilterNode | null;
+/**
+ * Replaces the node at a path, or removes it when `update` returns `null`.
+ * Everything outside the path keeps its identity, so an editor re-renders only
+ * the branch it touched. The root cannot be replaced: `[]` returns the tree.
+ */
+export declare function updateAt(tree: FilterTree, path: FilterPath, update: (node: FilterNode) => FilterNode | null): FilterTree;
+/** Removes the node at a path. */
+export declare function removeAt(tree: FilterTree, path: FilterPath): FilterTree;
+/** Appends a node to the group at `parent`; `[]` is the root group. */
+export declare function insertAt(tree: FilterTree, parent: FilterPath, node: FilterNode): FilterTree;
+/** True when the tree holds no leaf at any depth. */
+/**
+ * Whether a tree asks nothing: well-formed groups all the way down and not
+ * one leaf. A tree holding a malformed entry is not empty — it is admission's
+ * to report — so `mergeFilters` must not drop it as if it said nothing, or a
+ * stored filter that lost its shape would vanish behind an injected scope
+ * and the query would run wider than the view was saved to be.
+ */
+export declare function isEmptyFilter(tree: FilterTree): boolean;
+/**
+ * A group that says "not this": `nor` over exactly one condition.
+ *
+ * It is how a condition is negated (D18-7): the pill's switch wraps the leaf
+ * in a group of its own rather than every kind growing a negated operator,
+ * and the compiler already turns `nor` into the protocol's negation. It is
+ * also the one group shape the simple editor still draws as a pill.
+ */
+export declare function isNegation(node: unknown): node is FilterGroup & {
+    children: [FilterLeaf];
+};
+/**
+ * The condition a node asks: the leaf itself, or the one inside a negation.
+ * `null` for anything that is not one condition — a group of several, an
+ * empty one, a malformed entry.
+ *
+ * It is the kernel's answer to "what does this say", so that the wrapper
+ * D18-7 stores a negation as stays the kernel's to know: a caller that
+ * wants the field, the operator or the value asks this rather than reaching
+ * into `children[0]` and spelling the shape a second time.
+ */
+export declare function conditionOf(node: unknown): FilterLeaf | null;
+/** One condition of a group: what it says, where it sits, and how. */
+export interface GroupCondition {
+    /** The condition itself, wrapper or no wrapper. */
+    leaf: FilterLeaf;
+    /** Which child of the group holds it. */
+    index: number;
+    /**
+     * The leaf's own path — inside the wrapper when it has one, which is the
+     * path the pill holds either way, and the one `negateAt` and a
+     * controller's `remove` both take.
+     */
+    path: FilterPath;
+    /** Whether the group holds it as "not this". */
+    negated: boolean;
+}
+/**
+ * The children of a group that each read as one condition, in order, with
+ * the leaf's path and whether it is negated. A nested group of several
+ * conditions is not one of them, and neither is a malformed entry, so the
+ * indexes it yields may have gaps — the caller that draws every child in
+ * order keys by `index` rather than counting.
+ *
+ * `at` is the group's own path, so the paths come out addressed from the
+ * root and can be handed straight to an editor. This is what the picker,
+ * the condition strip and `fieldsFor` read: none of them has to know that a
+ * negated condition is stored one level down.
+ */
+export declare function conditions(group: unknown, at?: FilterPath): GroupCondition[];
+/**
+ * `simple` mode shows one AND group of conditions, each on its own or
+ * negated. Anything else needs the advanced editor, which is why the mode
+ * travels with the saved config.
+ */
+export declare function isSimpleTree(tree: FilterTree): boolean;
+/**
+ * The tree with the condition at `path` negated — or, when it already sits
+ * alone in a `nor` group, that group replaced by the condition itself.
+ * `path` is the leaf's, inside its wrapper when it has one, which is the
+ * path the pill holds either way. The root is never wrapped: a root that
+ * negates itself has no simple reading and no pill.
+ */
+export declare function negateAt(tree: FilterTree, path: FilterPath): FilterTree;
+/**
+ * The tree without the condition at `path`, and without the negation around
+ * it when it has one: an editor holds a negated condition by its leaf's
+ * path, so removing it takes the wrapper along rather than leaving an empty
+ * `nor` group behind that says nothing and cannot be edited.
+ *
+ * `path` naming anything else — a nested group, a leaf standing on its own —
+ * removes exactly that, so this is the one removal an editor needs.
+ */
+export declare function removeConditionAt(tree: FilterTree, path: FilterPath): FilterTree;
+export interface TreeVisit {
+    node: FilterNode;
+    path: IssuePath;
+    depth: number;
+}
+/**
+ * A place in the tree holding something that is not a node: `null`, a
+ * number, an object with neither `children` nor `field`. It has a path and a
+ * depth like any node, so the budget counts it and an issue can point at it,
+ * but nothing below it is walked.
+ */
+export interface MalformedVisit {
+    node: null;
+    path: IssuePath;
+    depth: number;
+}
+/**
+ * Walks the tree iteratively, malformed entries included. Configs arrive from
+ * a store, so nothing here may recurse before the budget in `validateFilter`
+ * has admitted the tree, and that budget is the one caller that needs to see
+ * the malformed entries: they cost a node each, and they are its to report.
+ */
+export declare function walkFilterShape(tree: unknown): Generator<TreeVisit | MalformedVisit>;
+/** Walks the nodes of the tree, skipping whatever is not one. */
+export declare function walkFilter(tree: FilterTree): Generator<TreeVisit>;
+/**
+ * Whether two nodes say the same thing *at their own level*: a leaf by its
+ * field, operator and value, a group by its operator alone.
+ *
+ * A group deliberately ignores its children, because the callers walk the
+ * tree and ask about every node. Comparing children here would mark a group,
+ * its parent and the root as changed for one edited condition, and "3 not
+ * applied" for a single edit is a lie the user cannot act on. `null` stands
+ * for "no node there", which is never equal to a node — an added condition
+ * is a change, whatever it says.
+ *
+ * `dequal` would answer the value part, but the runtime is the only layer
+ * allowed to import it (`test/architecture.test.ts`), and this comparison
+ * belongs to the editor rather than to the store of state.
+ */
+export declare function sameFilterNode(left: FilterNode | null, right: FilterNode | null, budget?: number): boolean;
+/** Whether two trees — or two nodes — are the same, children and all. */
+export declare function sameFilterTree(left: FilterNode, right: FilterNode, budget?: number): boolean;
+export declare function countLeaves(tree: FilterTree): number;
+/** Every field the tree mentions, in first-seen order. */
+export declare function filterFields(tree: FilterTree): string[];
+/** The earlier moment a time since another moment (N3) names, if it is one. */
+export declare function durationFrom(leaf: FilterLeaf): string | undefined;
+//# sourceMappingURL=tree.d.ts.map