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

package/dist/runtime/dashboard/panelRun.d.ts

@@ -0,0 +1,101 @@
+import { DashboardFilters, DashboardViewConfig, DashboardViewPanel, FilterTree, Issue, RuntimeLimits } from '../../model/index.js';
+import { FieldKindRegistry } from '../../filter/index.js';
+import { HandOver } from '../navigation.js';
+import { DataViewRuntime } from '../viewRuntime.js';
+import { PanelView } from './children.js';
+import { DashboardRuntimeState } from './contract.js';
+import { DashboardPanelState } from './panels.js';
+import { AnchorClock, PanelAnchor } from './anchor.js';
+/** What a panel's child is handed by the board it sits on. */
+export interface PanelRun {
+    /** The view, its config the view's own as the board presents it. */
+    view: PanelView;
+    /** The condition the board narrows it by, in the view's own field names. */
+    scope: FilterTree;
+    /** What the board says about it: an override dropped, a unit kept. */
+    issues: Issue[];
+    /** A trend card anchored to the period a date filter picked (D39). */
+    anchor: PanelAnchor | null;
+}
+/**
+ * What one data panel runs on this board: the view's own config with the
+ * panel's override of how it looks laid over it (`presentedConfig`), its
+ * time dimension at the board's unit where its definition allows that
+ * (`regrouped`, D22 F), and under the board's standing condition and
+ * every filter wired to it that holds a value — each in the
+ * panel's own field names (`panelFilterTree`) — but one whose value was
+ * pressed on this panel (`DashboardFilters.from`). A trend card whose axis
+ * a date filter holds one period of runs anchored to it (`panelAnchor`,
+ * D39): its own dates read as of that period, the window ending with it.
+ */
+export declare function panelRun(panel: DashboardViewPanel, index: number, view: PanelView, board: {
+    applied: DashboardViewConfig;
+    filters: DashboardFilters;
+    kinds: FieldKindRegistry;
+    limits: RuntimeLimits;
+    clock: AnchorClock;
+}): PanelRun;
+/**
+ * The one condition a data panel runs under, in its own field names: the
+ * board's fixed scope (`boardCondition`: `fixed`, D26 Q31), mapped through
+ * the panel's bindings, ANDed with every filter wired to it that holds a
+ * value in `filters` (`panelFilterTree`) — but one whose value was pressed
+ * on this panel (`DashboardFilters.from`). The panel runs under it with
+ * every value in force (`panelRun`); what a text filter offers is counted
+ * under it with only the values the host holds
+ * (`FilterValues.candidatesOf`), so the two never tell apart what scope a
+ * panel is in. An anchored card (`panelAnchor`, D39) runs under its window
+ * in place of the date filter's own condition.
+ */
+export declare function panelScope(panel: DashboardViewPanel, board: {
+    applied: DashboardViewConfig;
+    filters: DashboardFilters;
+    kinds: FieldKindRegistry;
+}, anchor?: PanelAnchor | null): FilterTree;
+/** A panel's child as the board left it, and what the panel reports. */
+export interface PanelOutcome {
+    runtime: DataViewRuntime | null;
+    issues: Issue[];
+}
+/**
+ * The state of every panel on a board as it now stands (`boardPanels`):
+ * what the runtime knows of it, and its two ways of treating a data panel's
+ * child — `run` for one on the tab shown, `hold` for one elsewhere.
+ */
+export interface BoardPanelsHost {
+    applied: DashboardViewConfig;
+    /** Admission of `applied`. */
+    issues: readonly Issue[];
+    tab: string | null;
+    filters: DashboardFilters;
+    held(name: string): boolean;
+    viewOf(panel: DashboardViewPanel): PanelView | null;
+    /** A data panel on the tab shown, its child brought in line with it. */
+    run(panel: DashboardViewPanel, index: number, own: Issue[]): PanelOutcome;
+    /** A data panel elsewhere: the child it has, kept as it stands, or none. */
+    hold(panel: DashboardViewPanel, index: number, own: Issue[]): PanelOutcome | null;
+}
+/**
+ * Every panel's state on the board as it now stands. Only the tab on
+ * screen runs (D22 E): a panel elsewhere keeps the child it has, rows and
+ * all, exactly as it stands — neither re-scoped nor re-run — until its tab
+ * is shown; one never shown has none yet. A problem with the board itself
+ * stops every panel, the rule `apply` follows; a panel's own problem stops
+ * only that one. It is judged here because a reference arriving also comes
+ * here, and a view waiting to be fixed must not start querying behind it.
+ */
+export declare function boardPanels(host: BoardPanelsHost): DashboardPanelState[];
+/**
+ * What one data panel's view takes off the board as it stands
+ * (`DashboardRuntime.handOver`): its two parts (`panelHandOver`), and — on
+ * a board that was saved — the board it left, for the way back to it with
+ * the tab and the filters it was read on. `null` for no such data panel.
+ */
+export declare function boardHandOver(panelId: string, state: Pick<DashboardRuntimeState, 'applied' | 'filters' | 'saved' | 'title' | 'tab'>, board: {
+    definitionId: string;
+    held(name: string): boolean;
+    kinds: FieldKindRegistry;
+    /** The window a panel anchored at its last run (`PanelRun.anchor`). */
+    anchor?(panelId: string): PanelAnchor | null;
+}): HandOver | null;
+//# sourceMappingURL=panelRun.d.ts.map

package/dist/runtime/dashboard/panelRun.d.ts.map

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

package/dist/runtime/dashboard/panels.d.ts

@@ -0,0 +1,155 @@
+import { DashboardPanel, DashboardViewConfig, DataViewConfig, FieldDefinition, Issue, PanelClick, ViewKind } from '../../model/index.js';
+import { FilterReach } from '../../dashboard/index.js';
+import { PanelGrouping } from './grouping.js';
+import { PanelChild } from './children.js';
+import { DataViewRuntime } from '../viewRuntime.js';
+import { ViewRuntime } from '../viewRuntimeTypes.js';
+/** One panel as the grid renders it. */
+export interface DashboardPanelState {
+    id: string;
+    panel: DashboardPanel;
+    /**
+     * The child runtime of a data panel, once its reference has been loaded and
+     * admitted. `null` for a content panel and for one that cannot run.
+     */
+    runtime: ViewRuntime<DataViewConfig> | null;
+    /** Issues about this panel alone; the dashboard around it still works. */
+    issues: Issue[];
+    /**
+     * The fields of the view a data panel shows, once it is known: what its
+     * findings are named by, a field by its label rather than its path —
+     * above all a panel that cannot run, which has no runtime to ask. Empty
+     * for a content panel and for one whose view is not known.
+     */
+    fields: readonly FieldDefinition[];
+    /** The tab it is on (`panelTab`); `null` on a board without tabs. */
+    tab: string | null;
+    /**
+     * A data panel on a tab that has not been shown yet: nothing was asked
+     * for it and nothing is wrong with it — its child is made the first time
+     * its tab is (D22 E, only the tab on screen runs).
+     */
+    waiting: boolean;
+    /**
+     * What each of the board's filters does to it, by filter name
+     * (`filterReach`): wired, and through which field, or not and why. Empty
+     * for a content panel; a data panel whose view is not known yet answers
+     * for its wires alone.
+     */
+    reach: Readonly<Record<string, FilterReach>>;
+    /** What the board's time grouping does to it; see `PanelGrouping`. */
+    grouping: PanelGrouping;
+    /**
+     * What a press on one of its groups does (D22 H, I): its click as set, or
+     * `null` for the follow-up menu — none set, or one set aside
+     * (`clickInForce`). A press reads it here and judges nothing itself
+     * (`PanelPresses`, A-11).
+     */
+    click: PanelClick | null;
+    /**
+     * Why the click set is not the one in force, carried with it: what
+     * admission found wrong with it, which the panel's warning says and a
+     * press falling back to the follow-up menu says again; `null` when
+     * admission said nothing about it.
+     */
+    clickFinding: Issue | null;
+}
+/**
+ * A panel's click, unless admission said something about it: a click that
+ * cannot do what it says is set aside and a press opens the follow-up menu,
+ * carrying the finding that says why. So is one that sets a filter the
+ * host holds (`DashboardRuntime.holdFilters`): a press cannot change what
+ * the page fixed, so it does what a press does on a panel with no click,
+ * and nothing is wrong with it.
+ */
+export declare function clickInForce(panel: DashboardPanel, issues: readonly Issue[], held?: (filter: string) => boolean): Pick<DashboardPanelState, 'click' | 'clickFinding'>;
+/** The panel an issue belongs to, or `null` for one about the dashboard. */
+export declare function panelOf(found: Issue): number | null;
+/**
+ * Whether the issues hold an error about the dashboard itself — one no
+ * panel owns, "too many panels" at `['panels']` included.
+ *
+ * Only such an error stops the board: its apply, its timer and every panel
+ * with it. A panel's own error — a reference it may not use, a binding that
+ * does not hold, a link it may not show — stops that panel and nothing else,
+ * so a drag still lands and the global filter still reaches the panels that
+ * can carry it. One broken panel must not decide what the others show, and
+ * a board a user cannot rearrange until some other panel is fixed is one
+ * they cannot use.
+ */
+export declare function blocksBoard(issues: readonly Issue[]): boolean;
+/**
+ * What a board says about itself, above its panels (Q-01, A-07): every
+ * finding on the draft that no panel carries. That is the board's own —
+ * "too many panels" at `['panels']` among them, which belongs to no one
+ * panel — and a panel's that the draft raised and no panel wears yet: a
+ * fixed scope mapped onto a panel field that warns is, until it is
+ * applied, a finding under `['panels', …]` that only the draft holds, and
+ * a save would write it unseen. A panel's own findings stay the panel's to
+ * say, each in its own frame. One reading, so the workbench, an embed that
+ * builds and a host drawing its own board say the same.
+ */
+export declare function boardFindings(state: {
+    issues: readonly Issue[];
+    panels: readonly Pick<DashboardPanelState, 'issues'>[];
+}): Issue[];
+/**
+ * Whether these issues stop a view of this kind from being saved.
+ *
+ * Any error does for a record or an analysis view: its config is one
+ * question, and a question that cannot be asked is not worth keeping. A
+ * dashboard is stopped only by what stops the board (`blocksBoard`): a
+ * panel's own trouble — a view some readers cannot open, a binding that no
+ * longer holds, a view whose saved settings no longer work — is said on the
+ * panel and saved with the board (D22 B), since the author may well be
+ * saving precisely to fix a different panel, and a board nobody can save
+ * until every panel is well is one nobody can maintain.
+ */
+export declare function stopsSave(kind: ViewKind, issues: readonly Issue[]): boolean;
+/** What a thrown value says for itself; not everything thrown is an `Error`. */
+export declare function reasonOf(error: unknown): string;
+/**
+ * What a panel reports for a child that runs: the dashboard's own findings
+ * about it, then what the child still has to say about its saved config,
+ * re-addressed to the panel.
+ *
+ * The child's part is read off its snapshot rather than off `setScopeFilter`,
+ * which answers `[]` for a scope it already holds — a layout edit re-syncs
+ * every panel with the scope unchanged, and a warning must not vanish on
+ * that. And it is read second: the dashboard re-validates the merged filter
+ * against the child's fields, and the child admits the same merged tree, so
+ * a kind that warns is heard twice. The panel shows the wording, and the
+ * same sentence twice tells nobody anything more, so a warning the
+ * dashboard already reported is not repeated.
+ *
+ * Then what the child's **last result** has to say (`resultIssues`): the
+ * summaries that fell back to this page because their query failed, an
+ * analysis that filled its limit. Both workbenches and `EmbeddedView` say
+ * these; a panel showing the very same truncated pie must not fall silent
+ * because it hangs in a dashboard. They are read off the snapshot on every
+ * rebuild, and a child notifying on a result is what rebuilds, so the
+ * marker on the panel follows the result it sits over.
+ */
+export declare function panelIssues(index: number, own: readonly Issue[], runtime: DataViewRuntime): Issue[];
+/**
+ * The panels with one child's panel re-issued from what the child says now
+ * (`panelIssues`), or `null` when nothing changed — the child is not the
+ * one on screen for its panel, or it says what the panel already does.
+ */
+export declare function reissued(panels: readonly DashboardPanelState[], child: Pick<PanelChild, 'index' | 'own' | 'runtime'> | undefined): DashboardPanelState[] | null;
+/** A child's issues, addressed from the dashboard's config. */
+export declare function atPanel(index: number, issues: readonly Issue[]): Issue[];
+/**
+ * Whether two panel arrays say the same thing, so a re-sync that changes
+ * nothing can keep the previous one and a grid bound with
+ * `useSyncExternalStore` does not re-render on every apply.
+ */
+export declare function samePanels(previous: readonly DashboardPanelState[], next: readonly DashboardPanelState[]): boolean;
+/**
+ * The tab a board shows: the one asked for while it has it, else its first;
+ * `null` for a board without tabs. A stored config is read as untrusted.
+ */
+export declare function shownTab(config: DashboardViewConfig, requested: string | null): string | null;
+/** A panel whose reference could not be put to work, as its finding. */
+export declare function panelFailure(index: number, instanceId: string, reason: string): Issue;
+//# sourceMappingURL=panels.d.ts.map

package/dist/runtime/dashboard/panels.d.ts.map

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

package/dist/runtime/dashboard/presentation.d.ts

@@ -0,0 +1,25 @@
+import { DataViewConfig, Issue, IssuePath, PanelPresentation } from '../../model/index.js';
+import { KernelContext } from '../execute.js';
+/**
+ * The config a panel's child runs: the view's own with the panel's override
+ * of how it looks laid over it, and what the panel says about an override
+ * it could not use.
+ *
+ * An override is dropped — whole, with one note, never an error — when it no
+ * longer fits the view it is laid over: a member that kind does not have (a
+ * chart over a record view), or a chart the view's result cannot be drawn as
+ * any more because the view was changed since (the analysis kernel says so,
+ * the one that says so for the view itself). The panel then shows the view
+ * as the view says, which is what it would show without an override. A view
+ * already refused on its own config is left to say so: its override is not
+ * what is wrong with it.
+ *
+ * An override that is no object, or names a member no view has, is the
+ * dashboard kernel's to note (`validatePresentation`); here it is read as
+ * setting nothing more than the members it may set.
+ */
+export declare function presentedConfig(base: DataViewConfig, presentation: PanelPresentation | undefined, judge: Pick<KernelContext, 'definition' | 'kinds' | 'limits'>, path: IssuePath): {
+    config: DataViewConfig;
+    issues: Issue[];
+};
+//# sourceMappingURL=presentation.d.ts.map

package/dist/runtime/dashboard/presentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentation.d.ts","sourceRoot":"","sources":["../../../src/runtime/dashboard/presentation.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,cAAc,EACd,KAAK,EACL,SAAS,EACT,iBAAiB,EAClB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAcvE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,cAAc,EACpB,YAAY,EAAE,iBAAiB,GAAG,SAAS,EAC3C,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,YAAY,GAAG,OAAO,GAAG,QAAQ,CAAC,EAC7D,IAAI,EAAE,SAAS,GACd;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,MAAM,EAAE,KAAK,EAAE,CAAA;CAAE,CAqB7C"}

package/dist/runtime/dashboard/press.d.ts

@@ -0,0 +1,150 @@
+import { DashboardField, DashboardFilters, DashboardViewConfig, ViewInstance, FilterValue, Issue, RecordData } from '../../model/index.js';
+import { FieldKindRegistry } from '../../filter/index.js';
+import { PanelReference } from '../../dashboard/index.js';
+import { DataViewRuntime } from '../viewRuntime.js';
+import { DashboardPanelState } from './panels.js';
+import { HandOver, ViewNavigation } from '../navigation.js';
+/** What a press that sets a filter did (D22 I). */
+export type CrossFilterOutcome = 
+/** The filter took the group's value, from this panel. */
+{
+    kind: 'set';
+    filter: DashboardField;
+}
+/** The same group pressed again: the filter no longer holds it. */
+ | {
+    kind: 'cleared';
+    filter: DashboardField;
+}
+/**
+ * Nothing changed: the group holds no value the filter can take (the
+ * records without one), or the filter refused it.
+ */
+ | {
+    kind: 'no-value';
+    filter: DashboardField;
+}
+/** The panel's press sets no filter. */
+ | {
+    kind: 'none';
+};
+/** Where a press on a custom destination goes, or why it goes nowhere. */
+export type PressDestination = {
+    to: ViewNavigation;
+} | {
+    refused: Issue;
+}
+/**
+ * The click cannot do what it says — admission warned of it, or, read at
+ * the press, a board it opens is gone, or a filter or a dimension it maps
+ * is (D23 Q17): the follow-up menu opens on the group instead, and
+ * `issue` says why. The board read by the press re-judges the panel, so
+ * the warning stays on it and the next press opens the menu directly.
+ */
+ | {
+    fallback: Issue;
+};
+/** Another board as a click reads it: the instance, its config a board's. */
+export type DestinationBoard = ViewInstance & {
+    config: DashboardViewConfig;
+};
+/** What the presses need of the runtime that holds the board. */
+export interface PressHost {
+    kinds: FieldKindRegistry;
+    applied(): DashboardViewConfig;
+    filters(): DashboardFilters;
+    /** A data panel's child, the rows a press is on. */
+    child(panelId: string): DataViewRuntime | null;
+    /** Sets a filter by a press (`FilterValues.press`). */
+    press(name: string, value: FilterValue | null, panelId: string): Issue[];
+    /** Whether the host holds this filter, so no press can set it. */
+    held(name: string): boolean;
+    /**
+     * A panel as the board has it now: the click in force and why a click set
+     * is not (`DashboardPanelState`); `null` for no such panel.
+     */
+    panel(panelId: string): DashboardPanelState | null;
+    /** A saved view, loaded: what a destination carries its group into. */
+    reference(instanceId: string): Promise<PanelReference | null>;
+    /** What the panel's view would take off the board (`handOver`). */
+    handOver(panelId: string): HandOver | null;
+}
+/**
+ * The presses on a board's panels. Each reads the panel as the board has it
+ * now and the child's rows as they last landed — a press is on a group of
+ * the result on screen, never of a draft.
+ */
+export declare class PanelPresses {
+    private readonly host;
+    constructor(host: PressHost);
+    /**
+     * Cross-filtering: the filter the panel's press sets takes the group's
+     * value, marked as pressed on this panel, so every other panel wired to it
+     * runs under it and this one does not; the same group pressed again clears
+     * it — a required filter back to its default.
+     */
+    crossFilter(panelId: string, row: RecordData): CrossFilterOutcome;
+    /**
+     * Whether a filter holds this group's value, set by a press on this very
+     * panel — the one its click sets, or a date filter a span of its time
+     * axis set (`pressSpan`): the group the panel marks, since it is not
+     * narrowed by the value it set. A group whose bucket lies inside the span
+     * a date filter holds is one of the groups pressed.
+     */
+    pressed(panelId: string, row: RecordData): boolean;
+    /**
+     * The date filters a span of this panel's time axis can set (D33 Q52,
+     * 「设为〈筛选〉」): each wired to the panel through the field of a date
+     * dimension its rows ran with, and not held by the host. Offered whatever
+     * the panel's click says — a brush is not a press, and asks the menu.
+     */
+    spanFilters(panelId: string): DashboardField[];
+    /**
+     * A span of a panel's time axis set into one of its `spanFilters`, as a
+     * press sets a filter (D22 I): marked as pressed on this panel, so every
+     * other panel wired to it runs under it and this one keeps every group,
+     * marking the ones inside it (D23 Q18). `row` and `through` are the span's
+     * two ends, as `drillSpan` reads them.
+     */
+    pressSpan(panelId: string, name: string, row: RecordData, through: RecordData): CrossFilterOutcome;
+    /**
+     * Where a press on a panel with a custom destination goes: a page of the
+     * host's, its URL filled with the group; or another saved view, taking
+     * what the panel's view would take off the board (D26 Q30) — what the
+     * page holds as its scope, the reader's values and the group's
+     * conditions as its own — each condition on fields its data has too, by
+     * name and by type, the rule auto-connect wires by (D22 G). A view that
+     * is gone, or is a dashboard, is refused and said.
+     */
+    destination(panelId: string, row: RecordData): Promise<PressDestination | null>;
+    /**
+     * Another board a click opens, read for 「点击时…」 or a press — never
+     * when this board opens — through the references the panels load, so
+     * the read re-judges the click (a reference settling admits the board
+     * again); `null` for one gone, unreadable or not a board.
+     */
+    board(instanceId: string): Promise<DestinationBoard | null>;
+    /**
+     * A press that opens another board (D23 Q17): the board read — which
+     * re-judges the panel's click against it, so the state says whether the
+     * mapping still holds and, if not, why — then each filter mapped set
+     * from its source — the group's value on a
+     * dimension, in the filter's shape, or what this board's filter holds at
+     * the press (its default until a reader set another) — and the rest at
+     * the target's defaults, as a board opened without a value for them would
+     * start. A source with nothing to give — the records without a value, a
+     * filter left blank, a value the target filter refuses (several into one
+     * that takes one) — leaves that filter at its default too.
+     */
+    private toBoard;
+    /** The group's value on one dimension, in a filter's shape; `null` for none. */
+    private groupValue;
+    /** The filter a panel's press sets, and the field it is wired through. */
+    private filterOf;
+    private panelOf;
+    /** The row's groups, as the config the child's rows ran on reads them. */
+    private pressedOn;
+    /** The group's value in the filter's shape, or `null` for none. */
+    private valueOf;
+}
+//# sourceMappingURL=press.d.ts.map

package/dist/runtime/dashboard/press.d.ts.map

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

package/dist/runtime/dashboard/references.d.ts

@@ -0,0 +1,97 @@
+import { DashboardViewConfig, Issue } from '../../model/index.js';
+import { PanelReference } from '../../dashboard/index.js';
+/** Loads what a panel references; rejects when it is gone or unreadable. */
+export type PanelResolver = (instanceId: string) => Promise<PanelReference>;
+/**
+ * The references a dashboard's panels point at, as far as they are known.
+ *
+ * Three answers per instance id: not asked yet, being loaded, and loaded —
+ * where "loaded" is a reference or `null` for one that is gone or unreadable.
+ * A fourth, kept apart, is a load that failed: a reference that arrived but
+ * could not be put to work (its definition names a source the host does not
+ * resolve, say), or a read that failed for a reason that may pass — the
+ * store unreachable, or answering with an error of its own. Admission cannot
+ * see either, so the reason is remembered here and reported against the
+ * panel that asked for it (`dashboard.panel.failed`), and `retry` asks again.
+ * Only a store's `NOT_FOUND` or `FORBIDDEN` — or another answer that would be
+ * the same the next time — says the view is gone (`dashboard.panel.unavailable`).
+ *
+ * The runtime is told once per settled load — resolved, unreadable, or
+ * failed — and re-judges its draft then; what it does with that is its own.
+ */
+export declare class PanelReferences {
+    private readonly resolve;
+    /** Called after each load settles, however it settled. */
+    private readonly settled;
+    /** Resolved references by instance id; `null` once known to be unreadable. */
+    private readonly references;
+    /** Why a resolved reference could not be brought into service, by id. */
+    private readonly failures;
+    private readonly pending;
+    constructor(resolve: PanelResolver, 
+    /** Called after each load settles, however it settled. */
+    settled: () => void);
+    /** What admission validates the panels against. */
+    get known(): ReadonlyMap<string, PanelReference | null>;
+    /** True while a reference is still being loaded. */
+    get resolving(): boolean;
+    /** The reference for an id, `null` for an unreadable one, `undefined` for one not loaded yet. */
+    get(instanceId: string): PanelReference | null | undefined;
+    /** Why the reference could not be put to work, if it could not. */
+    failure(instanceId: string): string | undefined;
+    /**
+     * Starts loading the references a config needs and does not have yet, and
+     * says whether it started any.
+     *
+     * `awaited` says whether anyone is waiting on the outcome. `ready()` waits
+     * on what the constructor starts, so a load that cannot be brought into
+     * service at all refuses the opening. A load `edit` or `adoptSaved` starts
+     * has no such caller: letting it reject would leave an unhandled rejection
+     * and no trace on screen, so its failure becomes this panel's issue.
+     */
+    load(config: DashboardViewConfig, awaited: boolean): boolean;
+    /**
+     * Loads one saved view before any panel points at it — the one a board is
+     * about to add, so the panel starts at the size of what it shows — and
+     * resolves once it has settled, however it settled; `null` when it is
+     * already known or on its way, and there is nothing to start.
+     */
+    fetch(instanceId: string): Promise<void> | null;
+    /**
+     * Asks again for every reference whose load failed (`failure`), and says
+     * whether there was one: a board's refresh, which a reader presses
+     * because something on it looks wrong.
+     */
+    retryFailed(): boolean;
+    /**
+     * Asks again for one reference whose load failed, forgetting the failure
+     * first; `false` when it had not failed, and there is nothing to ask.
+     */
+    retry(instanceId: string | undefined): boolean;
+    /**
+     * A finding of admission as the reader should hear it: a view the kernel
+     * finds missing (`dashboard.panel.unavailable`) because its read failed —
+     * not because the store said it is gone — is that failure
+     * (`dashboard.panel.failed`). A reader told the view was deleted, or not
+     * shared, would go and ask its owner for nothing.
+     */
+    restate(found: Issue): Issue;
+    private start;
+    /**
+     * Resolves once every reference the current config needs has been loaded or
+     * found unreadable. A reference that arrives may add panels of its own to
+     * load, so this drains rather than awaiting one round.
+     */
+    ready(): Promise<void>;
+    /**
+     * A reference known without asking the store — the view a board has just
+     * saved one of its own views as — so the panel pointing at it does not
+     * blank while it is read back.
+     */
+    seed(reference: PanelReference): void;
+    private resolved;
+    private failed;
+    /** A read that failed for a reason that may pass; see `gone`. */
+    private unreadable;
+}
+//# sourceMappingURL=references.d.ts.map

package/dist/runtime/dashboard/references.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../../../src/runtime/dashboard/references.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,KAAK,EACX,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,0BAA0B,CAAC;AAIlC,4EAA4E;AAC5E,MAAM,MAAM,aAAa,GAAG,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;AAE5E;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,eAAe;IAQxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,0DAA0D;IAC1D,OAAO,CAAC,QAAQ,CAAC,OAAO;IAT1B,8EAA8E;IAC9E,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA4C;IACvE,yEAAyE;IACzE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IACtD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;gBAGzC,OAAO,EAAE,aAAa;IACvC,0DAA0D;IACzC,OAAO,EAAE,MAAM,IAAI;IAGtC,mDAAmD;IACnD,IAAI,KAAK,IAAI,WAAW,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC,CAEtD;IAED,oDAAoD;IACpD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,iGAAiG;IACjG,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,GAAG,SAAS;IAI1D,mEAAmE;IACnE,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI/C;;;;;;;;;OASG;IACH,IAAI,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO;IAgB5D;;;;;OAKG;IACH,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAO/C;;;;OAIG;IACH,WAAW,IAAI,OAAO;IAMtB;;;OAGG;IACH,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO;IAa9C;;;;;;OAMG;IACH,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IAe5B,OAAO,CAAC,KAAK;IAmBb;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;;;OAIG;IACH,IAAI,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI;IAKrC,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,MAAM;IAKd,iEAAiE;IACjE,OAAO,CAAC,UAAU;CAMnB"}