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

package/dist/testing/actions.d.ts

@@ -0,0 +1,78 @@
+import { FieldOption, RecordKey } from '../model/index.js';
+import { ActionConfirm, ActionInput, ActionPlace, ActionRefusal, ActionRow as RecordRow, RecordActions } from '../runtime/actions.js';
+export interface ActionHarnessOptions {
+    /** The clock the rules are asked at; `Date.now()` when left out. */
+    now?: number;
+}
+/** One action on one record, as the row, the menu and the detail draw it. */
+export interface HarnessState {
+    hidden: boolean;
+    available: boolean;
+    /** Why not, as the host wrote it (a key stays a key); `null` when able. */
+    reason: string | null;
+}
+/** One action over a selection, as the selection's bar and its dialog read it. */
+export interface HarnessBulk {
+    able: RecordKey[];
+    refused: ActionRefusal[];
+    /** The refused by reason, the commonest first: what the dialog lists. */
+    reasons: {
+        reason: string;
+        count: number;
+        keys: RecordKey[];
+    }[];
+}
+/** One field of an action's form, as the dialog draws it. */
+export interface HarnessField {
+    name: string;
+    label: string;
+    input: 'select' | 'text' | 'number' | 'boolean';
+    options: readonly FieldOption[] | null;
+    required: boolean;
+}
+/**
+ * A host's declared actions over some records, without a screen
+ * (host-integration.md 6): the engine's own reading of them — which place
+ * offers which, whether a record takes one now and why not, how a
+ * selection splits, what the confirmation and the form ask, when the rules
+ * change on their own — so a host's unit test pins its business rules in a
+ * line each.
+ */
+export interface ActionHarness {
+    /** Every action's id, in the order declared. */
+    readonly ids: readonly string[];
+    /** The ids offered at a place, in order. */
+    at(place: ActionPlace): string[];
+    /**
+     * One record's state; with an input, asked as a pressed action is — the
+     * form's `initial` under it.
+     */
+    state(id: string, key: RecordKey, input?: ActionInput): HarnessState;
+    bulk(id: string, keys?: readonly RecordKey[], input?: ActionInput): HarnessBulk;
+    /**
+     * Whether pressing it at `place` asks before sending — a selection
+     * always does — and what it asks: the declared question, or `null` when
+     * the engine asks with its own words (a selection with no `confirm`).
+     * Asked as the screen asks it: the form's `initial` under `input`.
+     */
+    asks(id: string, place: ActionPlace, input?: ActionInput): {
+        asks: boolean;
+        confirm: ActionConfirm | null;
+    };
+    /** The form's fields, or `null` without one; a choice is one `select`. */
+    form(id: string): HarnessField[] | null;
+    /** Whether it is a choice: a form of one field of options, offered as them. */
+    choice(id: string): readonly FieldOption[] | null;
+    /** The required fields `input` leaves blank, the form's `initial` under it. */
+    missing(id: string, input: ActionInput): string[];
+    /** The soonest time after `now` a record's availability flips on its own. */
+    changesAt(key?: RecordKey): number | null;
+    /**
+     * Sends one record the command as the engine would — with the form's
+     * `initial` under `input` — refused with the reason (`ActionRefusedError`)
+     * where it does not take it, else the host's `run` itself.
+     */
+    run(id: string, key: RecordKey, input?: ActionInput): Promise<unknown>;
+}
+export declare function actionHarness(list: RecordActions, rows: readonly RecordRow[], { now }?: ActionHarnessOptions): ActionHarness;
+//# sourceMappingURL=actions.d.ts.map

package/dist/testing/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/testing/actions.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAYL,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,SAAS,IAAI,SAAS,EAE3B,KAAK,aAAa,EACnB,MAAM,uBAAuB,CAAC;AAE/B,MAAM,WAAW,oBAAoB;IACnC,oEAAoE;IACpE,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,6EAA6E;AAC7E,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,2EAA2E;IAC3E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED,kFAAkF;AAClF,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,yEAAyE;IACzE,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,SAAS,EAAE,CAAA;KAAE,EAAE,CAAC;CACjE;AAED,6DAA6D;AAC7D,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;IAChD,OAAO,EAAE,SAAS,WAAW,EAAE,GAAG,IAAI,CAAC;IACvC,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,QAAQ,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,4CAA4C;IAC5C,EAAE,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,EAAE,CAAC;IACjC;;;OAGG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,YAAY,CAAC;IACrE,IAAI,CACF,EAAE,EAAE,MAAM,EACV,IAAI,CAAC,EAAE,SAAS,SAAS,EAAE,EAC3B,KAAK,CAAC,EAAE,WAAW,GAClB,WAAW,CAAC;IACf;;;;;OAKG;IACH,IAAI,CACF,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,WAAW,EAClB,KAAK,CAAC,EAAE,WAAW,GAClB;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAAA;KAAE,CAAC;IACpD,0EAA0E;IAC1E,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,EAAE,GAAG,IAAI,CAAC;IACxC,+EAA+E;IAC/E,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,WAAW,EAAE,GAAG,IAAI,CAAC;IAClD,+EAA+E;IAC/E,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,MAAM,EAAE,CAAC;IAClD,6EAA6E;IAC7E,SAAS,CAAC,GAAG,CAAC,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,CAAC;IAC1C;;;;OAIG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACxE;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,SAAS,SAAS,EAAE,EAC1B,EAAE,GAAgB,EAAE,GAAE,oBAAyB,GAC9C,aAAa,CA4Ef"}

package/dist/testing/aggregate.d.ts

@@ -0,0 +1,24 @@
+import { AggregationQuery } from '@ahoo-wang/wow-client';
+import { RecordData } from '../model/record.js';
+/**
+ * One aggregation over the records a query's root filter has already
+ * matched, with Wow's answer shape and order:
+ *
+ * 1. `elements` replace the records by the elements of an array, step by
+ *    step — each path relative to the step before, each gate filter naming
+ *    the element's own fields; what is left is counted as if each element
+ *    were a record.
+ * 2. The groups key each record; a metric's own `filter` decides, per
+ *    record, whether that record counts toward that one metric.
+ * 3. A `dense` date group fills its empty buckets; the derived metrics are
+ *    computed over each grouped row; `having` keeps the rows it admits.
+ * 4. The rows are sorted by the query's sort, then by every group alias it
+ *    does not name, ascending, as Wow appends them; and cut to `limit`
+ *    (Wow's default 100) — after the having, so the top five of what is
+ *    kept.
+ *
+ * An ungrouped aggregation always answers its one row, over nothing too: a
+ * count of 0 and null for a value nothing contributed to.
+ */
+export declare function summarise(matched: readonly RecordData[], query: AggregationQuery): RecordData[];
+//# sourceMappingURL=aggregate.d.ts.map

package/dist/testing/aggregate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../src/testing/aggregate.ts"],"names":[],"mappings":"AAcA,OAAO,EAWL,KAAK,gBAAgB,EAMtB,MAAM,uBAAuB,CAAC;AAW/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,KAAK,EAAE,gBAAgB,GACtB,UAAU,EAAE,CAgCd"}

package/dist/testing/calendar.d.ts

@@ -0,0 +1,41 @@
+import { AggregationDatePart, AggregationDateUnit, DateHistogramAggregationGroup, DatePartAggregationGroup } from '@ahoo-wang/wow-client';
+/**
+ * The bucket start an instant falls in, for one unit in one zone: the start
+ * of its unit in the zone, in epoch milliseconds, which is the key the
+ * service answers a date bucket with.
+ *
+ * Every bucket of a day or more starts at a local midnight, so the bucket is
+ * a property of the calendar day: it is worked out once per day the rows
+ * touch and looked up after that, where converting each row into the zone
+ * cost a conversion per row per query. A shorter bucket is counted from the
+ * day's start (`SUB_DAY_WIDTHS`), except on a day the clock jumps, which is
+ * worked out row by row from the wall clock.
+ *
+ * The week starts on Monday, as `wow-mongo` truncates it (`$dateTrunc` with
+ * `startOfWeek: "Monday"`); a quarter starts in January, April, July or
+ * October. The zone arithmetic is the platform's (`Intl.DateTimeFormat`):
+ * dayjs's timezone plugin answers from the host's own zone rules and was off
+ * by an hour on the days the host's clock moves.
+ */
+export declare function bucketerOf(unit: AggregationDateUnit, zone: string): (at: number) => number;
+/**
+ * The zone a date histogram buckets in, or a date part reads in: its own, or
+ * UTC, as Wow's `AggregationGroup` defaults it — not the reader's.
+ */
+export declare function zoneOf(group: DateHistogramAggregationGroup | DatePartAggregationGroup): string;
+/** The keys a date part runs through, first and last (Wow's `DatePartFill`). */
+export declare const PART_DOMAINS: Record<AggregationDatePart, [
+    first: number,
+    last: number
+]>;
+/** How a date part reads an instant, on the zone's wall clock. */
+export declare function parterOf(part: AggregationDatePart, zone: string): (at: number) => number;
+/**
+ * The keys of a dense date histogram, in order, as Wow answers `dense`: every
+ * bucket of the unit between the first and the last key that has records —
+ * not beyond them. A local date the zone skipped is no bucket; the next
+ * bucket start after a start is the one the next instant falls in, so a
+ * skipped day is stepped over rather than invented.
+ */
+export declare function denseKeys(keys: readonly number[], group: DateHistogramAggregationGroup): number[];
+//# sourceMappingURL=calendar.d.ts.map

package/dist/testing/calendar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calendar.d.ts","sourceRoot":"","sources":["../../src/testing/calendar.ts"],"names":[],"mappings":"AAaA,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,KAAK,6BAA6B,EAClC,KAAK,wBAAwB,EAC9B,MAAM,uBAAuB,CAAC;AAmC/B;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,MAAM,GACX,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAQxB;AAgJD;;;GAGG;AACH,wBAAgB,MAAM,CACpB,KAAK,EAAE,6BAA6B,GAAG,wBAAwB,GAC9D,MAAM,CAER;AAED,gFAAgF;AAChF,eAAO,MAAM,YAAY,EAAE,MAAM,CAC/B,mBAAmB,EACnB;IAAC,KAAK,EAAE,MAAM;IAAE,IAAI,EAAE,MAAM;CAAC,CAM9B,CAAC;AAEF,kEAAkE;AAClE,wBAAgB,QAAQ,CACtB,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,MAAM,GACX,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAiBxB;AAuBD;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,KAAK,EAAE,6BAA6B,GACnC,MAAM,EAAE,CAmBV"}

package/dist/testing/expression.d.ts

@@ -0,0 +1,17 @@
+import { AggregationExpressionOperator, AggregationExpression } from '@ahoo-wang/wow-client';
+/** Wow's four operations; a division by zero has no value. */
+export declare function arithmetic(operator: AggregationExpressionOperator, left: number, right: number): number | null;
+/**
+ * What one record contributes, before a metric summarises it across the
+ * group, or what an `EXPRESSION` filter compares, or what a band is cut from:
+ * a field, a number, one operation over two of those, or the time between
+ * two moments (`to − from` in the unit). A formula is computed **per record
+ * and then summarised** — 金额 − 成本 per order, then summed.
+ *
+ * `null` is "no value", as the service skips such a record: a field that
+ * holds no number (an array of one number counts as that number, an array of
+ * several as none), a division by zero, a result that is not finite (an
+ * overflow), a `DATE_DIFF` missing either moment.
+ */
+export declare function evaluated(expression: AggregationExpression, record: unknown): number | null;
+//# sourceMappingURL=expression.d.ts.map

package/dist/testing/expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["../../src/testing/expression.ts"],"names":[],"mappings":"AAaA,OAAO,EACL,6BAA6B,EAG7B,KAAK,qBAAqB,EAC3B,MAAM,uBAAuB,CAAC;AAW/B,8DAA8D;AAC9D,wBAAgB,UAAU,CACxB,QAAQ,EAAE,6BAA6B,EACvC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACZ,MAAM,GAAG,IAAI,CAef;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CACvB,UAAU,EAAE,qBAAqB,EACjC,MAAM,EAAE,OAAO,GACd,MAAM,GAAG,IAAI,CA6Bf"}

package/dist/testing/filter.d.ts

@@ -0,0 +1,48 @@
+import { AnyObject } from 'mingo/types';
+import { ComparisonOperator, ElementFilterExpression, FilterExpression } from '@ahoo-wang/wow-client';
+import { RecordData } from '../model/record.js';
+type Filter = FilterExpression | ElementFilterExpression;
+/**
+ * Whether one document matches a filter, as `memorySource` reads it — the
+ * question a test asks of a condition of its own, such as the one an old
+ * screen used, to compare with what a view matched. Unlike a source, it
+ * assumes nothing about deletion: without a `DELETION` condition a deleted
+ * document is a candidate too. `now` is the clock `BEFORE_NOW` and
+ * `AFTER_NOW` compare against (`Date.now` by default).
+ */
+export declare function matches(document: RecordData, filter: FilterExpression, options?: {
+    now?: () => number;
+}): boolean;
+/** `value <op> against`, for an `EXPRESSION` filter and a `having`. */
+export declare function compares(operator: ComparisonOperator, value: number, against: number): boolean;
+/**
+ * A Wow source answers only the records that are not deleted unless the
+ * query carries a `DELETION` filter of its own — that reading is the
+ * source's, not the caller's. A document without a `deleted` flag is not
+ * deleted (`$ne: true`), where `wow-mongo` asks `deleted == false` of
+ * snapshots that always carry the flag.
+ */
+export declare function withDeletionDefault(filter: FilterExpression): AnyObject;
+/**
+ * Wow's filter as the MongoDB predicate `wow-mongo` compiles it
+ * (`AbstractMongoFilterCompiler`), for `mingo` to evaluate: MongoDB's own
+ * treatment of a missing field, an explicit null, array elements and case is
+ * then the answer — the semantics matrix Wow holds every backend to
+ * (`FilterSemantics`, canonical on MongoDB). What has no translation is
+ * refused, so a query the source cannot answer fails rather than answering
+ * something plausible and wrong.
+ *
+ * An `ELEMENT_MATCH` predicate names the element's own fields, relative to
+ * it, as `$elemMatch` does.
+ */
+export declare function criteria(filter: Filter): AnyObject;
+/**
+ * A query with every `BEFORE_NOW` / `AFTER_NOW` in it — at the root, in a
+ * logical or element match, in a metric's or an element's filter — lowered
+ * the way Wow's `FilterNormalizer` lowers them: to `LT` / `GT` against
+ * `now + offset`, encoded as the field keeps its time. The clock is read
+ * once, and only when the query holds one.
+ */
+export declare function atNow<Q>(query: Q, clock?: () => number): Q;
+export {};
+//# sourceMappingURL=filter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/testing/filter.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EACL,kBAAkB,EAMlB,KAAK,uBAAuB,EAC5B,KAAK,gBAAgB,EAEtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD,KAAK,MAAM,GAAG,gBAAgB,GAAG,uBAAuB,CAAC;AAEzD;;;;;;;GAOG;AACH,wBAAgB,OAAO,CACrB,QAAQ,EAAE,UAAU,EACpB,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CAAO,GACnC,OAAO,CAET;AAED,uEAAuE;AACvE,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,kBAAkB,EAC5B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,GACd,OAAO,CAmBT;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,gBAAgB,GAAG,SAAS,CAIvE;AAiBD;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CA4HlD;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAE,MAAM,MAAiB,GAAG,CAAC,CAgBpE"}

package/dist/testing/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `@ahoo-wang/wow-view-engine/testing`: an in-memory Wow source for a host's
+ * tests and demos (D65). Headless — no React, no DOM, no stylesheet — and
+ * held to the server's semantics matrix (`FilterSemantics`) and its TCK by
+ * the package's own suites.
+ */
+export { memorySource, type MemorySourceOptions } from './source.js';
+export { matches } from './filter.js';
+export { admit, type Admissible, type AdmitFinding, type AdmitOptions, } from '../runtime/admission.js';
+export { resolveNavigation } from '../runtime/routes.js';
+export { actionHarness, type ActionHarness, type ActionHarnessOptions, type HarnessBulk, type HarnessField, type HarnessState, } from './actions.js';
+export { ActionRefusedError } from '../runtime/actions.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAaA;;;;;GAKG;AACH,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EACL,KAAK,EACL,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,YAAY,GAClB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EACL,aAAa,EACb,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,YAAY,GAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/testing/source.d.ts

@@ -0,0 +1,52 @@
+import { RecordData } from '../model/record.js';
+import { ViewSource } from '../runtime/source.js';
+/**
+ * How `memorySource` keeps and reads its documents. None of it changes an
+ * answer.
+ */
+export interface MemorySourceOptions {
+    /**
+     * The service's clock, in epoch milliseconds, which `BEFORE_NOW` and
+     * `AFTER_NOW` compare against, read once per query and only by a query that
+     * holds one of them. Defaults to `Date.now`. A test pins it to the moment
+     * its data is built around — the one it pins the page's clock to — so
+     * 「晚于现在」 answers the same on every run.
+     */
+    now?: () => number;
+    /**
+     * A time column every document holds as epoch milliseconds, the way a Wow
+     * snapshot keeps `firstEventTime`. The documents are kept in its order — a
+     * query with no sort of its own reads them oldest first — and a range on it
+     * in the filter's top-level AND is cut out by binary search before the
+     * filter reads anything. For large sets; without it the documents keep the
+     * order they came in.
+     */
+    timeField?: string;
+    /**
+     * Answer a repeated aggregation from memory, keyed by the query, each
+     * caller getting its own copy. Only for documents that never change under
+     * the source; off by default, so a test that edits a document (a command
+     * it stubs) sees the edit in the next answer.
+     */
+    remember?: boolean;
+}
+/**
+ * A `ViewSource` over documents held in memory that answers each query the
+ * way a Wow service over MongoDB does — filter, sort, page, projection and
+ * aggregation — so a host's test sees the engine's real queries answered by
+ * the semantics the engine is built on, not a canned answer.
+ *
+ * The documents are the snapshots (or event streams) as the service returns
+ * them: `aggregateId`, `ownerId` and `deleted` on the envelope, the state
+ * under `state`, times as epoch milliseconds. A document with
+ * `deleted: true` is left out unless the filter carries a `DELETION`
+ * condition. A cursor is an offset, as opaque to the caller as Wow's.
+ *
+ * What it cannot answer — an operator or shape it has no reading of, such as
+ * `ID`, `TENANT_ID`, `SPACE_ID` or the calendar filters (`TODAY`, …) the
+ * engine never sends — is refused with an error, so a query a test starts to
+ * send fails rather than getting a plausible wrong answer. The documents are
+ * read, never written; a test may change them between queries.
+ */
+export declare function memorySource(documents: readonly RecordData[], options?: MemorySourceOptions): ViewSource;
+//# sourceMappingURL=source.d.ts.map

package/dist/testing/source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/testing/source.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAKvD;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;OAMG;IACH,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAKD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,SAAS,UAAU,EAAE,EAChC,OAAO,GAAE,mBAAwB,GAChC,UAAU,CA0CZ"}

package/dist/testing/values.d.ts

@@ -0,0 +1,14 @@
+/** A field of a document by its dotted path; `undefined` where the path ends early. */
+export declare function valueAt(document: unknown, path: string): unknown;
+/** A time as epoch milliseconds, or `null` for what names no instant. */
+export declare function instantOf(at: unknown): number | null;
+/**
+ * The number a metric reads off one value, as `wow-mongo` reads it: a finite
+ * number, or the one number of an array that holds exactly one — an array of
+ * several is no number; null for anything else.
+ */
+export declare function numberOf(value: unknown): number | null;
+/** Two values in MongoDB's order, which is the one `ANY`'s `$max` reads. */
+export declare function compareValues(left: unknown, right: unknown): number;
+export declare function mod(value: number, by: number): number;
+//# sourceMappingURL=values.d.ts.map

package/dist/testing/values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.d.ts","sourceRoot":"","sources":["../../src/testing/values.ts"],"names":[],"mappings":"AAgBA,uFAAuF;AACvF,wBAAgB,OAAO,CAAC,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAUhE;AAED,yEAAyE;AACzE,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAKpD;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAItD;AAYD,4EAA4E;AAC5E,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CAUnE;AAED,wBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAErD"}