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

package/dist/runtime/pending.d.ts

@@ -0,0 +1,75 @@
+import { Issue, ViewConfig } from '../model/index.js';
+/**
+ * What the draft says that the applied config does not (D17-6).
+ *
+ * "Changed, not applied" is one of the screen's three credentials (D2), and
+ * it used to be measured on the filter tree alone. Every other member of the
+ * config could stand apart from `applied` with nothing on screen to say so:
+ * a control that edits without applying — the filter mode, the analysis
+ * editor's groups, metrics, sort, limit and chart, which all wait for Run —
+ * and a control that edits and applies whose apply was refused, because the
+ * draft holds an error and `apply` does not land. The sort editor, the page
+ * size and the column settings then read the draft while the rows are still
+ * the last execution's.
+ *
+ * So the credential is the whole config: `draft` against `applied`, member
+ * by member. The conditions keep their finer reading — node by node, which is
+ * what marks one pill and not its ancestors — and every other member counts
+ * as one edit when it differs. A refused apply counts, since the two configs
+ * still disagree; a draft equal to what was applied does not, whatever the
+ * issues say about either.
+ *
+ * It lives in the runtime layer because `dequal` is the runtime's (see
+ * `test/architecture.test.ts`): the same equality `revert` decides by.
+ */
+export interface PendingReport {
+    /** True when the draft says anything the applied config does not. */
+    pending: boolean;
+    /**
+     * How many edits wait for apply: the conditions edited since the last
+     * apply, node by node, plus one for every other member that differs.
+     */
+    count: number;
+    /**
+     * Whether the conditions themselves differ. The filter editor's discard
+     * puts the conditions back and nothing else, so it is offered on this
+     * rather than on `pending`.
+     */
+    conditions: boolean;
+}
+/**
+ * Whether `issues` refuse the config's own filter tree for its size. Such a
+ * tree — from a store, possibly holding a cycle — is not walked at all: it
+ * blocked apply, so it stands apart from `applied` by construction and
+ * counts as one edit. An analysis element's or a dashboard panel's own
+ * filter reports the very same codes under `['elements', …]` or
+ * `['panels', …]`; the path is what says the finding is the root tree's.
+ */
+export declare function filterOverBudget(issues: readonly Issue[]): boolean;
+export declare function comparePending(draft: ViewConfig, applied: ViewConfig, issues: readonly Issue[]): PendingReport;
+/**
+ * Whether the draft waits for apply on anything `patch` does not write.
+ *
+ * A control that edits one member and runs — a header's sort above all —
+ * may run only while nothing else waits: running applies the whole draft,
+ * and a condition still waiting in the range is not the control's to apply
+ * (todo 「记录视图按表头排序」; the analysis header's `sortNow`, #1807). The
+ * patch is laid over both sides before they are compared, so an edit to the
+ * same member that was held back earlier — which this one replaces — does
+ * not count as another.
+ */
+export declare function pendingBesides<C extends ViewConfig>(state: {
+    draft: C;
+    applied: C;
+    issues: readonly Issue[];
+}, patch: Partial<C>): boolean;
+/**
+ * Whether the draft differs from what was saved **only** in how the result
+ * is drawn — the layout, the chart (`presentationMembers`) — and in at least
+ * one of those (D23 Q15). The title bar then says 「只改了展示」 rather than
+ * a bare 「已修改」, and takes the edits back without asking: what would be
+ * lost is a way of looking, not a question, and putting the saved one back
+ * runs nothing (a presentation edit never reached `applied`).
+ */
+export declare function presentationOnlyEdits(draft: ViewConfig, saved: ViewConfig): boolean;
+//# sourceMappingURL=pending.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pending.d.ts","sourceRoot":"","sources":["../../src/runtime/pending.ts"],"names":[],"mappings":"AAqBA,OAAO,EAGL,KAAK,KAAK,EACV,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,aAAa;IAC5B,qEAAqE;IACrE,OAAO,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,UAAU,EAAE,OAAO,CAAC;CACrB;AAID;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,OAAO,CAOlE;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,SAAS,KAAK,EAAE,GACvB,aAAa,CAiCf;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,UAAU,EACjD,KAAK,EAAE;IAAE,KAAK,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAA;CAAE,EACzD,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAChB,OAAO,CAMT;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,UAAU,GAChB,OAAO,CAWT"}

package/dist/runtime/permissions.d.ts

@@ -0,0 +1,80 @@
+import { ViewInstanceSummary, ViewScope } from '../model/index.js';
+import { InstancePermissions, ViewPermissions, ViewStore } from '../store/ViewStore.js';
+/**
+ * Everything is allowed when a store declares no permissions — everything a
+ * silence allows: `editSystem` is not among it (D81).
+ */
+export declare const ALLOW_ALL: ViewPermissions;
+/**
+ * Every action an instance permission answers for. The `satisfies` above is
+ * what makes it *every* one: a fourth member of `InstancePermissions` does
+ * not compile until it is named here, and `test/messages.test.tsx` expands
+ * this set into the `view.<action>.forbidden` codes the catalogue owes a
+ * sentence to.
+ */
+export declare const INSTANCE_ACTIONS: readonly (keyof InstancePermissions)[];
+/** What may be done to one instance, and — when nothing may — why not. */
+export interface InstanceAbilities extends Required<InstancePermissions> {
+    /**
+     * True when the refusal is the view's own nature rather than the store's
+     * answer. The guard words that refusal differently
+     * (`view.system.read-only`), and it is the one thing a caller cannot fix
+     * by being granted more.
+     */
+    readOnly: boolean;
+}
+/**
+ * What may be done to one instance: the store's answer for its id, with a
+ * system view read-only whatever that answer is — it lives in code or in
+ * the backend's configuration, and no store write can reach it — unless it
+ * is one the store keeps (`stored`), its id is not a code view's
+ * (`system:`), and the host grants `editSystem` (D81). Then the store's
+ * answer applies to it as to a shared view, bar `changeAudience`, which is
+ * always false: a system view never moves audience.
+ *
+ * **One reading, for both callers.** D4 has a manager's button exist exactly
+ * where the command would be allowed, so the guard and the manager asking
+ * separately is two answers to one question: the two spelled the system
+ * check out apart from each other, and the pair is only ever one edit away
+ * from offering a Rename the guard then refuses.
+ *
+ * A scope that is not to hand is not a system view: an id the manager's rows
+ * do not hold gets the store's answer, and the guard — which always has the
+ * scope, because it reads a summary or an instance — is the one that refuses
+ * it for certain.
+ *
+ * `changeAudience` answers for the move the manager offers — to the other
+ * audience — so it asks the store's `changeAudience` (silence allows it, as
+ * everywhere) **and** the create permission of the audience the view goes
+ * to: sharing puts a view in front of everyone, which is what
+ * `createShared` guards, however the view came to exist.
+ */
+export declare function instanceAbilities(summary: {
+    id: string;
+    scope?: ViewScope;
+    stored?: boolean;
+}, permissions: ViewPermissions): InstanceAbilities;
+export declare class PermissionGuard {
+    private readonly store;
+    constructor(store: ViewStore);
+    /**
+     * The store's answer, or everything. A store without `changeAudience` has
+     * no such move to permit, so its answer says so for every instance — the
+     * one reading the manager's buttons and this guard share (D4).
+     */
+    of(definitionId: string): ViewPermissions;
+    /** A system view is created only where `editSystem` is granted (D81). */
+    requireCreate(definitionId: string, scope: ViewScope): void;
+    /**
+     * Asks for identity, scope and whether the store keeps it, so an instance
+     * answers as well as a summary.
+     */
+    requireInstance(instance: Pick<ViewInstanceSummary, 'id' | 'definitionId' | 'scope' | 'stored'>, action: keyof InstancePermissions): void;
+    require(allowed: boolean, code: string): void;
+}
+/**
+ * Whether a view may be created in `scope`: the audience's create
+ * permission, and for a system view `editSystem`, whose silence refuses.
+ */
+export declare function mayCreate(permissions: ViewPermissions, scope: ViewScope): boolean;
+//# sourceMappingURL=permissions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../../src/runtime/permissions.ts"],"names":[],"mappings":"AAaA;;;;;;;;;GASG;AAEH,OAAO,EAIL,KAAK,mBAAmB,EACxB,KAAK,SAAS,EACf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EACV,mBAAmB,EACnB,eAAe,EACf,SAAS,EACV,MAAM,uBAAuB,CAAC;AAG/B;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE,eAWvB,CAAC;AAiBF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAExB,SAAS,CAAC,MAAM,mBAAmB,CAAC,EAAE,CAAC;AAE5C,0EAA0E;AAC1E,MAAM,WAAW,iBAAkB,SAAQ,QAAQ,CAAC,mBAAmB,CAAC;IACtE;;;;;OAKG;IACH,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,SAAS,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,EAC5D,WAAW,EAAE,eAAe,GAC3B,iBAAiB,CA8BnB;AAkBD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;gBAEtB,KAAK,EAAE,SAAS;IAI5B;;;;OAIG;IACH,EAAE,CAAC,YAAY,EAAE,MAAM,GAAG,eAAe;IAkBzC,yEAAyE;IACzE,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI;IAO3D;;;OAGG;IACH,eAAe,CACb,QAAQ,EAAE,IAAI,CACZ,mBAAmB,EACnB,IAAI,GAAG,cAAc,GAAG,OAAO,GAAG,QAAQ,CAC3C,EACD,MAAM,EAAE,MAAM,mBAAmB,GAChC,IAAI;IAiBP,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;CAG9C;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,WAAW,EAAE,eAAe,EAC5B,KAAK,EAAE,SAAS,GACf,OAAO,CAKT"}

package/dist/runtime/preferences.d.ts

@@ -0,0 +1,37 @@
+import { ViewInstanceSummary, ViewPreferences } from '../model/index.js';
+import { ViewStore } from '../store/ViewStore.js';
+export declare class PreferenceCache {
+    private readonly store;
+    private readonly cache;
+    /**
+     * How many times each definition's preferences were confirmed by a write
+     * (`note`). Revisions are opaque, so which of two is newer cannot be read
+     * off them; what can be told is that a write confirmed while a read was
+     * on its way, and the read then answers the state before it.
+     */
+    private readonly notes;
+    constructor(store: ViewStore);
+    /**
+     * Reads through to the store, and remembers what came back — unless a
+     * write confirmed newer preferences while the read was on its way: the
+     * read started before that write, so it answers the cached ones instead,
+     * and the next reorder does not start from a revision already gone.
+     */
+    read(definitionId: string): Promise<ViewPreferences>;
+    /** Remembers preferences a write has just confirmed. */
+    note(definitionId: string, preferences: ViewPreferences): void;
+    /** What a write starts from: the last value known, else a read. */
+    current(definitionId: string): Promise<ViewPreferences>;
+}
+/**
+ * Preferred order first, then whatever the server returned. An id that no
+ * longer exists is ignored rather than removed: the next write cleans it up.
+ */
+export declare function orderSummaries(summaries: readonly ViewInstanceSummary[], preferences: ViewPreferences): ViewInstanceSummary[];
+/**
+ * The effective default: an explicit id, else the stored one when it still
+ * exists, else the first of the ordered list, which is usually the first
+ * system view.
+ */
+export declare function resolveDefault(summaries: readonly ViewInstanceSummary[], preferences: ViewPreferences, explicit?: string): string | null;
+//# sourceMappingURL=preferences.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preferences.d.ts","sourceRoot":"","sources":["../../src/runtime/preferences.ts"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;IAClC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsC;IAC5D;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA6B;gBAEvC,KAAK,EAAE,SAAS;IAI5B;;;;;OAKG;IACG,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAS1D,wDAAwD;IACxD,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,eAAe,GAAG,IAAI;IAK9D,mEAAmE;IAC7D,OAAO,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;CAG9D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,SAAS,mBAAmB,EAAE,EACzC,WAAW,EAAE,eAAe,GAC3B,mBAAmB,EAAE,CAQvB;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,SAAS,mBAAmB,EAAE,EACzC,WAAW,EAAE,eAAe,EAC5B,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,GAAG,IAAI,CAMf"}

package/dist/runtime/publish.d.ts

@@ -0,0 +1,38 @@
+import { ViewConfig, ViewInstance, ViewScope } from '../model/index.js';
+import { ViewStore } from '../store/ViewStore.js';
+import { PermissionGuard } from './permissions.js';
+import { SummaryCache } from './summaries.js';
+import { WriteLedger } from './writeLedger.js';
+/** What a saved view a panel references is, as far as it can be read. */
+export type ReferenceOf = (id: string) => Promise<{
+    scope: ViewScope;
+    title: string;
+} | undefined>;
+/**
+ * Creates the copy of the saved view `id` (`read`: an open view's saved
+ * instance, else the store's) — its title and its saved config, never a
+ * draft — as a stored system view. Asked first: that the source is not a
+ * system view already (`view.system.read-only`, as the manager offers no
+ * such button), `editSystem` (`view.create.forbidden`) and the config's
+ * size; a board's panels the ledger asks of every create into the system
+ * scope (`requireSystemPanels`). The source is not
+ * written; the copy lands like a 另存为 (`save-as`), bound to no open view.
+ */
+export declare function publishCopy(guard: PermissionGuard, ledger: WriteLedger, id: string, read: () => Promise<ViewInstance>): Promise<ViewInstance>;
+/**
+ * Refuses a board headed for the system views when any panel references a
+ * saved view that is not a system view — the one it shows, the one
+ * 「在工作台中打开」 opens, or the one a press opens — naming those panels
+ * (`dashboard.system.non-system-panels`): such a panel would be blank for
+ * every reader in every other tenant. A view the board owns, and a view
+ * that cannot be read, count as they are: owned is fine, unreadable is not.
+ * Asked of a `scope` other than `system`, it lets the board pass.
+ */
+export declare function requireSystemPanels(config: ViewConfig, referenceOf: ReferenceOf, scope?: ViewScope): Promise<void>;
+/**
+ * How the engine reads a panel's saved view for `requireSystemPanels`: the
+ * summary it last saw, else the store's copy; one that cannot be read is
+ * none.
+ */
+export declare function readReferences(summaries: SummaryCache, store: ViewStore): ReferenceOf;
+//# sourceMappingURL=publish.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"publish.d.ts","sourceRoot":"","sources":["../../src/runtime/publish.ts"],"names":[],"mappings":"AAaA;;;;;;GAMG;AAEH,OAAO,EAIL,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,SAAS,EACf,MAAM,mBAAmB,CAAC;AAI3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,yEAAyE;AACzE,MAAM,MAAM,WAAW,GAAG,CACxB,EAAE,EAAE,MAAM,KACP,OAAO,CAAC;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC,CAAC;AAE9D;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,WAAW,EACnB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,GAChC,OAAO,CAAC,YAAY,CAAC,CAuBvB;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,WAAW,EACxB,KAAK,GAAE,SAAoB,GAC1B,OAAO,CAAC,IAAI,CAAC,CA+Bf;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,YAAY,EACvB,KAAK,EAAE,SAAS,GACf,WAAW,CAEb"}

package/dist/runtime/queryFailure.d.ts

@@ -0,0 +1,59 @@
+import { DataViewDefinition, FilterTree, Issue } from '../model/index.js';
+import { SourceFailure } from './sourceReason.js';
+import { ViewQueryState } from './viewRuntimeTypes.js';
+/**
+ * The Issue a failed execution reports: a request the queue turned away,
+ * or what the source said (`queryFailureIssue`), read against the view's
+ * own filter.
+ */
+export declare function failedExecutionIssue(error: unknown, definition: DataViewDefinition, filter: FilterTree | undefined): Promise<Issue>;
+/**
+ * The query state a failure leaves. The rows it keeps on screen answer the
+ * conditions they were asked under (`kept`, the result on screen); when those are not the ones
+ * that just failed (`asked`), the screen has to say so
+ * (`ViewQueryState.conditionsChanged`). Scope included, so a board's filter
+ * counts.
+ */
+export declare function failedQuery(error: Issue, requestId: string, kept: {
+    config: {
+        filter?: FilterTree;
+    };
+} | null | undefined, asked: {
+    filter?: FilterTree;
+}): ViewQueryState;
+/**
+ * The Issue a failed query shows, from what the source said.
+ *
+ * A source that refused the reader rather than the query — HTTP 403, or one
+ * of Wow's `IllegalAccess*` codes (`isForbiddenFailure`) — is
+ * `runtime.query.forbidden`, with `reason` and the service's `errorCode`:
+ * the permission state, which a retry does not change.
+ *
+ * A request that never reached the service (`unreachable`: fetch's own
+ * `TypeError`, 「Failed to fetch」) is `runtime.query.unreachable`, said in
+ * the reader's words rather than the browser's English; `reason` keeps the
+ * browser's for the host.
+ *
+ * Without a violation it is `runtime.query.failed` with the source's reason.
+ * With one — a Wow service naming the rule the query broke — the code is
+ * `runtime.query.failed.<code>` (the violation's code in lower case), which
+ * the catalogue words per rule; a code it has no wording for falls back
+ * along the dots to `runtime.query.failed` and the service's own words, so
+ * a rule a newer service adds still reads. The params say:
+ *
+ * - `reason`: the service's message, always;
+ * - `code` and `path`: the violation as the service gave it;
+ * - `field`: the field it is about by its label, when the definition
+ *   declares one at that path (an element field as its array's label and
+ *   its own), else the path itself;
+ * - `name`: that field's name in the definition, when it declares one.
+ *
+ * The Issue's `path` is the condition of the view's own filter the rule is
+ * about (`['children', 1]`), when one names that field — an element-match
+ * condition when the field is one of its array's elements — so the editor
+ * can mark that row; otherwise `[]`.
+ */
+export declare function queryFailureIssue(failure: SourceFailure, definition: DataViewDefinition, filter: FilterTree | undefined): Issue;
+/** Whether a query's Issue is the permission state; see `queryFailureIssue`. */
+export declare function isForbiddenQuery(found: Issue | null | undefined): boolean;
+//# sourceMappingURL=queryFailure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"queryFailure.d.ts","sourceRoot":"","sources":["../../src/runtime/queryFailure.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,kBAAkB,EAElB,UAAU,EACV,KAAK,EAEN,MAAM,mBAAmB,CAAC;AAI3B,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,OAAO,EACd,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,UAAU,GAAG,SAAS,GAC7B,OAAO,CAAC,KAAK,CAAC,CAIhB;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE;IAAE,MAAM,EAAE;QAAE,MAAM,CAAC,EAAE,UAAU,CAAA;KAAE,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,EAC5D,KAAK,EAAE;IAAE,MAAM,CAAC,EAAE,UAAU,CAAA;CAAE,GAC7B,cAAc,CAQhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,aAAa,EACtB,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,UAAU,GAAG,SAAS,GAC7B,KAAK,CA2BP;AA2DD,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAEzE"}

package/dist/runtime/queryWeight.d.ts

@@ -0,0 +1,29 @@
+import { AggregationQuery, FilterExpression, HavingExpression } from '@ahoo-wang/wow-client';
+/**
+ * What a query's conditions weigh as a Wow service's query guard weighs
+ * them (`QueryBudget` in wow-query): every node of every filter the query
+ * carries — its own, an element's, each metric's — then every node of its
+ * 「只保留」, counted on one tally; and the longest list of values any one
+ * node holds.
+ */
+export interface QueryWeight {
+    nodes: number;
+    /** The most values one node carries: an `IN` list, `IDS`, a having `IN`. */
+    values: number;
+}
+/**
+ * The weight of the filters a query sends and, for an aggregation, of its
+ * having, counted as the guard counts the compiled query — not the config's
+ * tree, where a date range is one condition and three nodes once compiled.
+ * The caller's own scope, which the service adds from who is asking, is not
+ * the engine's to see and is not in it.
+ */
+export declare function queryWeight(filters: readonly FilterExpression[], having?: HavingExpression): QueryWeight;
+/**
+ * The weight of what an aggregation query sends; see `queryWeight`. As the
+ * guard reads it, a filter left out is `MATCH_ALL` and counts as one node —
+ * the query's own and each element's — while a metric's counts only when it
+ * narrows anything.
+ */
+export declare function aggregationWeight(query: AggregationQuery): QueryWeight;
+//# sourceMappingURL=queryWeight.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"queryWeight.d.ts","sourceRoot":"","sources":["../../src/runtime/queryWeight.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACtB,MAAM,uBAAuB,CAAC;AAE/B;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,MAAM,CAAC,EAAE,gBAAgB,GACxB,WAAW,CAmBb;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,gBAAgB,GAAG,WAAW,CAatE"}

package/dist/runtime/recordRuntime.d.ts

@@ -0,0 +1,88 @@
+import { DataViewConfig, RecordData, RecordKey, RecordPageTarget, RecordViewConfig } from '../model/index.js';
+import { ExportRowsOptions, ExportedRows } from './exportRows.js';
+import { SourceFailure } from './sourceReason.js';
+import { ProjectedView } from './source.js';
+import { DataViewRuntime } from './viewRuntime.js';
+import { RecordViewRuntime, ViewRuntime, ViewRuntimeOptions, ViewRuntimeState } from './viewRuntimeTypes.js';
+/**
+ * The runtime of a Record view: the shared data view, plus what only rows
+ * have — the page a query asks for, the rows picked, every row for an
+ * export, one record read whole.
+ *
+ * Each is here and nowhere else, so an Analysis runtime carries no page it
+ * never turns and no `exportRows` it can only refuse.
+ */
+export declare class RecordDataViewRuntime extends DataViewRuntime<RecordViewConfig> implements RecordViewRuntime {
+    /** The page the next query asks for. */
+    private target;
+    /**
+     * Whether the page on screen is one a refused cursor already sent back
+     * to the start; cleared when a page lands, so the fall-back is once per
+     * refusal and never a loop.
+     */
+    private restarted;
+    /** Tells the host of an export whose rows could not be fetched (D40). */
+    private readonly exportFailed;
+    constructor(options: ViewRuntimeOptions<RecordViewConfig>);
+    page(target: RecordPageTarget): void;
+    select(keys: RecordKey[]): void;
+    /**
+     * The applied config's rows, all of them, for an export.
+     *
+     * It reads `applied` merged with the scope — the very config the result on
+     * screen came from — and goes straight to the source: the request runner is
+     * the view's own lane and an export must neither queue behind the view nor
+     * push it aside.
+     */
+    exportRows(options?: ExportRowsOptions): Promise<ExportedRows>;
+    fetchRecord(key: RecordKey, signal?: AbortSignal): Promise<RecordData | null>;
+    /**
+     * A draft that changes only how the rows on screen are drawn keeps them:
+     * the page, its selection and the reader's place stay, and only the
+     * columns are projected again (`restyleRecord`). One whose summaries
+     * changed too asks the source for the summary row alone, quietly: the
+     * query stays `success` and the rows stay drawn while it is out. Either
+     * way the page is not fetched, and nothing says 「正在查询」 or draws the
+     * table as waiting over rows that stay.
+     *
+     * Only over a result that landed and is current: while a query is out (a
+     * quiet one included), or after one failed, the rows on screen are not the answer to the config
+     * that ran, and the whole query runs as before. And only for a draft that
+     * differs from what ran: an apply that changes nothing — Apply with
+     * nothing pending, Enter in the search box, a host's `apply()` — is a
+     * request to ask again, and runs whole from the first page.
+     */
+    protected restyle(draft: RecordViewConfig): (() => void) | null;
+    /** A new question starts on the first page, with nothing picked. */
+    protected startOver(): Partial<ViewRuntimeState<RecordViewConfig>>;
+    protected pageNow(): RecordPageTarget | undefined;
+    /**
+     * A cursor the source no longer reads — a token from before the service
+     * changed how it writes one (#3502), or one a replica does not know —
+     * sends the view back to the first page once, rather than showing a
+     * failure the reader can do nothing about but start over by hand.
+     */
+    protected recovers(failure: SourceFailure): boolean;
+    /**
+     * A page the result shrank out from under asks for the last page there is
+     * rather than landing empty with rows before it; a refresh keeps whatever
+     * picked rows survive it.
+     */
+    protected settle(data: ProjectedView, keepSelection: boolean): Partial<ViewRuntimeState<RecordViewConfig>> | null;
+    /**
+     * Picked rows are rows someone is about to act on, and a refresh can move
+     * them to another page or out of the result: the clock waits.
+     */
+    protected holds(): boolean;
+    private shrunkTo;
+    private retainSelection;
+    private resultKeys;
+}
+/** The runtime a data view of this config's kind runs on. */
+export declare function dataViewRuntime(options: ViewRuntimeOptions<DataViewConfig>): DataViewRuntime;
+/**
+ * Whether a data view's runtime is a Record view's, with its rows' commands:
+ * a dashboard panel's runtime (`DashboardPanelState.runtime`) is either kind.
+ */
+export declare function isRecordRuntime(runtime: ViewRuntime<DataViewConfig>): runtime is RecordViewRuntime;
+//# sourceMappingURL=recordRuntime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recordRuntime.d.ts","sourceRoot":"","sources":["../../src/runtime/recordRuntime.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EACV,cAAc,EACd,UAAU,EACV,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,YAAY,EAClB,MAAM,iBAAiB,CAAC;AAKzB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EACV,iBAAiB,EACjB,WAAW,EACX,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;GAOG;AACH,qBAAa,qBACX,SAAQ,eAAe,CAAC,gBAAgB,CACxC,YAAW,iBAAiB;IAE5B,wCAAwC;IACxC,OAAO,CAAC,MAAM,CAA+B;IAC7C;;;;OAIG;IACH,OAAO,CAAC,SAAS,CAAS;IAC1B,yEAAyE;IACzE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA2B;gBAE5C,OAAO,EAAE,kBAAkB,CAAC,gBAAgB,CAAC;IAKzD,IAAI,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAOpC,MAAM,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,IAAI;IAS/B;;;;;;;OAOG;IACH,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,YAAY,CAAC;IAelE,WAAW,CACT,GAAG,EAAE,SAAS,EACd,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAgB7B;;;;;;;;;;;;;;;OAeG;cACgB,OAAO,CAAC,KAAK,EAAE,gBAAgB,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI;IA2BxE,oEAAoE;cACjD,SAAS,IAAI,OAAO,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;cAKxD,OAAO,IAAI,gBAAgB,GAAG,SAAS;IAI1D;;;;;OAKG;cACgB,QAAQ,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO;IAS5D;;;;OAIG;cACgB,MAAM,CACvB,IAAI,EAAE,aAAa,EACnB,aAAa,EAAE,OAAO,GACrB,OAAO,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,CAAC,GAAG,IAAI;IAYrD;;;OAGG;cACgB,KAAK,IAAI,OAAO;IAInC,OAAO,CAAC,QAAQ;IAUhB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,UAAU;CAKnB;AAiBD,6DAA6D;AAC7D,wBAAgB,eAAe,CAC7B,OAAO,EAAE,kBAAkB,CAAC,cAAc,CAAC,GAC1C,eAAe,CAIjB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,CAAC,cAAc,CAAC,GACnC,OAAO,IAAI,iBAAiB,CAE9B"}

package/dist/runtime/refreshTimer.d.ts

@@ -0,0 +1,72 @@
+import { ViewConfig } from '../model/index.js';
+import { RuntimeEnvironment } from './environment.js';
+/**
+ * The one auto-refresh timer a runtime holds, however many components watch
+ * it.
+ *
+ * A data view and a dashboard arm it for the same reasons and hold it for
+ * the same four — an invalid draft, an editor with focus, a hidden page, a
+ * request in flight (any panel's, on a dashboard) — so the arming is one
+ * piece of code rather than two copies that drift. The runtime decides the
+ * delay (`refreshDelayOf`) and publishes the due time it gets back; the
+ * timer only keeps the handle and fires.
+ *
+ * `sync` is idempotent for an unchanged delay: a state change that leaves
+ * the interval alone keeps the timer and its due time, which is what lets a
+ * countdown on screen keep counting to the same moment through every
+ * selection, sort and scroll.
+ */
+export declare class RefreshTimer {
+    private readonly environment;
+    private readonly fire;
+    private handle;
+    private delay;
+    private due;
+    constructor(environment: RuntimeEnvironment, fire: () => void);
+    /**
+     * Arms the timer for `delay`, keeps one already armed for the same delay,
+     * stops it for `null`; answers the due time the runtime should publish —
+     * read from the clock the timer runs on, so the countdown and the refresh
+     * answer to one number.
+     */
+    sync(delay: number | null): number | null;
+    stop(): void;
+}
+/**
+ * A one-shot timer for a moment rather than a cadence: the end of the
+ * period a metric card's headline skipped (`periodRollover`). `syncAt` keeps
+ * the timer armed for an unchanged moment, however often the state around
+ * it changes, and re-arms only when the moment moves; `null` stops it. A
+ * moment already past fires at once — a page shown again after midnight
+ * asks straight away.
+ */
+export declare class MomentTimer {
+    private readonly environment;
+    private readonly fire;
+    private handle;
+    private due;
+    /**
+     * The moment it last fired for. The same moment handed back — the refresh
+     * it fired failed, and the answer on screen is still the old one — is not
+     * fired for again: that would ask again at once, and again, for as long
+     * as the source keeps failing. A new answer brings a new moment.
+     */
+    private spent;
+    constructor(environment: RuntimeEnvironment, fire: () => void);
+    syncAt(due: number | null): void;
+    stop(): void;
+}
+/**
+ * The interval a config asks for, read as the untrusted thing it is. A
+ * stored config with no `refresh` is admission's to report, and it is
+ * reported; every state change still passes through here on the way to the
+ * timer, and must not throw before the user can fix it.
+ */
+export declare function refreshIntervalOf(config: Pick<ViewConfig, 'refresh'>): number | null;
+/**
+ * The delay to arm for, or `null` while the timer is held. `held` is the
+ * runtime's own reading of its four reasons; the clamp keeps a long
+ * interval inside what a host's `setTimeout` can count.
+ */
+export declare function refreshDelayOf(interval: number | null, held: boolean): number | null;
+//# sourceMappingURL=refreshTimer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"refreshTimer.d.ts","sourceRoot":"","sources":["../../src/runtime/refreshTimer.ts"],"names":[],"mappings":"AAaA,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,YAAY;IAMrB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,IAAI;IANvB,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,GAAG,CAAuB;gBAGf,WAAW,EAAE,kBAAkB,EAC/B,IAAI,EAAE,MAAM,IAAI;IAGnC;;;;;OAKG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI;IAiBzC,IAAI,IAAI,IAAI;CAOb;AAED;;;;;;;GAOG;AACH,qBAAa,WAAW;IAYpB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,IAAI;IAZvB,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,GAAG,CAAuB;IAClC;;;;;OAKG;IACH,OAAO,CAAC,KAAK,CAAuB;gBAGjB,WAAW,EAAE,kBAAkB,EAC/B,IAAI,EAAE,MAAM,IAAI;IAGnC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAyBhC,IAAI,IAAI,IAAI;CAMb;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,GAClC,MAAM,GAAG,IAAI,CAMf;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,IAAI,EAAE,OAAO,GACZ,MAAM,GAAG,IAAI,CAGf"}

package/dist/runtime/requestId.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A fresh request id: a random (version 4) UUID.
+ *
+ * `crypto.randomUUID` exists only in a secure context (HTTPS or localhost);
+ * a host served over plain HTTP — an intranet console, a dev cluster — has
+ * `crypto.getRandomValues` but no `randomUUID`, and every write would fail
+ * before it was sent. So the id is made from random bytes when
+ * `randomUUID` is missing, in the same shape.
+ */
+export declare function newRequestId(): string;
+//# sourceMappingURL=requestId.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"requestId.d.ts","sourceRoot":"","sources":["../../src/runtime/requestId.ts"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAerC"}

package/dist/runtime/requestRunner.d.ts

@@ -0,0 +1,58 @@
+import { RuntimeLimits } from '../model/index.js';
+export type RequestTask<T> = (controller: AbortController) => Promise<T>;
+/** A newer request took this key; the caller drops the result silently. */
+export declare class RequestSupersededError extends Error {
+    readonly key: string;
+    constructor(key: string);
+}
+/** The queue is full; the caller reports it rather than waiting longer. */
+export declare class RequestQueueFullError extends Error {
+    readonly key: string;
+    constructor(key: string, limit: number);
+}
+export declare function isRequestSuperseded(error: unknown): error is RequestSupersededError;
+/**
+ * The one scheduler every data query passes through.
+ *
+ * Two rules, both from `RuntimeLimits`. A key holds at most one request, so a
+ * new page or a new filter aborts the one it replaces instead of racing it;
+ * and the whole engine runs a bounded number at once, with a bounded queue
+ * behind it, so a dashboard of twenty panels opens without twenty parallel
+ * requests.
+ */
+export declare class RequestRunner {
+    private readonly maxConcurrent;
+    private readonly maxQueued;
+    private readonly byKey;
+    private readonly queue;
+    private running;
+    /** Room held beyond `maxQueuedQueries` for the boards open; see `reserve`. */
+    private reserved;
+    constructor(limits?: RuntimeLimits);
+    /** Requests started and not yet settled. */
+    get active(): number;
+    /** Requests admitted and waiting for a slot. */
+    get queued(): number;
+    /** How many requests may wait: the host's budget, and the room held. */
+    get capacity(): number;
+    /**
+     * Holds room in the queue for `slots` more requests until the returned
+     * release is called, once (host-integration.md 4): a board opening asks
+     * for its panels' queries all at once, and they wait their turn rather
+     * than being refused because the board is larger than the host's budget.
+     */
+    reserve(slots: number): () => void;
+    /**
+     * Runs `task` under `key`, superseding whatever that key was doing. The
+     * returned promise rejects with `RequestSupersededError` in that case, and
+     * with `RequestQueueFullError` when the queue has no room left.
+     */
+    run<T>(key: string, task: RequestTask<T>): Promise<T>;
+    /** Aborts the request under `key`, if any. Safe to call when there is none. */
+    cancel(key: string): void;
+    /** Aborts everything; the engine calls it when it is disposed. */
+    cancelAll(): void;
+    private pump;
+    private settle;
+}
+//# sourceMappingURL=requestRunner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"requestRunner.d.ts","sourceRoot":"","sources":["../../src/runtime/requestRunner.ts"],"names":[],"mappings":"AAaA,OAAO,EAA0B,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAE/E,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,UAAU,EAAE,eAAe,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;AAEzE,2EAA2E;AAC3E,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;gBAET,GAAG,EAAE,MAAM;CAKxB;AAED,2EAA2E;AAC3E,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;gBAET,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAKvC;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,sBAAsB,CAEjC;AAWD;;;;;;;;GAQG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA4B;IAClD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,OAAO,CAAK;IACpB,8EAA8E;IAC9E,OAAO,CAAC,QAAQ,CAAK;gBAET,MAAM,GAAE,aAAsC;IAK1D,4CAA4C;IAC5C,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,gDAAgD;IAChD,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,wEAAwE;IACxE,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;;;;OAKG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,IAAI;IAWlC;;;;OAIG;IACH,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IA4BrD,+EAA+E;IAC/E,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAYzB,kEAAkE;IAClE,SAAS,IAAI,IAAI;IAIjB,OAAO,CAAC,IAAI;IAmBZ,OAAO,CAAC,MAAM;CAOf"}