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

package/dist/runtime/source.d.ts

@@ -0,0 +1,108 @@
+import { AggregationQuery, CursorPage, CursorQuery, FilterPagedQuery, PagedList, QueryDescriptorResult } from '@ahoo-wang/wow-client';
+import { FieldOption, Issue, RecordData } from '../model/index.js';
+import { AnalysisProjection } from '../analysis/index.js';
+import { RecordProjection, SummaryRow } from '../record/index.js';
+/**
+ * Where a definition's data comes from. Three of `QueryApi`'s methods, so a
+ * Wow snapshot client satisfies it as it is; anything else can be written by
+ * hand for a test or for a non-Wow backend.
+ *
+ * Cancellation is an `AbortController` rather than the `AbortSignal` every
+ * other port takes (`OptionSource`, `ViewStore`) because that is what
+ * `QueryApi` accepts, and this port exists so that a wow-client query client
+ * plugs in unchanged. The controller is the engine's: it aborts it when a
+ * newer request takes this one's place, or when it is disposed. A source
+ * written by hand reads `abortController?.signal` and never aborts it. Should
+ * wow-client move to a signal, this port follows in the same minor
+ * (extension.md「宿主实现的接口怎样长」).
+ *
+ * Written out rather than `Pick<QueryApi, 'paged' | 'cursor' | 'aggregate'>`,
+ * for three reasons that all point the same way — this is the one type every
+ * source implements, and it must say exactly what this package needs:
+ *
+ * - `QueryApi.paged` takes `PagedQueryRequest`, which is
+ *   `FilterPagedQuery | PagedQuery`, and `PagedQuery` is deprecated. Picking
+ *   it would write the deprecated Wow API into the port that every source
+ *   fills, which `test/architecture.test.ts` bans everywhere else;
+ * - `QueryApi.aggregate` answers whatever row type its caller asserts
+ *   (`Row extends object`), and an asserted row is a row nothing checks.
+ *   Here it is `RecordData`, so every value arrives as `unknown` and is read
+ *   through a field's kind;
+ * - the pick would spread `QueryApi`'s two type parameters and its per-method
+ *   generics over every implementation, a test's stub included, for no gain:
+ *   all three methods are used at one instantiation only.
+ *
+ * What the pick would have bought — noticing upstream drift — is bought
+ * instead by an assignability assertion the compiler checks
+ * (`test/architecture.test.ts`, "Wow protocol"): a `QueryApi` must go on
+ * being a `ViewSource` without an adapter.
+ */
+export interface ViewSource {
+    paged(query: FilterPagedQuery, attributes?: Record<string, unknown>, abortController?: AbortController): Promise<PagedList<RecordData>>;
+    cursor(query: CursorQuery, attributes?: Record<string, unknown>, abortController?: AbortController): Promise<CursorPage<RecordData>>;
+    aggregate(query: AggregationQuery, attributes?: Record<string, unknown>, abortController?: AbortController): Promise<RecordData[]>;
+    /**
+     * The source's capability descriptor (capabilities.md 3): given the
+     * version already held, an unchanged one answers `notModified`.
+     * wow-client's `describeSnapshot` or `describeEventStream` fits it as it
+     * is. The engine reads it once per source before the first view over it
+     * runs, narrows each definition to what it admits and takes its limits,
+     * and checks it again on its own schedule. Left out, a view runs on the
+     * definition and the default limits alone, as it did before descriptors.
+     */
+    describe?(previous?: string, attributes?: Record<string, unknown>, abortController?: AbortController): Promise<QueryDescriptorResult>;
+}
+/**
+ * Remote candidates of a `reference` field: a paged search, and a lookup by id
+ * for the values a saved config already holds.
+ */
+export interface OptionSource {
+    search(input: {
+        query: string;
+        cursor?: string;
+    }, signal?: AbortSignal): Promise<{
+        items: FieldOption[];
+        nextCursor: string | null;
+    }>;
+    resolve(ids: (string | number)[], signal?: AbortSignal): Promise<FieldOption[]>;
+}
+/**
+ * What one execution produced, already shaped by its kernel. The discriminant
+ * equals the config's `kind`, so a renderer switches once and gets the view
+ * type its layout needs.
+ */
+export type ProjectedView = ProjectedRecord | ProjectedAnalysis;
+/**
+ * What both kinds carry besides their view: what is wrong with *these
+ * numbers*, as opposed to what is wrong with the config.
+ *
+ * `ViewRuntimeState.issues` cannot hold these. It is admission of the draft,
+ * recomputed on every keystroke, so a finding put there would vanish the
+ * moment the user touched the editor while the numbers it described were
+ * still on screen. A finding about a result belongs to the result, and lives
+ * exactly as long as it does: until the next successful execution replaces
+ * it. The strips read it beside `state.issues` and cannot tell them apart,
+ * which is the point — both are `warning`s the view has to say.
+ */
+export interface ProjectedBase {
+    /** Empty when the numbers mean what they appear to mean. */
+    issues: readonly Issue[];
+}
+export interface ProjectedRecord extends ProjectedBase {
+    kind: 'record';
+    view: RecordProjection;
+    /**
+     * Absent when the config asked for no summaries. Present with
+     * `scope: 'page'` when the totals query failed and the visible rows were
+     * added up instead — the numbers stay, `scope` says what they cover, and
+     * `issues` carries the warning that says why.
+     */
+    summaries: SummaryRow | null;
+}
+export interface ProjectedAnalysis extends ProjectedBase {
+    kind: 'analysis';
+    view: AnalysisProjection;
+}
+/** The findings of the last result, or none while there is no result. */
+export declare function resultIssues(data: ProjectedView | null | undefined): readonly Issue[];
+//# sourceMappingURL=source.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/runtime/source.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,gBAAgB,EAChB,UAAU,EACV,WAAW,EACX,gBAAgB,EAChB,SAAS,EACT,qBAAqB,EACtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,CACH,KAAK,EAAE,gBAAgB,EACvB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,eAAe,CAAC,EAAE,eAAe,GAChC,OAAO,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;IAClC,MAAM,CACJ,KAAK,EAAE,WAAW,EAClB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,eAAe,CAAC,EAAE,eAAe,GAChC,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC;IACnC,SAAS,CACP,KAAK,EAAE,gBAAgB,EACvB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,eAAe,CAAC,EAAE,eAAe,GAChC,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IACzB;;;;;;;;OAQG;IACH,QAAQ,CAAC,CACP,QAAQ,CAAC,EAAE,MAAM,EACjB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,eAAe,CAAC,EAAE,eAAe,GAChC,OAAO,CAAC,qBAAqB,CAAC,CAAC;CACnC;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,CACJ,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,EACzC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC;QAAE,KAAK,EAAE,WAAW,EAAE,CAAC;QAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;IAChE,OAAO,CACL,GAAG,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EACxB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;CAC3B;AAED;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,eAAe,GAAG,iBAAiB,CAAC;AAEhE;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B,4DAA4D;IAC5D,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,eAAgB,SAAQ,aAAa;IACpD,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,gBAAgB,CAAC;IACvB;;;;;OAKG;IACH,SAAS,EAAE,UAAU,GAAG,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,iBAAkB,SAAQ,aAAa;IACtD,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,kBAAkB,CAAC;CAC1B;AAED,yEAAyE;AACzE,wBAAgB,YAAY,CAC1B,IAAI,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,GACrC,SAAS,KAAK,EAAE,CAElB"}

package/dist/runtime/sourceReason.d.ts

@@ -0,0 +1,65 @@
+import { QueryViolation } from '@ahoo-wang/wow-client';
+/**
+ * What a source said went wrong: its reason in words, and — when it is a
+ * Wow service that rejected a query — which rule the query broke and where.
+ */
+export interface SourceFailure {
+    /** The reason, in the source's own words where it gave some. */
+    reason: string;
+    /**
+     * The first binding error of the body that carries a stable `code`: a
+     * query Wow rejected while decoding it (the JSON path) or admitting it
+     * against its query model (the logical field path, `''` for the model).
+     * Absent otherwise — a budget rejection, a failure the service did not
+     * answer, a source that is not Wow.
+     */
+    violation?: QueryViolation;
+    /** The service's `errorCode`, as it gave it, when it gave one. */
+    errorCode?: string;
+    /** The HTTP status the source answered with, when there was one. */
+    status?: number;
+    /**
+     * The request never reached the service: the browser's fetch rejected
+     * with a `TypeError` (「Failed to fetch」, 「Load failed」,
+     * 「NetworkError when attempting to fetch resource.」), bare or as the
+     * cause of an exchange that has no response, with no status and no
+     * body. `reason` keeps the browser's words, which are English whatever
+     * the reader's language, for the host; the reader is told the server
+     * could not be reached.
+     */
+    unreachable?: true;
+}
+/**
+ * What a source said went wrong, in its own words where it gave some.
+ *
+ * A source is the host's, and the engine words whatever it rejects with. A
+ * Wow service rejects a query it refuses with a 4xx whose body says why —
+ * `{ errorCode: 'IllegalArgument', errorMsg: 'HTTP page window[12000] must
+ * not exceed 10000.' }` — while the HTTP client's error only says that the
+ * request failed, and names the URL it failed for: an operator shown that
+ * learns nothing they can act on and something they should not see. So a
+ * rejection that carries its exchange (fetcher's `ExchangeError`, read by
+ * its shape rather than its class: the engine does not depend on the HTTP
+ * client, only on what an exchange offers) is asked for its body, and the
+ * service's message is the reason. A rejection that is itself such a body
+ * (wow-client's `WowError`, which a stream errors with) is read the same way.
+ * Without either, the status is all there is to say; anything else says what
+ * its message says.
+ *
+ * The body's first binding error with a `code` is the violation. It never
+ * rejects, and it reads a failure once however often it is asked.
+ */
+export declare function sourceFailure(error: unknown): Promise<SourceFailure>;
+/** The reason alone; see `sourceFailure`. */
+export declare function sourceReason(error: unknown): Promise<string>;
+/**
+ * Whether the source refused the reader rather than the query: HTTP 403, or
+ * one of Wow's `IllegalAccess*` codes — the owner's or the space's aggregate
+ * (`IllegalAccessOwnerAggregate`, `IllegalAccessSpaceAggregate`), a query
+ * the server requires a tenant scope for (`IllegalAccessQueryScope`), and
+ * any it adds under that prefix. `IllegalAccessDeletedAggregate` is not one:
+ * it is 410, the aggregate is gone, and asking again is no use for another
+ * reason.
+ */
+export declare function isForbiddenFailure(failure: SourceFailure): boolean;
+//# sourceMappingURL=sourceReason.d.ts.map

package/dist/runtime/sourceReason.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sourceReason.d.ts","sourceRoot":"","sources":["../../src/runtime/sourceReason.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,kEAAkE;IAClE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,IAAI,CAAC;CACpB;AASD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CAQpE;AAED,6CAA6C;AAC7C,wBAAsB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAElE;AA6FD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAQlE"}

package/dist/runtime/storedViews.d.ts

@@ -0,0 +1,17 @@
+import { ViewInstance } from '../model/index.js';
+import { ViewStore } from '../store/ViewStore.js';
+/**
+ * A stored view read into the form this engine writes — for a dashboard,
+ * `migrateDashboardConfig`; the same instance when it already is, so a view
+ * in this form is never a different object for having been read.
+ */
+export declare function readStored(instance: ViewInstance): ViewInstance;
+/**
+ * The host's store as the engine reads it: every view it hands back — read,
+ * created, saved or renamed, or carried by a write's conflict — through
+ * `readStored`, and every other call passed on as it is. A method is looked
+ * up on the host's store as it is called rather than once, so a store
+ * swapped or spied on after the engine was built is still the one asked.
+ */
+export declare function readingStore(store: ViewStore): ViewStore;
+//# sourceMappingURL=storedViews.d.ts.map

package/dist/runtime/storedViews.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storedViews.d.ts","sourceRoot":"","sources":["../../src/runtime/storedViews.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;GAUG;AAEH,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,YAAY,GAAG,YAAY,CAK/D;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,CA6BxD"}

package/dist/runtime/summaries.d.ts

@@ -0,0 +1,25 @@
+import { Issue, ViewInstance, ViewInstanceSummary } from '../model/index.js';
+import { ViewStore } from '../store/ViewStore.js';
+/**
+ * The stored half of a definition's list, which may fail on its own: a
+ * store that is down takes the saved views with it and nothing else, so the
+ * failure is answered beside an empty list rather than thrown (management.md).
+ * An id in the reserved `system:` namespace is dropped and handed to
+ * `reserved`: only a definition may declare one.
+ */
+export declare function storedSummaries(store: ViewStore, definitionId: string, reserved: (id: string) => void): Promise<{
+    stored: ViewInstanceSummary[];
+    failed: Issue | null;
+}>;
+export declare class SummaryCache {
+    private readonly cache;
+    /** Remembers a whole listing, declared system views included. */
+    noteAll(summaries: readonly ViewInstanceSummary[]): void;
+    /** Remembers the instance a write has just confirmed, as its summary. */
+    note(instance: ViewInstance): void;
+    /** Forgets a view that is gone; nothing may be written against it again. */
+    drop(id: string): void;
+    /** The last summary seen for `id`, or nothing when none ever was. */
+    get(id: string): ViewInstanceSummary | undefined;
+}
+//# sourceMappingURL=summaries.d.ts.map

package/dist/runtime/summaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summaries.d.ts","sourceRoot":"","sources":["../../src/runtime/summaries.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAGL,KAAK,KAAK,EACV,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACzB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAGvD;;;;;;GAMG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,SAAS,EAChB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,GAC7B,OAAO,CAAC;IAAE,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAAC,MAAM,EAAE,KAAK,GAAG,IAAI,CAAA;CAAE,CAAC,CAYlE;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA0C;IAEhE,iEAAiE;IACjE,OAAO,CAAC,SAAS,EAAE,SAAS,mBAAmB,EAAE,GAAG,IAAI;IAIxD,yEAAyE;IACzE,IAAI,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;IAIlC,4EAA4E;IAC5E,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAItB,qEAAqE;IACrE,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;CAGjD"}

package/dist/runtime/tabMemory.d.ts

@@ -0,0 +1,39 @@
+import { ViewInstance, ViewPreferences } from '../model/index.js';
+import { WriteHandle } from './write.js';
+/** What the memory borrows of the engine: the preferences and their writes. */
+export interface TabMemoryHost {
+    /** The preferences a write starts from (`PreferenceCache.current`). */
+    current(definitionId: string): Promise<ViewPreferences>;
+    /** One preference write through the ledger. */
+    write(definitionId: string, next: ViewPreferences): Promise<ViewPreferences>;
+    /** Lets an unsettled write go, so it holds nothing else back. */
+    abandon(handle: WriteHandle): void;
+}
+/**
+ * Where each reader last read each dashboard (D22 E): kept in their
+ * preferences for the board's definition (`ViewPreferences.lastTabs`), by
+ * instance id, and where a board opens when its host names no tab.
+ *
+ * It is a convenience and nothing more, so it never rejects and never leaves
+ * an outcome behind. A burst of tab switches writes the last one, once the
+ * write in flight settles — the ledger lets one preference write out at a
+ * time. A write that fails is let go: an unsettled preference write would
+ * hold back the list's own reorder and default, which matter more than
+ * which tab a board opens on.
+ */
+export declare class TabMemory {
+    private readonly host;
+    /** The tab each board is to be remembered on, by definition and instance. */
+    private readonly wanted;
+    /** The boards whose write is out. */
+    private readonly writing;
+    constructor(host: TabMemoryHost);
+    remember(definitionId: string, instanceId: string, tabId: string): Promise<void>;
+    /**
+     * The tab a board opens on: the one asked for while the board has it,
+     * else the one its reader last read it on; `null` for its first, and for
+     * any view that is no board.
+     */
+    opensOn(instance: ViewInstance, asked: string | null | undefined): Promise<string | null>;
+}
+//# sourceMappingURL=tabMemory.d.ts.map

package/dist/runtime/tabMemory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabMemory.d.ts","sourceRoot":"","sources":["../../src/runtime/tabMemory.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAEV,YAAY,EACZ,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAoB,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAEhE,+EAA+E;AAC/E,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,OAAO,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IACxD,+CAA+C;IAC/C,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAC7E,iEAAiE;IACjE,OAAO,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;CACpC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,SAAS;IAMR,OAAO,CAAC,QAAQ,CAAC,IAAI;IALjC,6EAA6E;IAC7E,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,qCAAqC;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;gBAEhB,IAAI,EAAE,aAAa;IAE1C,QAAQ,CACZ,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC;IAwBhB;;;;OAIG;IACG,OAAO,CACX,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;CAa1B"}

package/dist/runtime/text.d.ts

@@ -0,0 +1,20 @@
+import { TextResolver } from '../model/index.js';
+export declare class EngineText {
+    readonly start: TextResolver | undefined;
+    private readonly known;
+    private resolver;
+    private knownKeys;
+    /**
+     * `start` is the words the engine was built with, said wherever the words
+     * set later lack a key; `known` the keys the definitions write (read once,
+     * on first use).
+     */
+    constructor(start: TextResolver | undefined, known: () => ReadonlySet<string>);
+    /** Checks another language from now on. True when that changed anything. */
+    set(resolver: TextResolver | undefined): boolean;
+    /** The words for `key` in force: the ones set, else the ones started with. */
+    resolve(key: string): string | undefined;
+    /** Whether `resolver` has words for any key the definitions write. */
+    saysAny(resolver: TextResolver): boolean;
+}
+//# sourceMappingURL=text.d.ts.map

package/dist/runtime/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/runtime/text.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,qBAAa,UAAU;IAUnB,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,KAAK;IAVxB,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,SAAS,CAAkC;IAEnD;;;;OAIG;gBAEQ,KAAK,EAAE,YAAY,GAAG,SAAS,EACvB,KAAK,EAAE,MAAM,WAAW,CAAC,MAAM,CAAC;IAGnD,4EAA4E;IAC5E,GAAG,CAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,GAAG,OAAO;IAMhD,8EAA8E;IAC9E,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIxC,sEAAsE;IACtE,OAAO,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO;CAMzC"}

package/dist/runtime/unavailable.d.ts

@@ -0,0 +1,13 @@
+import { DataViewConfig, Issue } from '../model/index.js';
+/** The errors of `effective` that `declared` does not have. */
+export declare function unavailableIssues(effective: readonly Issue[], declared: readonly Issue[]): Issue[];
+/**
+ * The config with the first finding that can be taken out taken out, or
+ * `null` when none of them can: a condition goes (a filter's own or a
+ * metric's), a sort entry goes, 「只保留」 goes whole, a dimension keeps
+ * its field but loses the missing-value group or the filled gaps. A
+ * dimension or a metric the source cannot compute stays — taking it out
+ * would change the question, not trim it — and is left to the reader.
+ */
+export declare function withoutFirstUnavailable<C extends DataViewConfig>(config: C, issues: readonly Issue[]): C | null;
+//# sourceMappingURL=unavailable.d.ts.map

package/dist/runtime/unavailable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unavailable.d.ts","sourceRoot":"","sources":["../../src/runtime/unavailable.ts"],"names":[],"mappings":"AAaA;;;;;;;;;GASG;AAEH,OAAO,EAGL,KAAK,cAAc,EAEnB,KAAK,KAAK,EAEX,MAAM,mBAAmB,CAAC;AAa3B,+DAA+D;AAC/D,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,SAAS,KAAK,EAAE,EAC3B,QAAQ,EAAE,SAAS,KAAK,EAAE,GACzB,KAAK,EAAE,CAUT;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,cAAc,EAC9D,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,SAAS,KAAK,EAAE,GACvB,CAAC,GAAG,IAAI,CAMV"}

package/dist/runtime/validateDefinition.d.ts

@@ -0,0 +1,43 @@
+import { Issue, RuntimeLimits, ViewDefinition } from '../model/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+export interface ValidateDefinitionOptions {
+    limits?: RuntimeLimits;
+    /**
+     * The other definitions registered beside this one, by id. A board a
+     * definition declares may own an analysis of another definition, and that
+     * analysis is judged whole against it. Left out, an owned analysis is
+     * judged by its shape alone.
+     */
+    definitions?: (definitionId: string) => ViewDefinition | undefined;
+}
+/**
+ * Admits a definition.
+ *
+ * Definitions are code, not data, so this does not run on every keystroke; it
+ * runs once, where an application registers them. What it buys is that every
+ * invariant the rest of the package assumes becomes a reported finding rather
+ * than an exception several layers down: `systemInstanceId` composes ids with
+ * `:`, `defaultRecordConfig` reads `layouts[0]`, `defaultAnalysisConfig`
+ * assumes some metric is constructible, and the compilers assume field names
+ * are Wow query paths. Each of those would otherwise surface as a `TypeError`
+ * at the moment a user opened a view.
+ *
+ * It lives beside the runtime rather than in a kernel because it needs all
+ * three of them at once, and a kernel may not import another kernel.
+ */
+export declare function validateDefinition(definition: ViewDefinition, kinds: FieldKindRegistry, options?: ValidateDefinitionOptions): Issue[];
+/**
+ * Whether a definition may be opened at all: it has no error, bar one a
+ * declared board's panel owns (`boardPanelFinding`).
+ *
+ * A board is opened panel by panel, and its runtime judges each panel again
+ * with its references in hand and puts out only the one that cannot run
+ * (`blocksBoard`). A definition refused for one bad panel would take every
+ * good panel of every board it declares down with it, and say nothing of
+ * which panel or why, since nothing opens to say it. So what a board holds
+ * apart from its panels — its grid, its filters, its fixed scope, its tabs,
+ * how many panels it has — refuses the definition as before, and a panel's
+ * own error is said on that panel when the board opens.
+ */
+export declare function isUsableDefinition(issues: readonly Issue[]): boolean;
+//# sourceMappingURL=validateDefinition.d.ts.map

package/dist/runtime/validateDefinition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateDefinition.d.ts","sourceRoot":"","sources":["../../src/runtime/validateDefinition.ts"],"names":[],"mappings":"AAcA,OAAO,EASL,KAAK,KAAK,EAGV,KAAK,aAAa,EAElB,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAS,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAYnE,MAAM,WAAW,yBAAyB;IACxC,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,cAAc,GAAG,SAAS,CAAC;CACpE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,cAAc,EAC1B,KAAK,EAAE,iBAAiB,EACxB,OAAO,GAAE,yBAA8B,GACtC,KAAK,EAAE,CA4BT;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,OAAO,CAIpE"}

package/dist/runtime/validateFields.d.ts

@@ -0,0 +1,9 @@
+import { FieldDefinition, Issue, IssuePath } from '../model/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+/**
+ * Admits a definition's fields, and each array's element fields in turn:
+ * names, kinds, the declarations each kind reads, and what a search looks
+ * in. `validateDefinition` calls it on `definition.fields`.
+ */
+export declare function validateFields(fields: readonly FieldDefinition[], kinds: FieldKindRegistry, path: IssuePath, inElement?: boolean): Issue[];
+//# sourceMappingURL=validateFields.d.ts.map

package/dist/runtime/validateFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateFields.d.ts","sourceRoot":"","sources":["../../src/runtime/validateFields.ts"],"names":[],"mappings":"AAaA,OAAO,EAcL,KAAK,eAAe,EACpB,KAAK,KAAK,EACV,KAAK,SAAS,EACf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAS,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEnE;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,SAAS,eAAe,EAAE,EAClC,KAAK,EAAE,iBAAiB,EACxB,IAAI,EAAE,SAAS,EACf,SAAS,UAAQ,GAChB,KAAK,EAAE,CA8JT"}

package/dist/runtime/valueCandidates.d.ts

@@ -0,0 +1,58 @@
+import { FilterTree } from '../model/index.js';
+import { ValueCandidates } from '../analysis/index.js';
+import { KernelContext } from './execute.js';
+/**
+ * The values a condition on one field may be picked from, counted from the
+ * data (`valueCandidatesConfig`). Handed out by `ViewRuntime.valueCandidates`
+ * once per field, so an editor may key an effect on it.
+ */
+export interface ValueCandidateSource {
+    /** The field whose values these are, as the condition names it. */
+    readonly field: string;
+    /**
+     * The most frequent values holding `query` (all of them while it is
+     * blank). Rejects with what the source threw, and with the signal's reason
+     * once it aborts.
+     */
+    search(query: string, signal?: AbortSignal): Promise<ValueCandidates>;
+}
+/**
+ * Every candidate source of one data view, and what they have answered.
+ *
+ * An answer is kept for the life of the view, keyed by field and by what was
+ * typed: a condition reopened, or a second condition on the same field, asks
+ * nothing again. What narrows without asking is narrowed here — once the
+ * unnarrowed list came back whole there is nothing more the source could
+ * add, and a field that offers no substring or prefix condition cannot be
+ * narrowed by the source at all — so the source is asked only for a question
+ * whose answer is not already in hand.
+ *
+ * The answers belong to the scope they were asked under. A host that
+ * narrows the view to another tenant is asking about other records, so
+ * `reset` forgets them, and an answer still on its way from before is not
+ * kept.
+ */
+export declare class ValueCandidateSources {
+    private readonly context;
+    private readonly scope;
+    private readonly sources;
+    private readonly answers;
+    private generation;
+    /** The scope the answers in hand were asked under (`scoped`). */
+    private askedUnder;
+    constructor(context: KernelContext, scope: () => FilterTree | null);
+    /** The source of `field`, or `null` when its values are not offered. */
+    of(name: string): ValueCandidateSource | null;
+    /** Forgets every answer: the scope they were asked under has changed. */
+    reset(): void;
+    private search;
+    /**
+     * The scope in force now. Answers asked under another are forgotten, so
+     * whatever moved it — a host's condition, a board's fixed scope, a value
+     * the host holds — the values are counted again rather than read from
+     * before, whether or not anyone called `reset`.
+     */
+    private scoped;
+    private ask;
+}
+//# sourceMappingURL=valueCandidates.d.ts.map

package/dist/runtime/valueCandidates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueCandidates.d.ts","sourceRoot":"","sources":["../../src/runtime/valueCandidates.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAGV,UAAU,EACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAQL,KAAK,eAAe,EACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAMlD;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,mEAAmE;IACnE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;CACvE;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,qBAAqB;IAQ9B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK;IARxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkD;IAC1E,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;IAC9D,OAAO,CAAC,UAAU,CAAK;IACvB,iEAAiE;IACjE,OAAO,CAAC,UAAU,CAA2B;gBAG1B,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,MAAM,UAAU,GAAG,IAAI;IAGjD,wEAAwE;IACxE,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI;IAiB7C,yEAAyE;IACzE,KAAK,IAAI,IAAI;YAKC,MAAM;IAqBpB;;;;;OAKG;IACH,OAAO,CAAC,MAAM;YASA,GAAG;CAiDlB"}

package/dist/runtime/viewChanges.d.ts

@@ -0,0 +1,39 @@
+import { Issue } from '../model/index.js';
+/**
+ * The write that changed a list — **not** the kind of the view it changed.
+ *
+ * These five are what a list of views can see: one appeared, one was saved,
+ * one was renamed, one moved to the other audience (and so to the other
+ * group), one is gone.
+ * A preference write is not among them: it changes the order and the default,
+ * which the caller that wrote them already holds.
+ */
+export type ViewChangeKind = 'create' | 'save' | 'rename' | 'changeAudience' | 'delete';
+/** What a confirmed write changed about one definition's list of views. */
+export interface ViewChange {
+    definitionId: string;
+    kind: ViewChangeKind;
+    id: string;
+}
+export type ViewChangeListener = (change: ViewChange) => void;
+/**
+ * Who is listening for list changes, and what they are told.
+ *
+ * The engine is the only place that knows when a write lands, so it says so
+ * rather than leaving every caller to remember (D15). The shape is a
+ * runtime's: `subscribe` returns the way to stop listening.
+ */
+export declare class ViewChanges {
+    /**
+     * A listener that throws is contained: `emit` is called from inside a write
+     * that has just been confirmed, and letting it out would record a write
+     * that landed as an outcome the user is asked to retry.
+     */
+    private readonly listeners;
+    private readonly report;
+    constructor(report: (found: Issue) => void);
+    subscribe(listener: ViewChangeListener): () => void;
+    emit(change: ViewChange): void;
+    clear(): void;
+}
+//# sourceMappingURL=viewChanges.d.ts.map

package/dist/runtime/viewChanges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewChanges.d.ts","sourceRoot":"","sources":["../../src/runtime/viewChanges.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAG/C;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GACxB,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,gBAAgB,GAAG,QAAQ,CAAC;AAE7D,2EAA2E;AAC3E,MAAM,WAAW,UAAU;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,cAAc,CAAC;IACrB,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;AAE9D;;;;;;GAMG;AACH,qBAAa,WAAW;IACtB;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,SAAS,CAIxB;IACF,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyB;gBAEpC,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI;IAI1C,SAAS,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,IAAI;IAInD,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAI9B,KAAK,IAAI,IAAI;CAGd"}