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

package/dist/react/actionRunner.d.ts

@@ -0,0 +1,161 @@
+import { RecordKey } from '../model/index.js';
+/**
+ * One command over records, as the surface's runner takes it — a declared
+ * action's, or a host's own from a slot (`run` on a slot's context): what it
+ * is called, and what it does to one record. `each` resolves when the record
+ * took the command and throws when it did not; what it throws is read for
+ * the source's own reason (`sourceReason`), so a host passes the error on
+ * rather than wording it — and an action's own refusal keeps its reason as
+ * written, a key said where it is shown.
+ */
+export interface BulkRun {
+    /**
+     * Said before the counts: a host with several commands names which ran.
+     * A key or words, said where it is shown.
+     */
+    title: string;
+    /** Words said into `title`'s `{name}`s, each itself said first. */
+    values?: Readonly<Record<string, string>>;
+    each(key: RecordKey): Promise<unknown>;
+    /**
+     * What the host's `onError` is told the command was
+     * (`context.operation`): a declared action's id; `title` by default.
+     */
+    operation?: string;
+    /**
+     * How long one record is waited for, in milliseconds; past it the
+     * record's outcome is unknown and the run moves on. No deadline by
+     * default.
+     */
+    timeout?: number;
+}
+/**
+ * One record the command did not take, and the reason why: the source's
+ * words, or the action's own refusal as written (a key stays a key).
+ */
+export interface BulkFailure {
+    key: RecordKey;
+    reason: string;
+}
+/** How far a command has come over the records it was handed. */
+export interface BulkProgress {
+    total: number;
+    /** Settled either way. */
+    done: number;
+    failed: number;
+}
+/** What one command came to, once every record it started has settled. */
+export interface BulkOutcome {
+    title: string;
+    values?: Readonly<Record<string, string>>;
+    succeeded: readonly RecordKey[];
+    /** Sent, and refused by the source: the source's reason for each. */
+    failed: readonly BulkFailure[];
+    /**
+     * Not sent: the action refused the record when its turn came
+     * (`ActionRefusedError`), with the action's reason as written.
+     */
+    refused: readonly BulkFailure[];
+    /**
+     * Sent, and nobody knows whether it took: the request timed out, the
+     * network went, the action's `timeout` passed, or the reader stopped
+     * waiting. Let go of rather than left selected — sent again blind, a
+     * refund could be paid twice — to be checked against the refreshed rows.
+     */
+    unknown: readonly BulkFailure[];
+    /** Never started, because the command was stopped. */
+    skipped: readonly RecordKey[];
+    /**
+     * What the run left selected — the failed, the refused and the never
+     * started, in the order picked; none for a record's own command.
+     */
+    kept: readonly RecordKey[];
+}
+/**
+ * The records a command runs over, and what a command does to them
+ * afterwards: the ones still to be dealt with stay selected (`select`), the
+ * rest are let go, and the view is read again.
+ */
+export interface BulkSelection {
+    keys: readonly RecordKey[];
+    /** Absent for a record's own command, which leaves the selection be. */
+    select?(keys: readonly RecordKey[]): void;
+    refresh(): void;
+}
+/** The command in flight on a surface. */
+export interface BulkRunning {
+    title: string;
+    values?: Readonly<Record<string, string>>;
+    progress: BulkProgress;
+    /**
+     * Stop was pressed: nothing more starts, and a second press stops waiting
+     * for what is under way.
+     */
+    stopping: boolean;
+}
+/** A surface's one runner: its command in flight, and what the last came to. */
+export interface ActionRunner {
+    run(selection: BulkSelection, command: BulkRun): void;
+    /**
+     * Starts nothing more; what is already in flight settles. Pressed again
+     * while stopping, it stops waiting: what is still in flight is reported
+     * with an unknown outcome and the run settles at once, so a `run` that
+     * never answers cannot hold the surface.
+     */
+    stop(): void;
+    /** The command in flight, or `null`. */
+    running: BulkRunning | null;
+    outcome: BulkOutcome | null;
+    dismiss(): void;
+}
+/** Where a failure the runner reports happened. */
+export interface ActionFailureContext {
+    /** The record the command failed, or went unanswered, for. */
+    key: RecordKey;
+    /** `BulkRun.operation`, else its title. */
+    operation: string;
+}
+export interface ActionRunnerOptions {
+    /**
+     * How many records are in flight at once. A command writes, and a
+     * selection of a hundred sent in one burst is a hundred writes landing on
+     * one service at once; a handful at a time is quick and polite.
+     */
+    concurrency?: number;
+    /**
+     * Told of what a record's command threw — a failure, or a timeout or a
+     * lost connection whose outcome is unknown — as it was thrown. Not of an
+     * action's own refusal (`ActionRefusedError`) nor of an abort: neither is a
+     * failure.
+     */
+    onError?(error: unknown, context: ActionFailureContext): void;
+}
+/**
+ * Everything of a bulk command that is not the command itself: records a
+ * handful at a time, progress while it runs, a stop that starts nothing
+ * more (and, pressed again, stops waiting), each record's deadline, the
+ * source's reason for every record that refused, and afterwards a refresh
+ * of the page the reader is on with the failed and the unsent rows left
+ * selected — they are the rows still to be dealt with. A record whose
+ * outcome is unknown is let go: it is checked, not sent again.
+ *
+ * One command at a time: commands write, so a second press over the same
+ * rows is not a newer read that can supersede the first but a second write.
+ *
+ * It is the engine's, one per record surface (a workbench's record view, a
+ * board's record panel): the declared actions run through it
+ * (`useRecordActions`), and so does a host's own command from a slot
+ * (`run` on the slot's context), so every command on a surface reports on
+ * its one line.
+ */
+export declare function useActionRunner(options?: ActionRunnerOptions): ActionRunner;
+/**
+ * The reasons a command's failures give, most common first — the strip says
+ * a few of them rather than one reason for all, since records refuse for
+ * different reasons and the most common is the one to fix first.
+ */
+export declare function failureReasons(failed: readonly BulkFailure[]): {
+    reason: string;
+    count: number;
+}[];
+//# sourceMappingURL=actionRunner.d.ts.map

package/dist/react/actionRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionRunner.d.ts","sourceRoot":"","sources":["../../src/react/actionRunner.ts"],"names":[],"mappings":"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"}

package/dist/react/actions.d.ts

@@ -0,0 +1,112 @@
+import { ReactNode } from 'react';
+import { RecordKey } from '../model/index.js';
+import { RecordRow } from '../record/index.js';
+import { RecordViewRuntime } from '../runtime/index.js';
+import { BulkRun } from './actionRunner.js';
+/**
+ * Where a host hangs markup of its own on a record surface — the escape
+ * hatch beside the declared actions (`actions()`, host-integration.md 5),
+ * drawn after them: a link out, a control the declarations cannot say.
+ * A command belongs in a declaration, where the engine places it, asks
+ * first, runs it over a selection and reports it; a slot that sends one
+ * anyway runs it through the surface's own runner (`run`), so it reports
+ * on the same line.
+ *
+ * Nothing here is persisted: a saved view is a way of looking at records,
+ * and what may be done to them belongs to the application that mounted the
+ * workbench, not to the view the user saved.
+ *
+ * Every context carries `refresh`, because an action that changes records
+ * has to be able to show the change.
+ */
+export interface RecordActionSlots {
+    /** Beside the view's own actions in the header; acts on no row. */
+    global?(context: RecordGlobalActionContext): ReactNode;
+    /** In the toolbar while rows are selected; acts on all of them. */
+    bulk?(context: RecordBulkActionContext): ReactNode;
+    /** In each row, or on each card; acts on that one. */
+    row?(context: RecordRowActionContext): ReactNode;
+}
+export interface RecordGlobalActionContext {
+    runtime: RecordViewRuntime;
+    refresh(): void;
+}
+export interface RecordBulkActionContext {
+    /** The selected rows in result order, so a confirmation can name them. */
+    rows: RecordRow[];
+    keys: RecordKey[];
+    runtime: RecordViewRuntime;
+    /** Selection survives a refresh, so an action that consumed it says so. */
+    clearSelection(): void;
+    /** Picks exactly these rows — what a command leaves for the reader. */
+    select(keys: readonly RecordKey[]): void;
+    refresh(): void;
+    /**
+     * Runs a command over the selection on the surface's runner: a few at a
+     * time, its progress and outcome on the surface's line, the ones it
+     * failed on left selected, the view read again after.
+     */
+    run(command: BulkRun): void;
+    /** A command is running on this surface: nothing else starts until it settles. */
+    busy: boolean;
+}
+export interface RecordRowActionContext {
+    row: RecordRow;
+    runtime: RecordViewRuntime;
+    refresh(): void;
+    /** Runs a command on this record on the surface's runner. */
+    run(command: BulkRun): void;
+    /** A command is running on this surface. */
+    busy: boolean;
+}
+/**
+ * A section the host adds to a record's detail, beside the ones the engine
+ * lays out from the definition's field groups (`detailSections`) — what the
+ * definition cannot say because it is the application's: a form that acts
+ * on the record, a stack trace read the host's way, the record's history as
+ * an embedded view (G2).
+ *
+ * `render` is called only while the section is on screen — the detail open
+ * on a record the engine has in hand — so a section that reads something
+ * of its own (an `EmbeddedView`) reads it when the reader opens the record,
+ * not before. Each section is drawn inside a boundary of its own: one that
+ * throws takes itself and not the detail.
+ */
+export interface RecordDetailSection {
+    /** Unique among the host's sections; React's key and `data-section`. */
+    id: string;
+    /** The section's heading, which also names it for a screen reader. */
+    title: string;
+    /**
+     * Where the section stands among the engine's: `'end'` (the default)
+     * after every one of them, `'start'` before the first, `{ after }` right
+     * after the field group of that id — at the end when the definition has
+     * no such group. Host sections at the same place keep the order given.
+     */
+    placement?: RecordDetailPlacement;
+    /**
+     * The definition's fields this section shows in its own way — a stack
+     * trace the host reads with line numbers and a copy button, say. The
+     * engine's groups leave them out, so the record does not read them twice,
+     * and a group left with none is not drawn; `{ after }` that group still
+     * places a section where the group stood.
+     */
+    fields?: readonly string[];
+    render(): ReactNode;
+}
+export type RecordDetailPlacement = 'start' | 'end' | {
+    after: string;
+};
+export interface RecordDetailSectionContext {
+    /**
+     * The record open in the detail: the page's row until the whole record
+     * has come (`complete`), the whole record from then on.
+     */
+    row: RecordRow;
+    /** Whether `row.data` is the whole record rather than the page's row. */
+    complete: boolean;
+    runtime: RecordViewRuntime;
+    /** Runs the view again; the detail reads the record again when it lands. */
+    refresh(): void;
+}
+//# sourceMappingURL=actions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/react/actions.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,iBAAiB;IAChC,mEAAmE;IACnE,MAAM,CAAC,CAAC,OAAO,EAAE,yBAAyB,GAAG,SAAS,CAAC;IACvD,mEAAmE;IACnE,IAAI,CAAC,CAAC,OAAO,EAAE,uBAAuB,GAAG,SAAS,CAAC;IACnD,sDAAsD;IACtD,GAAG,CAAC,CAAC,OAAO,EAAE,sBAAsB,GAAG,SAAS,CAAC;CAClD;AAED,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC,0EAA0E;IAC1E,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,2EAA2E;IAC3E,cAAc,IAAI,IAAI,CAAC;IACvB,uEAAuE;IACvE,MAAM,CAAC,IAAI,EAAE,SAAS,SAAS,EAAE,GAAG,IAAI,CAAC;IACzC,OAAO,IAAI,IAAI,CAAC;IAChB;;;;OAIG;IACH,GAAG,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5B,kFAAkF;IAClF,IAAI,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,sBAAsB;IACrC,GAAG,EAAE,SAAS,CAAC;IACf,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,IAAI,IAAI,CAAC;IAChB,6DAA6D;IAC7D,GAAG,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5B,4CAA4C;IAC5C,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,mBAAmB;IAClC,wEAAwE;IACxE,EAAE,EAAE,MAAM,CAAC;IACX,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,SAAS,CAAC,EAAE,qBAAqB,CAAC;IAClC;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,MAAM,IAAI,SAAS,CAAC;CACrB;AAED,MAAM,MAAM,qBAAqB,GAAG,OAAO,GAAG,KAAK,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAExE,MAAM,WAAW,0BAA0B;IACzC;;;OAGG;IACH,GAAG,EAAE,SAAS,CAAC;IACf,yEAAyE;IACzE,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,4EAA4E;IAC5E,OAAO,IAAI,IAAI,CAAC;CACjB"}

package/dist/react/analysisEditing.d.ts

@@ -0,0 +1,122 @@
+import { AnalysisScope, Dropped, MetricMove } from '../analysis/index.js';
+import { AnalysisColumn, AnalysisDateDiffUnit, AnalysisGroup, AnalysisHavingExpression, AnalysisMetric, AnalysisViewConfig, FilterTree } from '../model/index.js';
+/**
+ * What a change to the question proposes: the groups and metrics, the chain
+ * where it moves, and what the change itself took out beyond what it was
+ * asked to (`withElements`' `dropped`), for the editor to say.
+ */
+export type ReshapeProposal = Pick<AnalysisViewConfig, 'groups' | 'metrics'> & Partial<Pick<AnalysisViewConfig, 'elements'>> & {
+    dropped?: Dropped;
+    /** The table's declared columns, where the change moves one. */
+    columns?: AnalysisColumn[];
+};
+/** The edit a drop is said after: a step of the chain, or any other. */
+export type DropCause = {
+    kind: 'expand';
+    name: string;
+} | {
+    kind: 'collapse';
+    name: string;
+};
+/** A change to what is grouped or measured; see `useAnalysisEditor`'s reshape. */
+export type Reshape = (update: (current: AnalysisViewConfig) => ReshapeProposal | undefined, cause?: DropCause) => void;
+export interface QuestionEditingInput {
+    reshape: Reshape;
+    /** A plain edit of the draft, for members nothing else names. */
+    edit(patch: Partial<AnalysisViewConfig>): void;
+    scope: AnalysisScope | null;
+}
+/**
+ * The edits to the question — the dimensions, the metrics, what keeps a
+ * group — as plain functions over the draft. They are built once per scope
+ * and change the draft through `reshape`, which brings the chart, the sort
+ * and the table columns along with whatever alias moved. Kept out of the
+ * hook so the hook stays the wiring and this stays the rules.
+ */
+export declare function questionEditing({ reshape, edit, scope, }: QuestionEditingInput): {
+    addGroup: (group: AnalysisGroup) => void;
+    updateGroup: (index: number, patch: Partial<AnalysisGroup>) => void;
+    removeGroup: (index: number) => void;
+    renameGroup: (index: number, label: string | undefined) => void;
+    setMissingBucket: (index: number, on: boolean) => void;
+    setDense: (index: number, on: boolean) => void;
+    addMetric: (metric: AnalysisMetric) => void;
+    updateMetric: (index: number, patch: Partial<AnalysisMetric>) => void;
+    /**
+     * Puts a whole metric in a row's place. A change of summary is a change
+     * of type — a sum becomes a distinct count — and a patch over the old
+     * shape would leave its `function` or `expression` behind for admission
+     * to trip over; the card builds the new metric and swaps it in.
+     */
+    replaceMetric: (index: number, metric: AnalysisMetric) => void;
+    renameMetric: (index: number, label: string | undefined) => void;
+    /**
+     * The conditions a metric counts under, or none. An empty tree is kept
+     * while the card is being filled in — validation says it is unfinished
+     * and the query waits — and `undefined` takes the condition away.
+     */
+    setMetricFilter: (index: number, filter: FilterTree | undefined) => void;
+    /**
+     * A second card of the same metric, right after it, with an empty
+     * condition to fill in: 复制「金额的总和」并加条件. The copy keeps no
+     * display name — two cards called the same thing is the ambiguity the
+     * name exists to resolve, and the condition it is about to carry is what
+     * resolves it. Answers the copy's alias — the card's identity — so the
+     * slot can open the copy's conditions on the spot: the menu item
+     * promised a condition, and a second identical card with nothing open is
+     * not one. `reshape` runs synchronously against the live draft, so the
+     * alias is in hand. `undefined` where there was nothing to copy.
+     */
+    duplicateMetric: (index: number) => string | undefined;
+    /**
+     * The five numbers a boxplot draws of this metric's field (「补齐箱线图
+     * 的五个数」): the ones among its lowest, 25th, 50th and 75th
+     * percentiles and highest it is not, added right after it under its own
+     * condition (`fiveNumberMetrics`). Nothing for a metric of no field.
+     */
+    addFiveNumbers: (index: number) => void;
+    /**
+     * The four numbers a candlestick draws of this metric's field (「补齐 K
+     * 线的四个数」): the ones among its opening value, highest, lowest and
+     * closing value it is not, added right after it under its own condition
+     * and ordered by its own time (`ohlcMetrics`). Nothing for a metric that
+     * is none of the four of a field.
+     */
+    addOhlc: (index: number) => void;
+    /**
+     * The metric at `from` put at `to`, as far as the order allows (D71): a
+     * derived metric stays after what it reads, and a metric before what
+     * reads it (`moveMetric`). Answers where it landed and, when it landed
+     * short, which metric stopped it.
+     */
+    moveMetric: (from: number, to: number) => MetricMove | undefined;
+    removeMetric: (index: number) => void;
+    /**
+     * A formula over the first two fields the unit can measure, or over
+     * one field twice when it has only one: the card is there to be
+     * changed, and a card with a slot it cannot fill is not offered.
+     */
+    addFormula: () => void;
+    /**
+     * A time between two moments (N3, 「两个时刻之差」): the average `unit`s
+     * from the first time the counting unit holds to the second — two
+     * fields it buckets by date and takes into arithmetic. Nothing when it
+     * holds fewer than two: a moment to itself is always nothing.
+     */
+    addDuration: (unit: AnalysisDateDiffUnit) => void;
+    /**
+     * The duration a metric measures, cut into bands one `unit` wide as a
+     * dimension of its own (「付款到发货 0–1 小时、1–2 小时…」, N3): a band of
+     * a computed number, placed after the dimensions there are.
+     */
+    groupByDuration: (index: number) => void;
+    /**
+     * A derived metric over the first two metrics before it that a derived
+     * one may read — any but a sample value or a moment
+     * (`analysis.derived.moment-operand`) — or over one metric twice.
+     */
+    addDerived: () => void;
+    setHaving: (having: AnalysisHavingExpression | undefined) => void;
+};
+export type QuestionEditing = ReturnType<typeof questionEditing>;
+//# sourceMappingURL=analysisEditing.d.ts.map

package/dist/react/analysisEditing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysisEditing.d.ts","sourceRoot":"","sources":["../../src/react/analysisEditing.ts"],"names":[],"mappings":"AAeA,OAAO,EAWL,KAAK,aAAa,EAClB,KAAK,OAAO,EACZ,KAAK,UAAU,EAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,wBAAwB,EAC7B,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAC;AAE3B;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,kBAAkB,EAAE,QAAQ,GAAG,SAAS,CAAC,GAC1E,OAAO,CAAC,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC,GAAG;IAC9C,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gEAAgE;IAChE,OAAO,CAAC,EAAE,cAAc,EAAE,CAAC;CAC5B,CAAC;AAEJ,wEAAwE;AACxE,MAAM,MAAM,SAAS,GACnB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAExE,kFAAkF;AAClF,MAAM,MAAM,OAAO,GAAG,CACpB,MAAM,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,eAAe,GAAG,SAAS,EACpE,KAAK,CAAC,EAAE,SAAS,KACd,IAAI,CAAC;AAEV,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,iEAAiE;IACjE,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC;IAC/C,KAAK,EAAE,aAAa,GAAG,IAAI,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,EAC9B,OAAO,EACP,IAAI,EACJ,KAAK,GACN,EAAE,oBAAoB;sBA2BD,aAAa;yBAKV,MAAM,SAAS,OAAO,CAAC,aAAa,CAAC;yBAErC,MAAM;yBAQN,MAAM,SAAS,MAAM,GAAG,SAAS;8BAM5B,MAAM,MAAM,OAAO;sBAQ3B,MAAM,MAAM,OAAO;wBASjB,cAAc;0BAKZ,MAAM,SAAS,OAAO,CAAC,cAAc,CAAC;IAE5D;;;;;OAKG;2BACoB,MAAM,UAAU,cAAc;0BAE/B,MAAM,SAAS,MAAM,GAAG,SAAS;IAMvD;;;;OAIG;6BACsB,MAAM,UAAU,UAAU,GAAG,SAAS;IAQ/D;;;;;;;;;;OAUG;6BACsB,MAAM,KAAG,MAAM,GAAG,SAAS;IAkBpD;;;;;OAKG;4BACqB,MAAM;IAY9B;;;;;;OAMG;qBACc,MAAM;IAYvB;;;;;OAKG;uBACgB,MAAM,MAAM,MAAM,KAAG,UAAU,GAAG,SAAS;0BAkBxC,MAAM;IAY5B;;;;OAIG;;IA0BH;;;;;OAKG;wBACiB,oBAAoB;IAWxC;;;;OAIG;6BACsB,MAAM;IAiB/B;;;;OAIG;;wBAoBiB,wBAAwB,GAAG,SAAS;EAG3D;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/react/analysisFields.d.ts

@@ -0,0 +1,38 @@
+import { AnalysisScope } from '../analysis/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+import { AnalysisDatePart, AnalysisDateUnit, AnalysisFunction, AnalysisGroupType } from '../model/index.js';
+/** One field and what the definition allows doing with it. */
+export interface AnalysisFieldOption {
+    field: string;
+    label: string;
+    /** Group types this field offers; empty when it cannot be grouped. */
+    groups: AnalysisGroupType[];
+    /** Aggregation functions it offers; empty when it cannot be measured. */
+    functions: AnalysisFunction[];
+    dateUnits: AnalysisDateUnit[];
+    /** The calendar parts a `DATE_PART` dimension on it may take (`datePartsOf`). */
+    dateParts: AnalysisDatePart[];
+    distinctCount: boolean;
+    percentile: boolean;
+    any: boolean;
+    /** Whether it offers an opening and a closing value (FIRST / LAST). */
+    firstLast: boolean;
+    /** Whether a dimension on it may keep records missing the value as a group of their own. */
+    missingKey: boolean;
+    /** Whether its values are the steps of one process (`steps`): a funnel's. */
+    steps?: boolean;
+    /**
+     * `false` where a formula may not take it as an operand
+     * (`expressionInput`); absent or `true` where it may.
+     */
+    expressionInput?: boolean;
+    /**
+     * How its values read (`cell ?? kind`): the earliest of a `datetime` is
+     * worded 「最早」 where a number's smallest is 「最小」, and a date is no
+     * operand of a formula. Absent when not known.
+     */
+    cell?: string;
+}
+/** What the definition allows doing with each field of a scope. */
+export declare function fieldOptions(scope: AnalysisScope, kinds: FieldKindRegistry | undefined): AnalysisFieldOption[];
+//# sourceMappingURL=analysisFields.d.ts.map

package/dist/react/analysisFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysisFields.d.ts","sourceRoot":"","sources":["../../src/react/analysisFields.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EAEvB,MAAM,mBAAmB,CAAC;AAE3B,8DAA8D;AAC9D,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,sEAAsE;IACtE,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B,yEAAyE;IACzE,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,iFAAiF;IACjF,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,aAAa,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,GAAG,EAAE,OAAO,CAAC;IACb,uEAAuE;IACvE,SAAS,EAAE,OAAO,CAAC;IACnB,4FAA4F;IAC5F,UAAU,EAAE,OAAO,CAAC;IACpB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,mEAAmE;AACnE,wBAAgB,YAAY,CAC1B,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,iBAAiB,GAAG,SAAS,GACnC,mBAAmB,EAAE,CAsBvB"}

package/dist/react/environment.d.ts

@@ -0,0 +1,10 @@
+import { RuntimeEnvironment, VisibilitySource } from '../runtime/index.js';
+/**
+ * Page visibility as the browser reports it, so a hidden tab stops
+ * auto-refreshing. Falls back to "always visible" where there is no document,
+ * which is what server rendering and a plain Node test are.
+ */
+export declare function documentVisibility(): VisibilitySource;
+/** The host a browser provides: ambient clock and timers, real visibility. */
+export declare function browserRuntimeEnvironment(overrides?: Partial<RuntimeEnvironment>): RuntimeEnvironment;
+//# sourceMappingURL=environment.d.ts.map

package/dist/react/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../src/react/environment.ts"],"names":[],"mappings":"AAaA,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACtB,MAAM,qBAAqB,CAAC;AAE7B;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,gBAAgB,CAWrD;AAED,8EAA8E;AAC9E,wBAAgB,yBAAyB,CACvC,SAAS,GAAE,OAAO,CAAC,kBAAkB,CAAM,GAC1C,kBAAkB,CAKpB"}

package/dist/react/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The `/react` entry: hooks and headless controllers over the runtime.
+ *
+ * Nothing here renders. A controller returns read-only state and action
+ * functions, never JSX, class names or vendor types, so the default UI and a
+ * hand-built one consume exactly the same contract.
+ */
+export type { RecordActionSlots, RecordBulkActionContext, RecordDetailPlacement, RecordDetailSection, RecordDetailSectionContext, RecordGlobalActionContext, RecordRowActionContext, } from './actions.js';
+export { browserRuntimeEnvironment, documentVisibility, } from './environment.js';
+export { kindMismatch } from './issues.js';
+export { toIssue } from '../runtime/issues.js';
+export { type AnalysisEditorController, useAnalysisEditor, } from './useAnalysisEditor.js';
+export type { AnalysisFieldOption } from './analysisFields.js';
+export type { DropCause, QuestionEditing, QuestionEditingInput, Reshape, ReshapeProposal, } from './analysisEditing.js';
+export type { DropNotice, MetricRemoval } from './useReshape.js';
+export { type AnalysisResultController, type FollowUp, type FollowUpAction, type FollowUpGroup, type SplitOption, useAnalysisResult, } from './useAnalysisResult.js';
+export { type RefreshController, useAutoRefresh, useRefreshCountdown, } from './useAutoRefresh.js';
+export { type ActionFailureContext, type ActionRunner, type BulkFailure, type BulkOutcome, type BulkProgress, type BulkRun, type BulkRunning, type BulkSelection, failureReasons, } from './actionRunner.js';
+export { type BulkActionView, type PendingAction, type RecordActionTable, type RecordActionsController, type RecordActionsOptions, type RowActionView, useRecordActions, } from './useRecordActions.js';
+export { type SearchBoxController, useSearchBox } from './useSearchBox.js';
+export { type UnavailableController, useUnavailable, } from './useUnavailable.js';
+export { type DashboardController, type DashboardPanelView, useDashboard, } from './useDashboard.js';
+export { type FollowUpHost, ownedNavigation, usePanelFollowUps, } from './usePanelFollowUps.js';
+export { type FilterEditorController, type FilterTreeController, useFilterEditor, } from './useFilterEditor.js';
+export { type RecordDetailControl, type RecordDetailController, useRecordDetail, } from './useRecordDetail.js';
+export { type RecordExportController, type RecordExportOptions, type RecordExportOutcome, type RecordExportProgress, type RecordExportScope, type RecordExportScopes, useRecordExport, } from './useRecordExport.js';
+export { type RecordTableController, type ToggleSelectionOptions, type ToggleSortOptions, useRecordTable, } from './useRecordTable.js';
+export { type SaveAbilities, type SaveCommandState, type SaveCommands, type SaveTargetInput, useSaveCommands, } from './useSaveCommands.js';
+export { VALUE_CANDIDATE_DEBOUNCE_MS, type ValueCandidatesController, useValueCandidates, } from './useValueCandidates.js';
+export { type DashboardOpening, type OpenViewState, type SnapshotOf, type ViewRuntimeStore, retryableOpen, useOpenView, useViewEngine, useViewRuntime, } from './useViewEngine.js';
+export { type ViewListOptions, type ViewListReloadOptions, type ViewListState, useViewList, } from './useViewList.js';
+export { type ViewManagerController, useViewManager, } from './useViewManager.js';
+export type { ManagedInstanceAbilities, ViewManagerAbilities, } from './manager/abilities.js';
+export { type DrillTarget, type HeldView, type ViewOrigin, type WorkbenchController, type WorkbenchOptions, useWorkbench, } from './useWorkbench.js';
+export type { RecoveredWrite, SettledWrite } from './writes.js';
+export { type InstanceSyncOptions, useInstanceSync, } from './workbench/instanceSync.js';
+export { type LeaveGuard, type LeaveGuardOptions, type LeaveGuardState, useLeaveGuard, } from './workbench/leaveGuard.js';
+export { useReleaseDeleted } from './workbench/releaseDeleted.js';
+export { useHandOver, useHandedConditions, useHandedRemoval, } from './workbench/handOver.js';
+export type { NewViewOptions } from './workbench/newView.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/react/index.ts"],"names":[],"mappings":"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"}

package/dist/react/issues.d.ts

@@ -0,0 +1,14 @@
+import { Issue, ViewKind } from '../model/index.js';
+export { toIssue } from '../runtime/issues.js';
+/**
+ * The reason a view that opened cannot be drawn here, or nothing.
+ *
+ * One data definition holds record and analysis instances together, so a host
+ * may name either of them to either workbench. The one that cannot render it
+ * says so where every other failure to open is already reported — a body it
+ * has no kernel for is an empty page, and an empty page explains nothing.
+ */
+export declare function kindMismatch(runtime: {
+    kind: ViewKind;
+} | null, drawn: readonly ViewKind[]): Issue | null;
+//# sourceMappingURL=issues.d.ts.map

package/dist/react/issues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issues.d.ts","sourceRoot":"","sources":["../../src/react/issues.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAIzD,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE/C;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,IAAI,EAClC,KAAK,EAAE,SAAS,QAAQ,EAAE,GACzB,KAAK,GAAG,IAAI,CAId"}

package/dist/react/manager/abilities.d.ts

@@ -0,0 +1,38 @@
+import { ViewInstanceSummary } from '../../model/index.js';
+import { ViewPermissions } from '../../store/ViewStore.js';
+/** What may be done to one row. `save` is not among them: nothing here edits a config. */
+export interface ManagedInstanceAbilities {
+    rename: boolean;
+    delete: boolean;
+    /**
+     * Whether the row may move to the other audience (设为共享／设为个人):
+     * the store has `changeAudience`, allows it for this view, and allows
+     * creating in the audience it would go to.
+     */
+    changeAudience: boolean;
+    /**
+     * Whether a copy of the row may be published as a system view
+     * (「发布为系统视图」, D81): a personal or shared row, and `editSystem`
+     * granted. The row itself is left as it is.
+     */
+    publish: boolean;
+}
+export interface ViewManagerAbilities {
+    reorder: boolean;
+    setDefault: boolean;
+    /**
+     * Whether this user may publish views as system views at all (D81,
+     * `editSystem`): a list-wide answer, so every row lays out the same cells.
+     */
+    publishSystem: boolean;
+    instance(id: string): ManagedInstanceAbilities;
+    /**
+     * Whether anything at all can be managed: the order, the default, or the
+     * title or existence of any row on the list. False means the manager would
+     * open on a dialog of read-only rows, so the way in is not offered — a
+     * button whose only lesson is that it leads nowhere.
+     */
+    anything: boolean;
+}
+export declare function abilitiesOf(items: readonly ViewInstanceSummary[], permissions: ViewPermissions): ViewManagerAbilities;
+//# sourceMappingURL=abilities.d.ts.map

package/dist/react/manager/abilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abilities.d.ts","sourceRoot":"","sources":["../../../src/react/manager/abilities.ts"],"names":[],"mappings":"AAaA;;;GAGG;AAEH,OAAO,EAAiB,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC/E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAGhE,0FAA0F;AAC1F,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,aAAa,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,wBAAwB,CAAC;IAC/C;;;;;OAKG;IACH,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,wBAAgB,WAAW,CACzB,KAAK,EAAE,SAAS,mBAAmB,EAAE,EACrC,WAAW,EAAE,eAAe,GAC3B,oBAAoB,CAuCtB"}

package/dist/react/manager/order.d.ts

@@ -0,0 +1,60 @@
+import { ViewAudience } from '../../model/index.js';
+/**
+ * The order a queued move computed, while the list it was computed from is
+ * still a reload behind it.
+ *
+ * `base` is the full rendered order it started from: once the list is no
+ * longer that, the reload has landed and the rendered order is the truth
+ * again. The two orders after the move are both kept, because they answer
+ * different questions — `order` is what was submitted, and `visible` is the
+ * list the next move reads its group and its indexes out of. Which inputs the
+ * move was raised under is the caller's to tag on; this module only does the
+ * arithmetic.
+ */
+export interface OptimisticOrder {
+    /** The full rendered order, unfiltered, before this move. */
+    base: readonly string[];
+    /** The full order this move submitted. */
+    order: readonly string[];
+    /** The narrowed order as this move left it. */
+    visible: readonly string[];
+}
+/**
+ * The two orders one move produces; see {@link OptimisticOrder}. Both are
+ * fresh arrays the caller owns — one of them is what it submits.
+ */
+export interface MovedOrder {
+    order: string[];
+    visible: string[];
+}
+export declare function sameOrder(one: readonly string[], other: readonly string[]): boolean;
+/**
+ * Where a row sits inside its own audience group, counted over the rows the
+ * user can see, or -1 when the list does not hold it.
+ *
+ * This is the index a move is expressed in, because it is the list a user is
+ * looking at: one group of rows under one heading, and a drop that lands on
+ * another row of it. A position in the flat rendered order would mean
+ * something different on either side of the boundary.
+ */
+export declare function groupIndexOf(visible: readonly string[], audiences: ReadonlyMap<string, ViewAudience>, id: string): number;
+/**
+ * What one move submits and what it leaves on screen, or null when there is
+ * nothing to move: a row the list no longer holds, a row of no known
+ * audience, or one already sitting where it is being sent.
+ *
+ * `index` is counted inside the row's own audience group, among the rows the
+ * user can see, and is clamped to that group — being carried past the last
+ * row of a group lands on the last row of it rather than in the group below.
+ *
+ * The move itself is made in the *full* order. Submitting the visible one
+ * would store a list with every other kind's id missing, and the store keeps
+ * one order for the whole definition: a record workbench reordering its own
+ * views would silently drop the analyses. The places the group holds in that
+ * order are rewritten with the group as this move leaves it, so every id that
+ * took no part — another kind's, the other audience's — stays exactly where
+ * it was. A row the submitted order does not hold cannot be placed in it, and
+ * storing an order without it would spend a revision to lose it.
+ */
+export declare function planMoveTo(visible: readonly string[], full: readonly string[], audiences: ReadonlyMap<string, ViewAudience>, id: string, index: number): MovedOrder | null;
+//# sourceMappingURL=order.d.ts.map