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

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

@@ -0,0 +1 @@
+{"version":3,"file":"order.d.ts","sourceRoot":"","sources":["../../../src/react/manager/order.ts"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,eAAe;IAC9B,6DAA6D;IAC7D,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,0CAA0C;IAC1C,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,+CAA+C;IAC/C,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,wBAAgB,SAAS,CACvB,GAAG,EAAE,SAAS,MAAM,EAAE,EACtB,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,OAAO,CAET;AA4BD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,EAC5C,EAAE,EAAE,MAAM,GACT,MAAM,CAIR;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,EAC5C,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,GACZ,UAAU,GAAG,IAAI,CA4BnB"}

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

@@ -0,0 +1,55 @@
+import { WriteState } from '../../runtime/index.js';
+import { SettledWrite } from '../writes.js';
+/**
+ * The key the order and the default view are recorded under.
+ *
+ * Both are one preference record, so both contend for one slot and share one
+ * outcome: there is no instance to hang them off, and a row cannot be asked
+ * to recover a write that was never about it.
+ *
+ * It shares the key space with instance ids, so it is taken from the one
+ * namespace a `ViewStore` may not issue into — the `system:` prefix
+ * `isSystemInstanceId` reserves — rather than from a bare word a store could
+ * hand out as an id and collide with.
+ */
+export declare const PREFERENCES_KEY: "system:preferences";
+/**
+ * One recorded outcome: what the command settled as, plus the intent a
+ * preference write keeps across a reload. The handle is the engine's, kept
+ * here rather than handed out — a caller acts on the row it can see, and
+ * `retry`, `abandon` and `resolveConflict` address the write for it.
+ */
+export interface Outcome extends SettledWrite {
+    /**
+     * The command as the user meant it, for a preference write whose conflict
+     * was answered with a reload. Running it again is a new write — it reads
+     * the revision the reload brought in — so the intent survives the reload
+     * without ever being replayed behind the user's back.
+     */
+    again?: () => Promise<unknown>;
+}
+export declare const NO_OUTCOMES: ReadonlyMap<string, Outcome>;
+/**
+ * Whether an outcome is a conflict the engine has already settled and whose
+ * intent is still the user's to put again: after a reload there is no handle
+ * to recover through, and the button offers the write once more rather than
+ * a recovery that would answer `false`.
+ *
+ * "No handle to recover through" is `holdsHandle` answering no over a
+ * conflict, asked rather than restated: which outcomes the engine is still
+ * answering for is `writes.ts`'s rule, and a second spelling of it here would
+ * be a second place to fix when it moves.
+ */
+export declare function kept(outcome: Outcome | undefined): boolean;
+/**
+ * The map with this key recorded or dropped, or null when it would not change
+ * — dropping a key nothing is held under is the one no-op, and answering it
+ * with a new map would re-render every row for nothing.
+ */
+export declare function withOutcome(outcomes: ReadonlyMap<string, Outcome>, key: string, outcome: Outcome | null): ReadonlyMap<string, Outcome> | null;
+/**
+ * The outcomes as a caller reads them: the state alone, because the handle is
+ * the engine's and the recovery actions address it on the row's behalf.
+ */
+export declare function projectStates(outcomes: ReadonlyMap<string, Outcome>): ReadonlyMap<string, WriteState>;
+//# sourceMappingURL=outcomes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"outcomes.d.ts","sourceRoot":"","sources":["../../../src/react/manager/outcomes.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAE9D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,sBACuD,CAAC;AAEpF;;;;;GAKG;AACH,MAAM,WAAW,OAAQ,SAAQ,YAAY;IAC3C;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;CAChC;AAED,eAAO,MAAM,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAa,CAAC;AAEnE;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CAO1D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,EACtC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,OAAO,GAAG,IAAI,GACtB,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAMrC;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GACrC,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAIjC"}

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

@@ -0,0 +1,56 @@
+/**
+ * One write at a time, in the order the clicks came — and only among the
+ * commands that answer for the same inputs.
+ *
+ * Two rows deleted in quick succession are two writes against one list and one
+ * `pending` slot: run together, the second one's completion clears the slot
+ * while the first is still going, and the first row stops showing progress it
+ * is still making. Chaining also keeps the reload each landing triggers from
+ * reading a list the other write is halfway through.
+ *
+ * The tag is what keeps that chaining honest, and it cuts both ways. A hook
+ * that swaps its inputs — a workbench moving to another definition, or to
+ * another view — while a write hangs must not queue the new inputs' first
+ * command behind it, or the row the user just clicked sits there showing
+ * nothing. And it must not lose the old chain either: the user can come back
+ * to those inputs while their write is still in flight, and a second write
+ * against the same target is one the engine refuses with
+ * `view.write.in-flight`, which the caller would report as the failure of the
+ * click that was only second. So the queue holds one chain per tag rather
+ * than one altogether, and each is dropped as it settles.
+ *
+ * There is no React in here: a queue is a plain mutable holder a hook keeps in
+ * a ref, so any command hook can take one.
+ */
+/** Whether two tags name the same inputs. */
+export type TagEquality<Tag> = (one: Tag, other: Tag) => boolean;
+export interface CommandQueue<Tag> {
+    /**
+     * The task at the back of each tag's chain, one entry per tag with something
+     * still in flight. An entry is dropped as its chain settles, so an idle
+     * queue is empty. Only ever read through {@link enqueue}.
+     */
+    backs: {
+        tag: Tag;
+        chain: Promise<unknown>;
+    }[];
+    readonly sameTag: TagEquality<Tag>;
+}
+/**
+ * An idle queue. `sameTag` decides which tasks chain: the default is identity,
+ * which is what a tag that is one object — a runtime, an engine — wants; a tag
+ * assembled per render passes its own comparison.
+ */
+export declare function createCommandQueue<Tag>(sameTag?: TagEquality<Tag>): CommandQueue<Tag>;
+/**
+ * Runs `task` after whatever this tag already has in flight, and answers what
+ * it answered.
+ *
+ * A task whose tag has nothing in flight starts now rather than a microtask
+ * later, so the row the user just clicked shows progress in that same event —
+ * and that is true of a tag nobody has used yet as much as of one whose last
+ * write is over. Another tag's chain is never waited on: it answers for inputs
+ * this task has nothing to do with.
+ */
+export declare function enqueue<Tag, T>(queue: CommandQueue<Tag>, tag: Tag, task: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=queue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../src/react/manager/queue.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,6CAA6C;AAC7C,MAAM,MAAM,WAAW,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC;AAEjE,MAAM,WAAW,YAAY,CAAC,GAAG;IAC/B;;;;OAIG;IACH,KAAK,EAAE;QAAE,GAAG,EAAE,GAAG,CAAC;QAAC,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,EAAE,CAAC;IAC/C,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;CACpC;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EACpC,OAAO,GAAE,WAAW,CAAC,GAAG,CAAa,GACpC,YAAY,CAAC,GAAG,CAAC,CAEnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,CAAC,EAC5B,KAAK,EAAE,YAAY,CAAC,GAAG,CAAC,EACxB,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACrB,OAAO,CAAC,CAAC,CAAC,CAiBZ"}

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

@@ -0,0 +1,74 @@
+import { ViewEngine, WritePayload } from '../../runtime/index.js';
+import { ViewListState } from '../useViewList.js';
+import { Outcome } from './outcomes.js';
+/**
+ * The inputs a command, an outcome and a queued order all answer for.
+ *
+ * The tag is the derivation `useViewList` makes — "which request does this
+ * answer belong to", asked of a command rather than of a load. A workbench
+ * swaps `definitionId` or `engine` while a write is in flight, and without
+ * the tag the rows of the definition just left keep their outcomes and their
+ * progress against a list that no longer holds them, and a completion from
+ * the old inputs repopulates the new one.
+ */
+export interface ManagerTag {
+    /** Null only before the first command; nothing is tagged with it. */
+    engine: ViewEngine | null;
+    definitionId: string;
+}
+export declare function sameTag(one: ManagerTag, other: ManagerTag): boolean;
+/**
+ * What a command tells the runner about itself, beyond what it writes.
+ *
+ * Both halves arrived with a different question — one keeps an intent alive
+ * across a reload, the other decides whether an unsettled key accepts this
+ * command at all — and they are independent: `resubmit` carries an intent and
+ * is still an ordinary write, so the `unknown` guard applies to it.
+ */
+export interface RunOptions {
+    /**
+     * Kept with the outcome so the same intent can be put again later. Only
+     * the preference commands pass one: everything else recovers through its
+     * handle, which addresses the write the store already has.
+     */
+    again?: () => Promise<unknown>;
+    /** A replay or a conflict choice, which is the one thing an unsettled outcome accepts. */
+    recovery?: boolean;
+    /**
+     * Asked once more at the front of the queue, for a command that addresses
+     * a handle it read when it was queued. The command ahead may have settled
+     * that outcome — retried it, abandoned it, answered its conflict — and the
+     * engine would refuse the second address with an error the row would show
+     * as a failure of the click the user just made. False means "nothing to do
+     * any more": the command is skipped and resolves `false`.
+     */
+    guard?: () => boolean;
+}
+export interface CommandRunner {
+    /**
+     * Runs one command, resolving whether it landed rather than rejecting: what
+     * happened is recorded under `key`, so a click handler needs no try/catch.
+     */
+    run(key: string, intent: WritePayload, code: string, command: () => Promise<unknown>, options?: RunOptions): Promise<boolean>;
+    /** Unresolved outcomes raised under these inputs, by key. */
+    outcomes: ReadonlyMap<string, Outcome>;
+    /** The key of the write in flight, or null. */
+    pending: string | null;
+    /**
+     * The outcome a command would be landing on, or null when the state on
+     * hand was raised under other inputs and says nothing about this key. It is
+     * read between renders, so a queued command sees what the one ahead of it
+     * recorded.
+     */
+    held(key: string): Outcome | null;
+    /** Records an outcome under a key, or drops the one it holds. */
+    record(key: string, outcome: Outcome | null): void;
+    /** Whether something raised elsewhere was raised under these same inputs. */
+    owns(tagged: ManagerTag): boolean;
+}
+/**
+ * One write at a time against one engine and definition, with what each
+ * command produced kept under the key of the row that raised it.
+ */
+export declare function useCommandRunner(engine: ViewEngine, definitionId: string, reload: ViewListState['reload']): CommandRunner;
+//# sourceMappingURL=useCommandRunner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCommandRunner.d.ts","sourceRoot":"","sources":["../../../src/react/manager/useCommandRunner.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,EAA4B,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AAGvE;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IACzB,qEAAqE;IACrE,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAEnE;AAiBD;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/B,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,MAAM,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,GAAG,CACD,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,EAC/B,OAAO,CAAC,EAAE,UAAU,GACnB,OAAO,CAAC,OAAO,CAAC,CAAC;IACpB,6DAA6D;IAC7D,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC,+CAA+C;IAC/C,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IAClC,iEAAiE;IACjE,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,GAAG,IAAI,CAAC;IACnD,6EAA6E;IAC7E,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC;CACnC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,GAC9B,aAAa,CA6If"}

package/dist/react/recordColumns.d.ts

@@ -0,0 +1,68 @@
+import { RecordColumn } from '../model/index.js';
+/**
+ * One column entry, carrying only the members it has something to say with.
+ *
+ * The one place a `RecordColumn` is built, so the rule above is kept once: a
+ * member that is nothing — no width, not pinned, not hidden — leaves the key
+ * out altogether rather than writing `undefined` under it. The three commands
+ * below and the draft's own reading of a stored list all come through here;
+ * each of them used to spell the three spreads out, and four spellings of
+ * "leave the key out" is four chances for one of them to write
+ * `{ pinned: undefined }` and mark a view unsaved for ever.
+ */
+export declare function recordColumn(field: string, members: {
+    /** Pixels, or nothing for a column that sizes itself. */
+    width?: number | null;
+    /** Held against the left edge, or nothing for one that scrolls (D19). */
+    pinned?: boolean | null;
+    /** Whether the table leaves it undrawn; only `true` is ever written. */
+    hidden?: boolean;
+}): RecordColumn;
+/** One column held against the table's left edge, or let go (D19). */
+export declare function repinned(column: RecordColumn, pinned: boolean): RecordColumn;
+/** One column at a fixed pixel width, or back to sizing itself. */
+export declare function resized(column: RecordColumn, width: number | null): RecordColumn;
+/**
+ * One column switched on or off. Everything else about it stays: hiding a
+ * column clears neither its width nor its pinning, because the entry is
+ * kept precisely so that showing it again puts back the column that was
+ * there.
+ */
+export declare function shown(column: RecordColumn, visible: boolean): RecordColumn;
+/**
+ * The table's columns after `fields` is what it shows.
+ *
+ * A column the config already knows is switched **in place** — its entry
+ * kept, `hidden` written or deleted — so switching it back on puts it back
+ * where it was rather than at the end. Which is why this says nothing about
+ * the order: a column that is not in the list has no order to give, so the
+ * order is its own command.
+ *
+ * Two entries leave the list instead, because they have nowhere to come
+ * back to: one whose field is not in `offered` — the definition dropped it,
+ * or its kind is a handle rather than something a row holds — and a second
+ * entry for a column already kept. Both are one row in the column settings
+ * and both are configs `validateRecord` refuses (`record.field.unknown`,
+ * `record.column.duplicate`), so switching them off is the repair it has
+ * always been: hiding one would leave the query and the save blocked by the
+ * control that had just run.
+ *
+ * A named field the config does not know yet joins at the end, once however
+ * many times it is named — a column has to start somewhere.
+ */
+export declare function withColumnsShown(columns: readonly RecordColumn[], fields: readonly string[], offered: ReadonlySet<string>): RecordColumn[];
+/**
+ * The table's columns in the order `fields` names them.
+ *
+ * A name that is not a column is ignored and a column the caller leaves
+ * unnamed keeps its place at the end, so a control that knows about part of
+ * the table — one area of the column settings — cannot drop the rest of it
+ * by saying nothing about it.
+ *
+ * The columns are all of them, the switched-off ones included: a hidden
+ * column has a place in the order, which is what makes switching it back on
+ * put it back where it was, so a caller that means to order the whole table
+ * names it along with the rest.
+ */
+export declare function reordered(columns: readonly RecordColumn[], fields: readonly string[]): RecordColumn[];
+//# sourceMappingURL=recordColumns.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recordColumns.d.ts","sourceRoot":"","sources":["../../src/react/recordColumns.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE;IACP,yDAAyD;IACzD,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,yEAAyE;IACzE,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACxB,wEAAwE;IACxE,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,GACA,YAAY,CAOd;AAED,sEAAsE;AACtE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,GAAG,YAAY,CAM5E;AAED,mEAAmE;AACnE,wBAAgB,OAAO,CACrB,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,YAAY,CAMd;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,GAAG,YAAY,CAM1E;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAC3B,YAAY,EAAE,CAiBhB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,MAAM,EAAE,SAAS,MAAM,EAAE,GACxB,YAAY,EAAE,CAYhB"}

package/dist/react/recordDraft.d.ts

@@ -0,0 +1,31 @@
+import { RecordColumn, RecordSort, RecordSummary } from '../model/index.js';
+export declare function recordSort(value: unknown): RecordSort[];
+/**
+ * Summaries as cells that can be drawn. An entry whose function is not one
+ * the model names is dropped rather than guessed at — there is no sensible
+ * default for "which number is this", and a wrong one would be a figure on
+ * screen that nobody asked for.
+ */
+export declare function recordSummaries(value: unknown): RecordSummary[];
+/**
+ * Whether `raw` was already the sound list `read` made of it.
+ *
+ * A list that had to be repaired is a config the kernel refuses
+ * (`record.sort.invalid`, `record.summaries.invalid`, `record.table.invalid`)
+ * over entries no control can address — they are not on screen, because they
+ * could not be read. So the next write of any kind carries the repair with
+ * it: the user changes a column and the sort that was a string becomes the
+ * list they can see, which is the same promise this module makes about
+ * entries, made about the list itself.
+ */
+export declare function wasSound(raw: unknown, read: readonly unknown[]): boolean;
+/**
+ * Columns as the draft holds them, with a width, a pinning and a visibility
+ * it can use. A column switched off keeps its entry and therefore its place
+ * in the order, so it is read like any other — only `hidden` says the table
+ * does not draw it, and anything but `true` under that name reads as shown.
+ * A pinning is read the same way (`columnPinned`): it is one yes-or-no
+ * (D19), so a stored `'left'` or `'top'` is a column that scrolls.
+ */
+export declare function recordColumns(value: unknown): RecordColumn[];
+//# sourceMappingURL=recordDraft.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recordDraft.d.ts","sourceRoot":"","sources":["../../src/react/recordDraft.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,aAAa,EAGnB,MAAM,mBAAmB,CAAC;AAwB3B,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,EAAE,CAKvD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,EAAE,CAM/D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,CAExE;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,EAAE,CAQ5D"}

package/dist/react/recordEdits.d.ts

@@ -0,0 +1,58 @@
+import { RecordSort, RecordSummary, RecordViewConfig, ViewInstance } from '../model/index.js';
+import { ViewRuntimeState } from '../runtime/index.js';
+/**
+ * The sort after one press on a column header: ascending, then descending,
+ * then off.
+ *
+ * By default the field joins the sort — a new one at the end, an existing
+ * one in its place, since the order of `sort` is the priority between
+ * columns — so several columns may order the rows. With `exclusive` the
+ * cycled field becomes the whole sort, wherever it stood: what a plain click
+ * on a header means, where Shift is what adds.
+ */
+export declare function cycledSort(current: readonly RecordSort[], field: string, exclusive: boolean): RecordSort[];
+/**
+ * The page sizes worth offering, in order and without a repeat.
+ *
+ * The ladder is the engine's (`RuntimeLimits.pageSizes`): a product that
+ * wants 15/30/60 hands it in with the budgets rather than shipping a build.
+ * A size above `max` is refused by `validateRecord`, so offering it would be
+ * offering a way to break the view — and the size the view is running at
+ * joins whatever it is, since a view saved at 500 under an older limit still
+ * has to show what it is running at, and a select whose value is not among
+ * its options shows nothing at all.
+ */
+export declare function offeredPageSizes(ladder: readonly number[], max: number | undefined, current: number): number[];
+/**
+ * The rung of the layout's ladder nearest a size the limits refuse — above
+ * `max`, not a whole number, or under one — or `null` for a size they
+ * admit. Only rungs the limits admit are offered.
+ */
+export declare function admittedPageSize(ladder: readonly number[], max: number | undefined, size: number | undefined): number | null;
+/**
+ * The summaries to write, in the shape the saved config uses for none.
+ *
+ * `summaries` is optional, so "no summaries" is spelled two ways — an empty
+ * list, or no member at all — and `dirty` is an equality against the saved
+ * config, which cannot tell the difference between a shape and a change.
+ * Adding a summary and taking it away again therefore left the view unsaved
+ * for the rest of the session, with the leave guard asking about an edit
+ * that had already been undone. `edit` removes a member given as
+ * `undefined`, so answering with the saved config's own spelling makes
+ * undoing an undo.
+ */
+export declare function summariesOf(next: RecordSummary[], saved: ViewInstance | null): RecordSummary[] | undefined;
+/**
+ * The patch, plus the sound form of any list the draft could not be read
+ * from and this patch does not already replace.
+ *
+ * A list the controller had to repair is a config the kernel refuses over
+ * entries that are not on screen — they could not be read, so no control
+ * lists them and no control can take them out. Carrying the repair along
+ * with whatever the user *did* change is what makes "the first change they
+ * make writes the sound list back" true of every list rather than only of
+ * the one they touched: with no sortable field left to add, an unreadable
+ * `sort` had no other way out at all.
+ */
+export declare function repairing(patch: Partial<RecordViewConfig>, state: ViewRuntimeState<RecordViewConfig>): Partial<RecordViewConfig>;
+//# sourceMappingURL=recordEdits.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recordEdits.d.ts","sourceRoot":"","sources":["../../src/react/recordEdits.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACb,gBAAgB,EAEhB,YAAY,EACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAQ5D;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,OAAO,GACjB,UAAU,EAAE,CAcd;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,OAAO,EAAE,MAAM,GACd,MAAM,EAAE,CAKV;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,IAAI,EAAE,MAAM,GAAG,SAAS,GACvB,MAAM,GAAG,IAAI,CAQf;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,aAAa,EAAE,EACrB,KAAK,EAAE,YAAY,GAAG,IAAI,GACzB,aAAa,EAAE,GAAG,SAAS,CAM7B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,EAChC,KAAK,EAAE,gBAAgB,CAAC,gBAAgB,CAAC,GACxC,OAAO,CAAC,gBAAgB,CAAC,CAqB3B"}

package/dist/react/recordSelection.d.ts

@@ -0,0 +1,46 @@
+import { RecordKey } from '../model/index.js';
+import { RecordRow } from '../record/index.js';
+import { RecordViewRuntime } from '../runtime/index.js';
+/**
+ * Which rows a set of rows is: the question that fetched them and the page
+ * of its answer. Two results with the same mark are the same rows asked for
+ * again — a refresh — and two with different marks are a different set, even
+ * where a key turns up in both.
+ *
+ * The question is the applied config by identity (`ViewResult.own`): it is a
+ * new object exactly when `apply` promotes a draft — a condition, a sort — and
+ * the same one across every refresh of it.
+ */
+export interface RowsMark {
+    readonly question: unknown;
+    readonly page: number | string | null;
+}
+/** Where the last plain toggle landed, and among which rows. */
+export interface SelectionAnchor {
+    readonly key: RecordKey;
+    readonly rows: RowsMark;
+}
+type RecordSnapshot = ReturnType<RecordViewRuntime['getSnapshot']>;
+/** The rows on screen and their mark, or `null` before any record result. */
+export declare function rowsOnScreen(snapshot: RecordSnapshot): {
+    rows: readonly RecordRow[];
+    mark: RowsMark;
+} | null;
+/**
+ * The anchor a range extends from, when it still stands among these rows:
+ * set on this very page of this very question, and its row still on it.
+ */
+export declare function standingAnchor(anchor: SelectionAnchor | null, rows: readonly RecordRow[], mark: RowsMark): RecordKey | null;
+/**
+ * The selection after `key` is toggled — alone, or with every row between
+ * `anchor` and it when there is an anchor to extend from.
+ *
+ * A range goes the way the pressed row goes: pressing an unselected row
+ * selects the range, pressing a selected one unselects it, which is the rule
+ * every file manager and mail client keeps. Rows are taken in result order,
+ * so a range pressed upwards covers what one pressed downwards would.
+ * Selected rows outside the range are left as they are.
+ */
+export declare function toggledSelection(selection: readonly RecordKey[], rows: readonly RecordRow[], key: RecordKey, anchor: RecordKey | null): RecordKey[];
+export {};
+//# sourceMappingURL=recordSelection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recordSelection.d.ts","sourceRoot":"","sources":["../../src/react/recordSelection.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAgB,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D;;;;;;;;;GASG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;CACvC;AAED,gEAAgE;AAChE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;CACzB;AAED,KAAK,cAAc,GAAG,UAAU,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAC,CAAC;AAEnE,6EAA6E;AAC7E,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,cAAc,GACvB;IAAE,IAAI,EAAE,SAAS,SAAS,EAAE,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,IAAI,CAQvD;AAUD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,eAAe,GAAG,IAAI,EAC9B,IAAI,EAAE,SAAS,SAAS,EAAE,EAC1B,IAAI,EAAE,QAAQ,GACb,SAAS,GAAG,IAAI,CAQlB;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,SAAS,SAAS,EAAE,EAC/B,IAAI,EAAE,SAAS,SAAS,EAAE,EAC1B,GAAG,EAAE,SAAS,EACd,MAAM,EAAE,SAAS,GAAG,IAAI,GACvB,SAAS,EAAE,CAgBb"}

package/dist/react/useAnalysisEditor.d.ts

@@ -0,0 +1,183 @@
+import { FieldGroupDefinition, FilterTree, AnalysisDateDiffUnit, AnalysisDateUnit, AnalysisElement, AnalysisGroup, AnalysisHavingExpression, AnalysisMetric, AnalysisSort, AnalysisViewConfig, ChartSpec, ChartType, FieldDefinition, Issue } from '../model/index.js';
+import { havingRows, AnalysisLimitBounds } from '../analysis/index.js';
+import { QuestionEditing } from './analysisEditing.js';
+import { AnalysisFieldOption } from './analysisFields.js';
+import { DropNotice, MetricRemoval } from './useReshape.js';
+import { FieldKindRegistry } from '../filter/index.js';
+import { OptionSource, ViewRuntime } from '../runtime/index.js';
+export interface AnalysisEditorController extends QuestionEditing {
+    /**
+     * What the latest edit took out beyond what it was asked to, while the
+     * draft is still the one that edit made; `null` otherwise. Said with an
+     * undo rather than asked before (D71: no confirmation dialog).
+     */
+    dropped: DropNotice | null;
+    /** Puts the question back as it was before the edit `dropped` reports. */
+    undoDrop(): void;
+    /**
+     * Whether the draft is still the one `undoDrop` put back — what lets
+     * 「已撤销」 stay said until the next edit, not a render later.
+     */
+    undone: boolean;
+    /** Takes the notice away and keeps the edit. */
+    dismissDrop(): void;
+    /** Whether the metric at `index` may be removed, and if not, why. */
+    metricRemoval(index: number): MetricRemoval;
+    /**
+     * The expansion chain in force, outermost first (D20 屏 G): the arrays
+     * the analysis counts inside. Empty when it counts records.
+     */
+    elements: AnalysisElement[];
+    /** The next level the capability declares beyond the chain, or none. */
+    expandable: {
+        path: string;
+        label: string;
+    } | null;
+    /** Whether the capability declares a chain at all: the slot exists then. */
+    expansible: boolean;
+    /**
+     * What is being counted: the innermost element, else the definition's
+     * `recordNoun`; `null` where the definition names none, and a surface
+     * says its own word for a record.
+     */
+    unit: string | null;
+    /** The array a level expands, as its field is labelled. */
+    elementLabel(index: number): string;
+    /** The fields a level's own gate may name. */
+    elementFields(index: number): FieldDefinition[];
+    /** One level deeper, along the declared chain; re-scopes the question. */
+    expand(path: string): void;
+    /** Cuts the chain at `index`: that level and every level inside it leave. */
+    collapse(index: number): void;
+    /** A level's gate on the entries it lets through, or none. */
+    setElementFilter(index: number, filter: FilterTree | undefined): void;
+    groups: AnalysisGroup[];
+    metrics: AnalysisMetric[];
+    sort: AnalysisSort[];
+    limit: number;
+    /**
+     * The range 「前 N 组」 may take and the N a blank stands for, from the one
+     * `limitBounds` admission reads, so a field can say the bounds Apply is
+     * refused by. `{ max: 0, fallback: 0 }` without an analysis capability.
+     */
+    limitBounds: AnalysisLimitBounds;
+    layout: AnalysisViewConfig['layout'];
+    chart: ChartSpec;
+    totals: boolean;
+    /** Issues about the analysis and its chart, not the whole view. */
+    issues: Issue[];
+    /** Aliases a chart or a sort may reference. */
+    aliases: {
+        groups: string[];
+        metrics: string[];
+    };
+    /**
+     * The draft's metrics that are moments (`momentMetrics`) — the earliest or
+     * the latest of a date — by alias: read in the table and on a card, never
+     * measured by a mark, compared by 「只保留」 or calculated with.
+     */
+    moments: ReadonlySet<string>;
+    /** What the definition allows, already expanded for configured elements. */
+    fields: AnalysisFieldOption[];
+    /** The picker groups the definition declares. */
+    fieldGroups: readonly FieldGroupDefinition[];
+    countable: boolean;
+    /**
+     * True while the rows on screen answer an older question than the one
+     * being asked: the runtime is about to run the draft on its own
+     * (`autoApplyDue`), or has sent it and the answer is on its way
+     * (`answeringAnew`) — however slow it is. The result is drawn faded rather
+     * than cleared, because a blank in between reads as a failure.
+     */
+    stale: boolean;
+    /** Whether 「只保留」 exists here: the capability declares `having`. */
+    havingAllowed: boolean;
+    /** Whether a formula or a derived metric may be written: `expressions`. */
+    expressionsAllowed: boolean;
+    /**
+     * The metric types 「只保留」 may compare (`havingMetrics`); `null` where
+     * the capability names none, which is every type.
+     */
+    havingMetrics: readonly string[] | null;
+    /**
+     * The field an opening or closing value (FIRST / LAST) at the root is
+     * ordered by when it names none (`firstLastOrderBy`, the model's event
+     * time); `null` where the capability does not say.
+     */
+    firstLastOrderBy: string | null;
+    /**
+     * The units a time between two moments may be measured in
+     * (`dateDiffUnitsOf`); empty where the capability offers no computed
+     * expressions, which takes 「两个时刻之差」 away.
+     */
+    dateDiffUnits: readonly AnalysisDateDiffUnit[];
+    /** Whether the rows may be ordered by a metric (`metricSort`). */
+    metricSortAllowed: boolean;
+    /** Whether a date dimension may fill its empty buckets (`dense`). */
+    denseAllowed: boolean;
+    /**
+     * The metric types the source estimates (`approximateMetrics`): a metric
+     * of one is named with 「≈」 wherever it is mentioned.
+     */
+    approximate: readonly string[];
+    /**
+     * 「只保留」 as rows of one comparison each, or `null` when the stored
+     * having is a shape the rows cannot say (`havingRows`).
+     */
+    having: ReturnType<typeof havingRows>;
+    /**
+     * The 「只保留」 the rows on screen ran under — the result's config, not
+     * the draft — or `undefined` when nothing ran or it kept every group. The
+     * result's reading says it (`AnalysisToolbar`): a saved view opens with
+     * the tray folded, and groups missing from the table with nothing on
+     * screen saying why read as groups with no data.
+     */
+    ranHaving: AnalysisHavingExpression | undefined;
+    /**
+     * The fields a metric's own condition may name (D20 屏 H): the scalar
+     * fields of the analysis scope — never a search, an array or an element
+     * match, which Wow refuses in metric position — as the range's editor
+     * names them, so the condition is built of the same pills.
+     */
+    conditionFields: readonly FieldDefinition[];
+    /** The kinds those fields are read by; absent without a runtime. */
+    kinds: FieldKindRegistry | undefined;
+    /** Candidates for a remote value editor, as the range's editor has them. */
+    optionSource?(remote: string): OptionSource | null;
+    /**
+     * True while the draft says something the last Run did not (D17-6): the
+     * groups, metrics, sort, limit, chart and totals all wait for Run, and a
+     * Run that was refused leaves them waiting. The same reading as the filter
+     * editor's `pending` — both buttons run the whole draft.
+     */
+    pending: boolean;
+    /**
+     * The granularity a new time dimension on this field starts at (K4): read
+     * off the applied range's conditions on the field, failing that off the
+     * buckets a result already has on it, else the field's first unit.
+     */
+    dateUnitFor(field: AnalysisFieldOption): AnalysisDateUnit;
+    setSort(sort: AnalysisSort[]): void;
+    /**
+     * Sets the sort and runs it now — unless something else in the draft is
+     * waiting for Apply. A press on a result header asks to see *this* result
+     * in another order; running would apply the other edits too (a range
+     * condition not yet applied, a dimension added in the tray), which is not
+     * that gesture's to do. Then the sort joins them, the pending dot shows,
+     * and Apply runs them together — the rule the metric card's whole
+     * (`useAnalysisResult`) keeps. Whether it ran is returned.
+     */
+    sortNow(sort: AnalysisSort[]): boolean;
+    setLimit(limit: number): void;
+    /** A redraw of the same rows, never a run; nor does it count as pending. */
+    setLayout(layout: AnalysisViewConfig['layout']): void;
+    setChartType(type: ChartType): void;
+    updateChart(patch: Partial<ChartSpec>): void;
+    setTotals(totals: boolean): void;
+    submit(): void;
+    /** Auto-refresh pauses between these two, so typing is never interrupted. */
+    focus(): void;
+    blur(): void;
+}
+export declare function useAnalysisEditor(runtime: ViewRuntime | null): AnalysisEditorController;
+//# sourceMappingURL=useAnalysisEditor.d.ts.map

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

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