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

package/dist/dashboard/filters.d.ts

@@ -0,0 +1,104 @@
+import { DashboardField, DashboardFilters, DashboardViewConfig, FieldOption, FilterLeaf, FilterOperatorName, FilterTree, FilterValue, Issue, IssuePath, PanelBinding, RuntimeLimits } from '../model/index.js';
+import { EditorDescriptor, FieldKindRegistry } from '../filter/index.js';
+/**
+ * The operator a filter of each of the six types is asked with: a date
+ * filter a window (`BETWEEN`, which reads a relative window, a range, a day
+ * or a named period alike), a yes-or-no `EQ`, text, ids and numbers `IN` —
+ * one value or several, so the same condition reaches a `string`, an `enum`
+ * and a `reference` field without being translated on the way — and a search
+ * `SEARCH`, the text a record view's search box looks for. A pre-C board
+ * condition is read into defaults by the same table (`migrateDashboardConfig`).
+ */
+export declare const FILTER_TYPE_OPERATOR: {
+    readonly date: "BETWEEN";
+    readonly text: "IN";
+    readonly id: "IN";
+    readonly number: "IN";
+    readonly boolean: "EQ";
+    readonly search: "SEARCH";
+};
+/**
+ * The operator a filter's condition is asked with: its type's
+ * (`FILTER_TYPE_OPERATOR`), or — for a kind outside the six — the way its
+ * kind asks by default.
+ */
+export declare function filterOperatorOf(field: Pick<DashboardField, 'kind'>, kinds: FieldKindRegistry): FilterOperatorName;
+/** Whether a filter's value says nothing yet: nothing picked, nothing typed. */
+export declare function isBlankFilterValue(field: DashboardField, value: unknown, kinds: FieldKindRegistry): boolean;
+/**
+ * The condition a filter's value stands for, on the filter's own name, or
+ * `null` while it is blank — a blank filter narrows nothing.
+ */
+export declare function filterCondition(field: DashboardField, value: FilterValue | undefined, kinds: FieldKindRegistry): FilterLeaf | null;
+/**
+ * What a board's filters hold before anyone set them: every default, and the
+ * time grouping's default unit.
+ */
+export declare function defaultFilters(config: DashboardViewConfig): DashboardFilters;
+/** The well-formed filters of a config: a stored `fields` is untrusted. */
+export declare function filtersOf(config: DashboardViewConfig): DashboardField[];
+/**
+ * What one value of one filter is refused for, at `path`: a value its kind
+ * cannot read, several values on a filter that takes one. Blank is not
+ * refused — it is a filter holding nothing.
+ */
+/**
+ * The named periods a one-day filter (`DashboardField.oneDay`) offers:
+ * the days that have come, by name. 「明天」 is one day too, but one with
+ * nothing in it yet.
+ */
+export declare const ONE_DAY_PRESETS: readonly ["today", "yesterday", "dayBeforeYesterday"];
+/**
+ * Whether a date value is one day, whatever the clock says: one of
+ * `ONE_DAY_PRESETS`, or a calendar day from its start to its end (`to`
+ * the same day, or left out). A window, a longer period or a moment is not.
+ */
+export declare function isOneDayValue(value: FilterValue): boolean;
+export declare function filterValueIssues(field: DashboardField, value: FilterValue, kinds: FieldKindRegistry, path: IssuePath, limits?: RuntimeLimits): Issue[];
+/**
+ * The filters a board holds as asked — a host's address, a reader's pick —
+ * admitted: a value of a filter the board lacks, or one its filter refuses,
+ * is left out and said in `refused`; a required filter left blank holds its
+ * default, since it never runs empty; a unit the time grouping does not offer
+ * is its default. `wanted` left out is every default.
+ */
+export declare function admitFilters(config: DashboardViewConfig, wanted: DashboardFilters | null | undefined, kinds: FieldKindRegistry): {
+    filters: DashboardFilters;
+    refused: Issue[];
+};
+/**
+ * The board's filters as the condition one panel is narrowed by, in its own
+ * field names: each filter wired to it (`bindings`) that holds a value,
+ * ANDed. A filter the panel is not wired to is left out — it does not reach
+ * that panel, which is what the panel then says (「不受此筛选影响」). Among
+ * conditions ANDed, leaving one out asks a wider question, never a wrong
+ * one, which an arbitrary tree could not promise.
+ * `null` when no wired filter holds a value.
+ */
+export declare function panelFilterTree(config: DashboardViewConfig, filters: DashboardFilters, bindings: readonly PanelBinding[], kinds: FieldKindRegistry): FilterTree | null;
+/**
+ * The control a filter's value is edited with (D22 F: the condition editor's
+ * value controls, never new ones): a date filter the date control its kind
+ * asks for, a yes-or-no the yes/no select, an id filter ids from the host's
+ * source or its list; a text or number filter with a list of its own the
+ * select over it, as over the list its wired fields declare (`wired`, an
+ * enum's options); otherwise text picked from the wired fields' values or a
+ * number — one value or several as the filter
+ * takes. A search filter, and one of a kind outside the six, gets what its
+ * kind asks for: a search the text it looks for, one line.
+ */
+export declare function filterEditor(field: DashboardField, value: FilterValue | undefined, kinds: FieldKindRegistry, wired?: readonly FieldOption[] | null): EditorDescriptor;
+/**
+ * A stored value as its control holds it: a filter that takes one value is
+ * stored as a one-entry list (`IN`, so it reaches any field of its type) and
+ * edited as that one value; a blank one starts at what its control starts
+ * at. Only a text, id or number filter is stored as a list.
+ */
+export declare function filterControlValue(field: DashboardField, stored: FilterValue | undefined): FilterValue;
+/**
+ * What a control handed back is stored as — the mirror of
+ * `filterControlValue` — or `null` for nothing picked. A filter that takes
+ * one value keeps the last one picked.
+ */
+export declare function filterStoredValue(field: DashboardField, control: FilterValue, kinds: FieldKindRegistry): FilterValue | null;
+//# sourceMappingURL=filters.d.ts.map

package/dist/dashboard/filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filters.d.ts","sourceRoot":"","sources":["../../src/dashboard/filters.ts"],"names":[],"mappings":"AAaA;;;;;GAKG;AAEH,OAAO,EAEL,KAAK,cAAc,EAEnB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EAExB,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,aAAa,EACnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAML,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACvB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB;;;;;;;CAOmC,CAAC;AAErE;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,EACnC,KAAK,EAAE,iBAAiB,GACvB,kBAAkB,CAIpB;AAED,gFAAgF;AAChF,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAWT;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,WAAW,GAAG,SAAS,EAC9B,KAAK,EAAE,iBAAiB,GACvB,UAAU,GAAG,IAAI,CAQnB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,mBAAmB,GAAG,gBAAgB,CAM5E;AAED,2EAA2E;AAC3E,wBAAgB,SAAS,CAAC,MAAM,EAAE,mBAAmB,GAAG,cAAc,EAAE,CAQvE;AAED;;;;GAIG;AACH;;;;GAIG;AACH,eAAO,MAAM,eAAe,uDAIlB,CAAC;AAKX;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAWzD;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,iBAAiB,EACxB,IAAI,EAAE,SAAS,EACf,MAAM,CAAC,EAAE,aAAa,GACrB,KAAK,EAAE,CAeT;AASD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,mBAAmB,EAC3B,MAAM,EAAE,gBAAgB,GAAG,IAAI,GAAG,SAAS,EAC3C,KAAK,EAAE,iBAAiB,GACvB;IAAE,OAAO,EAAE,gBAAgB,CAAC;IAAC,OAAO,EAAE,KAAK,EAAE,CAAA;CAAE,CAuCjD;AAkCD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,SAAS,YAAY,EAAE,EACjC,KAAK,EAAE,iBAAiB,GACvB,UAAU,GAAG,IAAI,CAiBnB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,WAAW,GAAG,SAAS,EAC9B,KAAK,EAAE,iBAAiB,EACxB,KAAK,GAAE,SAAS,WAAW,EAAE,GAAG,IAAW,GAC1C,gBAAgB,CAuBlB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,WAAW,CAMb;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,iBAAiB,GACvB,WAAW,GAAG,IAAI,CAYpB"}

package/dist/dashboard/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The dashboard kernel: admission, panel binding resolution and the global
+ * filter merge.
+ *
+ * It owns no data of its own. A dashboard composes instances of the other two
+ * kinds, so what this layer decides is whether a composition holds together —
+ * the references exist, they are visible where the dashboard is, and the
+ * global filter maps onto every one of them without losing its meaning.
+ */
+export * from './click.js';
+export * from './clickDraft.js';
+export * from './declared.js';
+export * from './defaults.js';
+export * from './edit.js';
+export * from './filterEdit.js';
+export * from './filters.js';
+export * from './layout.js';
+export * from './merge.js';
+export * from './migrate.js';
+export * from './panels.js';
+export * from './tabs.js';
+export * from './timeBindings.js';
+export * from './validate.js';
+export * from './validateFilters.js';
+export * from './wiring.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dashboard/index.ts"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AACH,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,aAAa,CAAC"}

package/dist/dashboard/layout.d.ts

@@ -0,0 +1,184 @@
+import { DashboardViewConfig, PanelLayout } from '../model/index.js';
+/** One keyboard command: a step of one grid cell, or a size one cell bigger or smaller. */
+export type ArrangeStep = 'left' | 'right' | 'up' | 'down' | 'wider' | 'narrower' | 'taller' | 'shorter';
+/**
+ * Whether a layout is one admission accepts: `x` and `y` non-negative
+ * integers, `w` and `h` positive ones, and `x + w` inside the grid. The
+ * same rule `validateDashboard` reports against, so nothing placed here can
+ * come back from it as an error.
+ */
+export declare function fitsGrid(layout: unknown, columns?: number): layout is PanelLayout;
+/** A panel's geometry under its id: what `placePanel` reads and returns. */
+export interface PlacedPanel extends PanelLayout {
+    id: string;
+}
+/** Whether two boxes share at least one cell. */
+export declare function overlaps(a: PanelLayout, b: PanelLayout): boolean;
+/** The first row below every panel: where a board ends. */
+export declare function bottomOf(panels: readonly PanelLayout[]): number;
+/**
+ * The panels floated up: each, in reading order, rises as far as it can
+ * without touching one already settled, and one that overlaps a settled
+ * panel (a stored config may hold two on one cell) drops below it instead.
+ * No panel passes another on the way up, so the order a reader sees down a
+ * column is kept; only the holes go.
+ */
+export declare function compactLayout(panels: readonly PlacedPanel[]): PlacedPanel[];
+/**
+ * The panels after one of them is put at `layout`, or `null` when the
+ * placement is not one the grid admits or names no panel.
+ *
+ * The panel placed is held at the cells it asked for while the others are
+ * compacted around it, in their reading order: one it covers drops below it,
+ * one it has moved out from under rises into the room it left. Then it is
+ * let go, and the whole tab is compacted — the panel placed rises too, until
+ * something is above it. So a panel dropped past the one under it trades
+ * places with it, and one dropped into empty space below the rest comes up
+ * to rest under them.
+ */
+export declare function placePanel(panels: readonly PlacedPanel[], id: string, layout: PanelLayout, columns?: number): PlacedPanel[] | null;
+/**
+ * Where one keyboard command puts the panel, as the layout to hand `place`,
+ * or `null` when it would change nothing the reader could see.
+ *
+ * Sideways and in size, one command is one cell, as a drag snaps to one.
+ * Up and down are what a compacted board makes of them: a panel stepped one
+ * row down into the one under it floats straight back, so "down" is the
+ * smallest drop that lands it somewhere else — past the panel below — and
+ * the bottom panel of a column has nowhere to go down. Up is the same the
+ * other way. A step off the grid is `null` as well, so a menu disables it
+ * rather than offering a command that does nothing.
+ */
+export declare function arrangePanel(panels: readonly PlacedPanel[], id: string, step: ArrangeStep, columns?: number): PanelLayout | null;
+/**
+ * The first place a new panel of this size can go: free, at rest (the
+ * compaction a later placement runs would not lift it), and at or below
+ * `fromRow` — the first row the reader has on screen, so what they add
+ * lands where they are looking (D22 A). Rows top to bottom, each left to
+ * right. When nothing down to the board's end will take it, it goes under
+ * everything and rises to rest there.
+ */
+export declare function freeSpot(panels: readonly PanelLayout[], size: {
+    w: number;
+    h: number;
+}, columns?: number, fromRow?: number): PanelLayout;
+/**
+ * A config with one panel placed and the rest of its tab compacted around
+ * it, or the same config when the placement changes nothing or cannot be
+ * made.
+ *
+ * Only the panel's own tab moves: another tab is another grid, whose
+ * panels share no cell with these whatever their numbers say. Read as the
+ * untrusted thing a stored config is: an entry that is no panel, or a panel
+ * whose layout admission would refuse, takes no part — it is not moved and
+ * moves nothing — and is handed back untouched.
+ *
+ * `grown` is the rows each panel is drawn tall where the screen grew it
+ * past what is saved (`grownLayout`, D52): a hand places against the board
+ * it sees, so the placement lands on the tab as drawn. What is written back
+ * is only what the hand moved (D68): the panel placed, and where another
+ * panel had to go — the row it is saved at, chosen so that the board grown
+ * again draws it where the author saw it. No untouched panel's saved height
+ * changes, since a grown height is one day's data, not a size anyone chose;
+ * and a panel only moved keeps its saved height too. A placement that moves
+ * nothing hands the same config back. A `layout` that says `fixedHeight`
+ * marks the panel sized by hand; one that does not say keeps what the panel
+ * had, as every other panel does.
+ */
+export declare function placePanelIn(config: DashboardViewConfig, id: string, layout: PanelLayout, columns?: number, grown?: ReadonlyMap<string, number>): DashboardViewConfig;
+/**
+ * A config with these boxes written into the panels they name, or the same
+ * config when none of them moves. A panel no box names, or whose stored
+ * layout is not one the grid admits, is left as it is. A box that says
+ * `fixedHeight` sets it; one that does not keeps the panel's own (D68).
+ */
+export declare function withLayouts(config: DashboardViewConfig, boxes: readonly PlacedPanel[], columns?: number): DashboardViewConfig;
+/**
+ * The panels in reading order: rows top to bottom, each left to right — the
+ * order a reader counts them in and the grid draws them in, whatever order
+ * the config lists them. Stable, so two panels an author stacked on the same
+ * cell keep the order they were saved in.
+ */
+export declare function readingOrder<T extends {
+    layout: PanelLayout;
+}>(panels: readonly T[]): T[];
+/** How many columns the narrow reading lays panels in: a pair of cards shares a row. */
+export declare const STACKED_COLUMNS = 2;
+/**
+ * The layout read as one column, for a screen too narrow for the grid: each
+ * panel the full width of the column and as tall as it was saved, stacked
+ * in reading order — except that two cards next to each other in reading
+ * order (`paired`, the metric cards) share a row, half the width each, as
+ * tall as the taller of them. A card is a number and a few words; a phone
+ * stacking eleven of them one per screen-wide row, each at its desktop
+ * height, made the reader scroll past a screen of white for every two
+ * figures. A card with no card after it takes the row alone.
+ *
+ * A panel sized by hand keeps its mark (`fixedHeight`, D68), so the
+ * narrow reading draws it at the height its author set, as the wide one
+ * does, rather than growing it back.
+ *
+ * The column is `STACKED_COLUMNS` wide. A reading of the layout, not a
+ * placement — it is never handed to `place`, because nothing in it maps
+ * back to the wide layout the config holds.
+ */
+export declare function stackedLayout(panels: readonly PlacedPanel[], paired?: (id: string) => boolean): PlacedPanel[];
+/**
+ * The layout read with some panels taller than saved (`heights`, rows by
+ * panel id): each grows to the height asked for, never shorter than it was
+ * saved, and whatever stood under it moves down with it. A panel is read
+ * as resting on the panels above it: it keeps the rows it had under the
+ * lowest of them (its nearest blocker), below the lowest of them as grown
+ * — so every panel under a grown one still reads where the author put it
+ * relative to what it sat on, and a saved row the placement writes back
+ * (`placePanelIn`) always reads as the row it was let go at (D68). Nothing
+ * rises, nothing moves sideways, and two panels a stored config put on
+ * one cell stay on it: only a panel that was clear of another is kept
+ * clear of it. With nothing grown it is the layout as saved.
+ *
+ * A reading, like `stackedLayout`, never a placement: a table panel shown
+ * whole while the board is read (P1-3) is not a layout its author chose,
+ * and nothing hands it to `place`.
+ */
+export declare function grownLayout(panels: readonly PlacedPanel[], heights: ReadonlyMap<string, number>): PlacedPanel[];
+/** One step along the one-column reading: before the panel read before it, or after the one read after it. */
+export type OrderStep = 'up' | 'down';
+/**
+ * The panels after one of them trades places with its neighbour in reading
+ * order — the one-column reading's 「上移」／「下移」 (D22 J) written back
+ * onto the grid — or `null` when there is no neighbour that way, or no such
+ * panel.
+ *
+ * The column is a reading of the layout, so a move in it has to come out as
+ * a layout that reads that way: the panel one place further along, and as
+ * near as can be every other panel where it was. The candidates are the two
+ * at each other's corner (two panels of one size side by side swap and
+ * nothing else moves), then every place either could be put by hand
+ * (`placePanel`) — moving one up past the other is moving the other down
+ * past it. Each is compacted, as every placement by hand is, so what comes
+ * back is at rest; and compacting can carry a third panel into the room one
+ * of the two left, which on a board whose columns do not line up puts it on
+ * the other side of them. So among the candidates that land the panel where
+ * it was asked to go, the one wins that reads least out of the order asked
+ * for (pairs of panels the other way round), then moves fewest other panels,
+ * then changes fewest rows, then moves them least far — on a board of plain
+ * rows that is the order asked for exactly. Where no candidate lands it
+ * there at all (a board whose rows interlock), the panels are stacked down
+ * the first column in the order asked for: the one layout that always reads
+ * right, at the cost of the board's columns.
+ */
+export declare function reorderPanel(panels: readonly PlacedPanel[], id: string, step: OrderStep, columns?: number): PlacedPanel[] | null;
+/**
+ * A config with one panel moved to place `to` (from 0) along the reading
+ * order of its tab, or the same config when it is already there or `to` is
+ * no place on the tab. The one-column reading carries a panel by a handle
+ * (D22 J): a drop names any place, an arrow key or the handle's menu one
+ * place along or either end. It gets there one place at a time
+ * (`reorderPanel`), each step the layout that reads that way and disturbs
+ * the rest least, so a move of several places is the steps it passes
+ * through — never a jump the grid could not have taken one place at a
+ * time. Read as untrusted like `placePanelIn`: an entry that is no panel,
+ * or whose layout admission would refuse, takes no part.
+ */
+export declare function reorderPanelIn(config: DashboardViewConfig, id: string, to: number, columns?: number): DashboardViewConfig;
+//# sourceMappingURL=layout.d.ts.map

package/dist/dashboard/layout.d.ts.map

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

package/dist/dashboard/merge.d.ts

@@ -0,0 +1,32 @@
+import { DashboardViewConfig, FilterTree, PanelBinding } from '../model/index.js';
+/**
+ * The condition every data panel of a board runs under before its filters,
+ * in the board's own field names: its fixed scope (`fixed`, D26 Q31) — the
+ * board's only condition of its own, since a board has no `filter` (D27).
+ * A fixed scope that is no tree adds nothing: admission reports it
+ * (`config.filter.invalid` at `fixed`).
+ */
+export declare function boardCondition(config: DashboardViewConfig): FilterTree;
+/**
+ * Rewrites a dashboard's global filter onto one panel's fields.
+ *
+ * The tree keeps its shape and every leaf keeps its operator and value: only
+ * the field name changes. That is what makes the mapping boolean-preserving,
+ * and it is why `validateDashboard` insists a panel bind *every* field the
+ * tree mentions — dropping one branch of an OR would silently narrow the
+ * condition, and treating it as true would erase it.
+ *
+ * The tree must have been admitted first: its depth is bounded by
+ * `RuntimeLimits.maxFilterDepth`, so the walk below cannot run away.
+ */
+export declare function mapGlobalFilter(tree: FilterTree, bindings: readonly PanelBinding[]): FilterTree;
+/**
+ * The panel's own applied filter ANDed with the mapped global filter.
+ *
+ * A dashboard's condition never reaches the referenced instance's draft or
+ * saved config; it is an outer scope, which is why the runtime injects the
+ * mapped tree through `setScopeFilter` and this function exists for admission,
+ * where the merged tree is what the budget and the panel's definition judge.
+ */
+export declare function mergeGlobalFilter(panelFilter: FilterTree, dashboardFilter: FilterTree, bindings: readonly PanelBinding[]): FilterTree;
+//# sourceMappingURL=merge.d.ts.map

package/dist/dashboard/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/dashboard/merge.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,mBAAmB,EAEnB,UAAU,EACV,YAAY,EACb,MAAM,mBAAmB,CAAC;AAG3B;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,mBAAmB,GAAG,UAAU,CAEtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,SAAS,YAAY,EAAE,GAChC,UAAU,CAKZ;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,UAAU,EACvB,eAAe,EAAE,UAAU,EAC3B,QAAQ,EAAE,SAAS,YAAY,EAAE,GAChC,UAAU,CAEZ"}

package/dist/dashboard/migrate.d.ts

@@ -0,0 +1,33 @@
+import { DashboardViewConfig } from '../model/index.js';
+/**
+ * A stored config read into the form this engine writes: onto the 24-column
+ * grid (D22 E), a pre-C board condition into its filters' defaults and the
+ * board's fixed scope (D23 Q16, D26 Q31; `intoDefaults` below), and the
+ * board's own condition, which a board no longer has, out of the config
+ * (D27; `withoutOwnCondition` below), and a board stored before its time
+ * wires were derived read with its unwired panels reading whole (D1;
+ * `withTimeIgnored`, `timeBindings.ts`). Each step is marked by the config
+ * itself — `columns`, `fixed`, the `filter` member, `derivesTime` — so it
+ * happens once: a second read, or a read after any edit, leaves the config
+ * alone.
+ *
+ * A config that does not say which grid it is in (`columns`) was written for
+ * the twelve-column grid: every `x` and `w` is doubled and every `y` and `h`
+ * kept, which puts each panel on exactly the pixels it had — a column of the
+ * new grid and the gap after it are half of one of the old, so a panel
+ * twice as many columns wide spans the same width. It gains `columns` and an
+ * empty `tabs`, so a save writes the new form and the next read leaves it
+ * alone.
+ *
+ * A config that says anything about `columns` is not guessed at: one naming
+ * another grid is left for admission to refuse (`dashboard.grid.unsupported`).
+ * A config already in this form comes back as it is (the same object, so
+ * nothing downstream sees a change). Nothing here throws on a malformed
+ * config either — whatever is not a panel with numbers, or a tree, is
+ * carried over untouched and reported where admission reports it.
+ *
+ * It is called at one place, the engine's read boundary (`readStored`,
+ * `runtime/storedViews.ts`), so everything else reads the new form only.
+ */
+export declare function migrateDashboardConfig(config: DashboardViewConfig): DashboardViewConfig;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/dashboard/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../../src/dashboard/migrate.ts"],"names":[],"mappings":"AAcA,OAAO,EAKL,KAAK,mBAAmB,EAGzB,MAAM,mBAAmB,CAAC;AAW3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,mBAAmB,GAC1B,mBAAmB,CAIrB"}

package/dist/dashboard/panelFieldNames.d.ts

@@ -0,0 +1,20 @@
+import { AnalysisViewConfig, DashboardViewConfig, DashboardViewPanel } from '../model/index.js';
+/** Each field a panel's definition names by an alias, by that alias. */
+export type PanelRenames = (panel: DashboardViewPanel) => Readonly<Record<string, string>> | null | undefined;
+/** A view the board owns, read under the paths `renamed` maps to. */
+export type OwnedViewRename = (config: AnalysisViewConfig, renamed: Readonly<Record<string, string>>) => AnalysisViewConfig;
+/**
+ * The board with every name it gives a data panel's field renamed to the
+ * path the panel's definition renames it to (#3519): a binding's
+ * `panelField`, a dimension another board's filter takes its value from,
+ * a `{{field}}` of a page click, and the view the panel owns. The board
+ * then agrees with the fields its panels run on — a filter wired by an
+ * alias still narrows its panel — and is saved under the paths next time.
+ *
+ * `renamedOf` says what a panel's definition renamed, `null` while it is
+ * not known. A stored config is untrusted: what is not the shape it names
+ * is left as it is, for admission to report. Returns the config itself
+ * when nothing is renamed.
+ */
+export declare function withCanonicalPanelFields(config: DashboardViewConfig, renamedOf: PanelRenames, ownedView: OwnedViewRename): DashboardViewConfig;
+//# sourceMappingURL=panelFieldNames.d.ts.map

package/dist/dashboard/panelFieldNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panelFieldNames.d.ts","sourceRoot":"","sources":["../../src/dashboard/panelFieldNames.ts"],"names":[],"mappings":"AAmBA,OAAO,EAEL,KAAK,kBAAkB,EAEvB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACxB,MAAM,mBAAmB,CAAC;AAK3B,wEAAwE;AACxE,MAAM,MAAM,YAAY,GAAG,CACzB,KAAK,EAAE,kBAAkB,KACtB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;AAEzD,qEAAqE;AACrE,MAAM,MAAM,eAAe,GAAG,CAC5B,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KACtC,kBAAkB,CAAC;AAExB;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,mBAAmB,EAC3B,SAAS,EAAE,YAAY,EACvB,SAAS,EAAE,eAAe,GACzB,mBAAmB,CAWrB"}

package/dist/dashboard/panelLook.d.ts

@@ -0,0 +1,18 @@
+import { DashboardViewPanel, Issue, IssuePath, ViewDefinition } from '../model/index.js';
+import { DefinitionLookup } from './declared.js';
+/**
+ * An override of how the panel looks (D22 D). Only its shape is this
+ * kernel's to judge: whether a chart fits the view's result is the analysis
+ * kernel's, and the runtime asks it — an override that does not fit is
+ * dropped there with the same note, never refused (`presentation.ts`).
+ */
+export declare function validatePresentation(panel: DashboardViewPanel, path: IssuePath): Issue[];
+/**
+ * The view 「在工作台中打开」 opens in the panel's stead: an id, which the
+ * workbench resolves when it opens. Anything else is let go with a warning,
+ * and the panel's own view opens.
+ */
+export declare function validateOpens(panel: DashboardViewPanel, path: IssuePath, view?: {
+    definition: ViewDefinition;
+} | null, lookup?: DefinitionLookup): Issue[];
+//# sourceMappingURL=panelLook.d.ts.map

package/dist/dashboard/panelLook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panelLook.d.ts","sourceRoot":"","sources":["../../src/dashboard/panelLook.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,kBAAkB,EAClB,KAAK,EACL,SAAS,EACT,cAAc,EACf,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAgB,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAMpE;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,kBAAkB,EACzB,IAAI,EAAE,SAAS,GACd,KAAK,EAAE,CAgBT;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,kBAAkB,EACzB,IAAI,EAAE,SAAS,EACf,IAAI,GAAE;IAAE,UAAU,EAAE,cAAc,CAAA;CAAE,GAAG,IAAW,EAClD,MAAM,CAAC,EAAE,gBAAgB,GACxB,KAAK,EAAE,CAiCT"}

package/dist/dashboard/panels.d.ts

@@ -0,0 +1,78 @@
+import { DashboardContentPanel, DashboardPanel, DashboardTab, DashboardViewConfig, DashboardViewPanel, OwnedView, PanelBinding, PanelClick, PanelPresentation } from '../model/index.js';
+/**
+ * The panels a config holds, read as the untrusted thing a stored config is.
+ * Admission reports a `panels` that is not an array; until it is fixed there
+ * is nothing to load, run or place, and nothing to throw about. An entry is
+ * still untrusted: each reader asks `isPlainObject` or `isViewPanel` of it.
+ */
+export declare function panelsOf(config: Pick<DashboardViewConfig, 'panels'>): readonly DashboardPanel[];
+/**
+ * The well-formed tabs of a stored config, in the order of its bar:
+ * admission reports the rest (`validateTabs`), and a bar or a menu naming
+ * tabs must not be the second place to find out.
+ */
+export declare function tabsOf(config: Pick<DashboardViewConfig, 'tabs'>): readonly DashboardTab[];
+/** Whether a key is one a panel's override of how it looks may set. */
+export declare function isPresentationMember(key: string): key is keyof PanelPresentation;
+/**
+ * The members a data panel's override of how it looks sets (D22 D), read as
+ * untrusted: none for a content panel, an override that is no object, or
+ * one that names only what no view has. Whether they fit its view is the
+ * runtime's to find out (`presentedConfig`).
+ */
+export declare function presentationMembersOf(panel: unknown): (keyof PanelPresentation)[];
+/**
+ * A panel backed by a referenced instance, and so by a child runtime.
+ * Total over `unknown`: a stored config may hold a panel that is no object,
+ * and the runtime asks this before admission has had its say.
+ */
+export declare function isViewPanel(panel: unknown): panel is DashboardViewPanel;
+/** A static panel: no query, no global filter, no child runtime. */
+export declare function isContentPanel(panel: unknown): panel is DashboardContentPanel;
+/**
+ * A data panel showing a view the board owns (`owned`) rather than a saved
+ * one. Read by the member alone — admission is what says a panel holding
+ * both, or neither, is wrong (`dashboard.panel.source-invalid`).
+ */
+export declare function isOwnedPanel(panel: unknown): panel is DashboardViewPanel & {
+    owned: OwnedView;
+};
+/** A panel's bindings, read as the untrusted thing a stored config is. */
+export declare function bindingsOf(panel: DashboardViewPanel): PanelBinding[];
+/**
+ * A panel's click as stored, or `null` for the follow-up menu: none set, or
+ * one this reading cannot make out — admission says which
+ * (`validatePanelClick`), and a press falls back to the menu meanwhile.
+ */
+export declare function clickOf(panel: unknown): PanelClick | null;
+/** Whether a click sets this filter: what unwiring the filter takes with it. */
+export declare function clicksFilter(panel: unknown, name: string): boolean;
+/**
+ * The saved view a data panel points at, or `undefined` for one the board
+ * owns or one whose `instanceId` is no string.
+ */
+export declare function referencedInstance(panel: unknown): string | undefined;
+/**
+ * The first `{prefix}-{n}` not among `taken`, counting from one. Ids are
+ * keys inside one config and never shown, so a plain counter is enough, and
+ * it keeps every edit a pure function of the config it edits.
+ */
+export declare function freshId(taken: Iterable<unknown>, prefix: string): string;
+/**
+ * The tab a panel is read as sitting on: its own when the board has that
+ * tab, the first otherwise, and `null` on a board without tabs. Admission
+ * reports a panel that names no tab of the board (`dashboard.panel.tab-unknown`);
+ * until it is fixed the panel is shown on the first rather than nowhere.
+ */
+export declare function panelTab(config: Pick<DashboardViewConfig, 'tabs'>, panel: Pick<DashboardPanel, 'tab'>): string | null;
+/**
+ * Whether a content panel's URL may be rendered.
+ *
+ * Only http, https, mailto and relative paths pass. A scheme-relative URL is
+ * refused along with the rest: it inherits the host page's scheme, so it is
+ * neither a checked absolute URL nor a path inside the application. A URL
+ * being well-formed says nothing about the resource behind it, which is why
+ * the UI layer still renders images and links defensively.
+ */
+export declare function isSafeContentUrl(raw: string): boolean;
+//# sourceMappingURL=panels.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panels.d.ts","sourceRoot":"","sources":["../../src/dashboard/panels.ts"],"names":[],"mappings":"AAaA,OAAO,EAGL,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,iBAAiB,EACvB,MAAM,mBAAmB,CAAC;AAG3B;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,IAAI,CAAC,mBAAmB,EAAE,QAAQ,CAAC,GAC1C,SAAS,cAAc,EAAE,CAG3B;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CACpB,MAAM,EAAE,IAAI,CAAC,mBAAmB,EAAE,MAAM,CAAC,GACxC,SAAS,YAAY,EAAE,CASzB;AAED,uEAAuE;AACvE,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,MAAM,GACV,GAAG,IAAI,MAAM,iBAAiB,CAEhC;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,GACb,CAAC,MAAM,iBAAiB,CAAC,EAAE,CAM7B;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAEvE;AAED,oEAAoE;AACpE,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,qBAAqB,CAE7E;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,kBAAkB,GAAG;IAAE,KAAK,EAAE,SAAS,CAAA;CAAE,CAEpD;AAED,0EAA0E;AAC1E,wBAAgB,UAAU,CAAC,KAAK,EAAE,kBAAkB,GAAG,YAAY,EAAE,CAUpE;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,IAAI,CA4CzD;AAWD,gFAAgF;AAChF,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAGlE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAMrE;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAKxE;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,IAAI,CAAC,mBAAmB,EAAE,MAAM,CAAC,EACzC,KAAK,EAAE,IAAI,CAAC,cAAc,EAAE,KAAK,CAAC,GACjC,MAAM,GAAG,IAAI,CASf;AAaD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAQrD"}

package/dist/dashboard/placeholders.d.ts

@@ -0,0 +1,3 @@
+/** `{{ name }}`, spaces inside the braces allowed; the name has none. */
+export declare const URL_PLACEHOLDER: RegExp;
+//# sourceMappingURL=placeholders.d.ts.map

package/dist/dashboard/placeholders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placeholders.d.ts","sourceRoot":"","sources":["../../src/dashboard/placeholders.ts"],"names":[],"mappings":"AAmBA,yEAAyE;AACzE,eAAO,MAAM,eAAe,QAA8B,CAAC"}

package/dist/dashboard/tabs.d.ts

@@ -0,0 +1,28 @@
+import { DashboardTab, DashboardViewConfig, Issue } from '../model/index.js';
+/**
+ * The tabs as admission reads them. An id is how a panel names its tab, so
+ * one that is missing or said twice is an error of the board; a blank title
+ * only leaves the tab to be called by its place, so it is a warning.
+ */
+export declare function validateTabs(tabs: readonly DashboardTab[]): Issue[];
+/**
+ * A board with one more tab, last, and that tab's id — or `null` when the
+ * title is blank or the board holds as many tabs as it may. On a board
+ * without tabs the panels it has go onto a first tab called `firstTitle`,
+ * and the new one is the second.
+ */
+export declare function addTab(config: DashboardViewConfig, title: string, firstTitle: string): {
+    config: DashboardViewConfig;
+    id: string;
+} | null;
+/** A tab renamed; the same board for a blank title or a tab it lacks. */
+export declare function renameTab(config: DashboardViewConfig, id: string, title: string): DashboardViewConfig;
+/** A tab moved to `index` in the bar (clamped to it); the same board when it stays. */
+export declare function moveTab(config: DashboardViewConfig, id: string, index: number): DashboardViewConfig;
+/**
+ * A board without one of its tabs and the panels on it; the same board for
+ * a tab it lacks or its last tab. A UI asks first when the tab holds panels
+ * (D22 E); this is what happens once it has.
+ */
+export declare function removeTab(config: DashboardViewConfig, id: string): DashboardViewConfig;
+//# sourceMappingURL=tabs.d.ts.map

package/dist/dashboard/tabs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabs.d.ts","sourceRoot":"","sources":["../../src/dashboard/tabs.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;GAWG;AAEH,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,KAAK,EAEX,MAAM,mBAAmB,CAAC;AAI3B;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,YAAY,EAAE,GAAG,KAAK,EAAE,CA4BnE;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CACpB,MAAM,EAAE,mBAAmB,EAC3B,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,GACjB;IAAE,MAAM,EAAE,mBAAmB,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA4BpD;AAED,yEAAyE;AACzE,wBAAgB,SAAS,CACvB,MAAM,EAAE,mBAAmB,EAC3B,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,GACZ,mBAAmB,CAQrB;AAED,uFAAuF;AACvF,wBAAgB,OAAO,CACrB,MAAM,EAAE,mBAAmB,EAC3B,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,GACZ,mBAAmB,CASrB;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,mBAAmB,EAC3B,EAAE,EAAE,MAAM,GACT,mBAAmB,CAUrB"}

package/dist/dashboard/timeBindings.d.ts

@@ -0,0 +1,42 @@
+import { DashboardField, DashboardViewConfig, DashboardViewPanel, FieldDefinition } from '../model/index.js';
+/**
+ * The board's time filter: its one date filter. A board with two — when an
+ * order was placed, when it shipped — has no one range to read every panel
+ * in, so none is wired on its own there.
+ */
+export declare function timeFilterOf(config: DashboardViewConfig): DashboardField | null;
+/** Whether a filter is one of dates. */
+export declare function isDateFilter(filter: DashboardField | undefined): boolean;
+/**
+ * What a panel's view says of time: the field its records happen at,
+ * `null` for a view read whole, `undefined` where it says nothing — a view
+ * not known yet, or a definition that declares no time field, whose wires
+ * are all the author's.
+ */
+export type PanelTime = (panel: DashboardViewPanel) => FieldDefinition | null | undefined;
+/**
+ * The board with its time filter wired to every data panel it reaches on
+ * its own through `timeOf` (`auto` and `derived`), and every wire derived
+ * before that no longer follows taken off: one whose view says otherwise
+ * now or is not known, one on a panel that reads whole, and every one while
+ * the board has no single date filter. A wire auto-connect made is the
+ * author's and is never touched. Without the storage marker; itself when
+ * nothing changes — a panel whose wires come out as they were is the same
+ * panel.
+ */
+export declare function withTimeBindings(config: DashboardViewConfig, timeOf: PanelTime): DashboardViewConfig;
+/**
+ * The board as it is stored: every wire derived from a view taken off —
+ * it is made again when read — and the marker that says so.
+ */
+export declare function storedTimeWires(config: DashboardViewConfig): DashboardViewConfig;
+/**
+ * A board stored before its time wires were derived, read as it was then
+ * (D1): unmarked, so each panel over data not wired to every one of its
+ * date filters reads whole (`ignoresTime`) — nothing wires it on its own,
+ * whichever of those filters is left the board's one. Its wires are the
+ * author's, auto-connected ones included, and stay. Marked, so it happens
+ * once; a marked board as it is.
+ */
+export declare function withTimeIgnored(config: DashboardViewConfig): DashboardViewConfig;
+//# sourceMappingURL=timeBindings.d.ts.map

package/dist/dashboard/timeBindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeBindings.d.ts","sourceRoot":"","sources":["../../src/dashboard/timeBindings.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAGL,KAAK,cAAc,EAEnB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EAErB,MAAM,mBAAmB,CAAC;AAK3B;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,mBAAmB,GAC1B,cAAc,GAAG,IAAI,CAGvB;AAED,wCAAwC;AACxC,wBAAgB,YAAY,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,GAAG,OAAO,CAExE;AAMD;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,CACtB,KAAK,EAAE,kBAAkB,KACtB,eAAe,GAAG,IAAI,GAAG,SAAS,CAAC;AAExC;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,mBAAmB,EAC3B,MAAM,EAAE,SAAS,GAChB,mBAAmB,CAkCrB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,mBAAmB,GAC1B,mBAAmB,CAUrB;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,mBAAmB,GAC1B,mBAAmB,CAgBrB"}