@overvis/hmi-workspace-ui 0.0.0-stage → 0.1.1

package/dist/src/workspace/dashboards/document/tiles/controls.d.ts

@@ -0,0 +1,23 @@
+import { type AppLocale } from "@overvis/hmi-shared";
+import type { DocumentControl, DocumentControlsTile, DocumentTile } from "@overvis/hmi-shared/document";
+import type { ParameterControl } from "@overvis/hmi-shared/parameter";
+import { type TileContext } from "./context.js";
+/**
+ * What a control writes: its setpoint, or its command's steps. A control keyed by it stays
+ * mounted, with a write under way, while only its name or look changes.
+ */
+export declare function controlBinding(control: DocumentControl): string;
+/** What a tile reads and writes, for keying it like {@link controlBinding}. */
+export declare function tileBinding(tile: DocumentTile): string;
+/** A document's control as a parameter control, in the UI language. */
+export declare function parameterControl(control: DocumentControl, key: string, locale: AppLocale): ParameterControl;
+/**
+ * An optional status value and one to four shared controls: commands write their steps in order
+ * after confirmation and stay highlighted while their feedback holds; setpoints open a value
+ * editor. View-only members see them disabled.
+ */
+export declare function ControlsTileView({ id, tile, context, }: {
+    id: string;
+    tile: DocumentControlsTile;
+    context: TileContext;
+}): import("react").JSX.Element;

package/dist/src/workspace/dashboards/document/tiles/frame.d.ts

@@ -0,0 +1,28 @@
+import type { ReactNode } from "react";
+import type { DocumentTileSize, DocumentTone } from "@overvis/hmi-shared/document";
+import type { ParameterValueState } from "../../../parameters/live/model.js";
+/**
+ * The card every tile is drawn in. A tile that opens (`onOpen`) does so through a button stretched
+ * under its content; controls inside it stay their own buttons. `label` is the card's accessible
+ * name, with the value and the tone's text; a reading that is not current is said so, as the
+ * drawn stale marker is hidden.
+ */
+export declare function TileFrame({ parameterId, size, tone, toneText, stale, name, label, state, onOpen, footer, children, className, }: {
+    parameterId: string | null;
+    size: DocumentTileSize;
+    tone: DocumentTone;
+    toneText: string | null;
+    stale: boolean;
+    name: string;
+    label: string;
+    state?: ParameterValueState;
+    onOpen: (() => void) | null;
+    footer?: ReactNode;
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+/** Interactive content inside a tile, above the stretched open button. */
+export declare function TileInteractive({ children, className, }: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/src/workspace/dashboards/document/tiles/gauge-model.d.ts

@@ -0,0 +1,4 @@
+import type { DocumentGaugeTile } from "@overvis/hmi-shared/document";
+import type { NumberRange, ParameterValueType } from "@overvis/hmi-shared/parameter";
+/** The bar's ends: the tile's, else the parameter's zone `min` and `max`; null when unknown. */
+export declare function gaugeRange(tile: Pick<DocumentGaugeTile, "min" | "max">, valueType: ParameterValueType | null): NumberRange | null;

package/dist/src/workspace/dashboards/document/tiles/gauge.d.ts

@@ -0,0 +1,11 @@
+import type { DocumentGaugeTile } from "@overvis/hmi-shared/document";
+import { type TileContext } from "./context.js";
+/**
+ * A numeric value on a horizontal bar between the ends: a marker over the parameter's zone bands,
+ * or the bar filled up to the value.
+ */
+export declare function GaugeTileView({ id, tile, context, }: {
+    id: string;
+    tile: DocumentGaugeTile;
+    context: TileContext;
+}): import("react").JSX.Element;

package/dist/src/workspace/dashboards/document/tiles/presentation.d.ts

@@ -0,0 +1,29 @@
+import { type AppLocale, type LocalizedString } from "@overvis/hmi-shared";
+import type { DocumentDensity, DocumentTile, DocumentTileSize, DocumentTone } from "@overvis/hmi-shared/document";
+import type { ParameterValueState } from "../../../parameters/live/model.js";
+import type { ParameterMetadata, ParameterMetadataState } from "../../../parameters/metadata.js";
+import type { TileTone } from "./tones.js";
+/** Tile surface per tone, in light and dark themes; text on it keeps the theme's foreground. */
+export declare const toneSurface: Readonly<Record<DocumentTone, string>>;
+/** The tone's badge, always shown with text. */
+export declare const toneBadge: Readonly<Record<DocumentTone, string>>;
+export declare function toneName(tone: DocumentTone): string;
+/**
+ * The text that names a tile's tone: the rule's label, or the tone's name. Null only when no rule
+ * or zone matched; a rule that sets Neutral still names itself.
+ */
+export declare function toneText(tone: TileTone, locale: AppLocale): string | null;
+/** Grid cells per size; on a phone (two columns) wide and large tiles take the full width. */
+export declare const tileSpan: Readonly<Record<DocumentTileSize, string>>;
+export declare const gridClass: Readonly<Record<DocumentDensity, string>>;
+/** The tile's name: its own in the UI language, or its parameter's. */
+export declare function tileName(tile: DocumentTile, locale: AppLocale, parameter: ParameterMetadata | null): string;
+/** The unit shown with a value: the tile's (empty hides it), or the parameter's. */
+export declare function tileUnit(unit: LocalizedString | undefined, parameter: ParameterMetadata | null, locale: AppLocale): string;
+/**
+ * A value as text by its type: numbers with the tile's decimal places (or as the parameter
+ * formats them), labels in the UI language, date-times in the app format; "—" without a value.
+ */
+export declare function formatTileValue(state: ParameterValueState | undefined, locale: AppLocale, parameter: ParameterMetadata | null, decimals: number | undefined): string;
+/** The text a reading stands for in names and accessible labels. */
+export declare function readingText(state: ParameterValueState, meta: ParameterMetadataState, locale: AppLocale, unit: string, decimals: number | undefined): string;

package/dist/src/workspace/dashboards/document/tiles/reading.d.ts

@@ -0,0 +1,14 @@
+import type { AppLocale } from "@overvis/hmi-shared";
+import { type ParameterValueState } from "../../../parameters/live/model.js";
+import type { ParameterMetadataState } from "../../../parameters/metadata.js";
+/**
+ * A tile's value, sized by the tile (container queries): a skeleton while loading, "—" for an
+ * idle value, the unavailable or missing reason, never zero.
+ */
+export declare function TileReading({ state, meta, locale, unit, decimals, }: {
+    state: ParameterValueState;
+    meta: ParameterMetadataState;
+    locale: AppLocale;
+    unit: string;
+    decimals: number | undefined;
+}): import("react").JSX.Element;

package/dist/src/workspace/dashboards/document/tiles/sparkline.d.ts

@@ -0,0 +1,7 @@
+import type { StoredParameterSeries } from "../../../parameters/live/use-stored-history.js";
+/** The last 24 hours of stored averages, extended by the values read since the page opened. */
+export declare function TileSparkline({ parameterId, series, label, }: {
+    parameterId: string;
+    series: StoredParameterSeries;
+    label: string;
+}): import("react").JSX.Element;

package/dist/src/workspace/dashboards/document/tiles/tile.d.ts

@@ -0,0 +1,8 @@
+import type { DocumentTile } from "@overvis/hmi-shared/document";
+import type { TileContext } from "./context.js";
+/** One tile; `id` identifies it while the document is open, such as its JSON pointer. */
+export declare function TileView({ id, tile, context, }: {
+    id: string;
+    tile: DocumentTile;
+    context: TileContext;
+}): import("react").JSX.Element;

package/dist/src/workspace/dashboards/document/tiles/tones.d.ts

@@ -0,0 +1,44 @@
+import type { LocalizedString } from "@overvis/hmi-shared";
+import type { DocumentTileColors, DocumentTone } from "@overvis/hmi-shared/document";
+import { type ParameterDisplayZone, type ParameterValueType } from "@overvis/hmi-shared/parameter";
+import { type ParameterValueState } from "../../../parameters/live/model.js";
+/** The color of a tile and where it came from; `stale` dims the tone of an old value. */
+export interface TileTone {
+    tone: DocumentTone;
+    /** The matched rule's label; the tone's name is shown when null. */
+    label: LocalizedString | null;
+    source: {
+        kind: "rule";
+        rule: number;
+    } | {
+        kind: "zone";
+        zone: ParameterDisplayZone;
+    } | null;
+    stale: boolean;
+}
+export declare const neutralTone: TileTone;
+/**
+ * The tone of a value or gauge tile. Rules are checked in order and the first match wins; a rule
+ * without `parameterId` reads the tile's parameter, and one on another parameter matches only
+ * while that value is current. Then the parameter's zones apply, when on. Only current values are
+ * colored: a stale value keeps the tone of its last reading, dimmed, and a loading, failed or
+ * missing value is neutral.
+ */
+export declare function evaluateTileTone({ parameterId, colors, states, valueType, }: {
+    parameterId: string;
+    colors: DocumentTileColors;
+    states: ReadonlyMap<string, ParameterValueState>;
+    valueType: ParameterValueType | null;
+}): TileTone;
+/** The last current tone of each tile binding of one document, while it is open. */
+export interface ToneMemory {
+    get: (binding: string) => TileTone | undefined;
+    remember: (binding: string, tone: TileTone) => void;
+}
+/** A tone memory holding at most `limit` bindings; the least recently remembered go first. */
+export declare function createToneMemory(limit: number): ToneMemory;
+/**
+ * A stale tile keeps `last`, the tone it had while its value was current, dimmed; without one it
+ * keeps the tone of its stale reading.
+ */
+export declare function withLastTone(tone: TileTone, last: TileTone | null): TileTone;

package/dist/src/workspace/dashboards/document/tiles/use-tile-tone.d.ts

@@ -0,0 +1,19 @@
+import { type DocumentTileColors } from "@overvis/hmi-shared/document";
+import type { ParameterValueType } from "@overvis/hmi-shared/parameter";
+import type { ParameterValueState } from "../../../parameters/live/model.js";
+import { type TileTone, type ToneMemory } from "./tones.js";
+/** A document's memory of its tiles' last tones; the view keeps one while it is open. */
+export declare function createDocumentToneMemory(): ToneMemory;
+/**
+ * The tile's tone. While its value is current the tone is evaluated; once it goes stale the tile
+ * keeps the tone it last had while current, dimmed, also after it was shown on another page:
+ * `memory` is the document's. Without such a tone it falls back to the tone of its stale reading.
+ */
+export declare function useTileTone(input: {
+    tileId: string;
+    parameterId: string;
+    colors: DocumentTileColors;
+    states: ReadonlyMap<string, ParameterValueState>;
+    valueType: ParameterValueType | null;
+    memory: ToneMemory;
+}): TileTone;

package/dist/src/workspace/dashboards/document/tiles/value.d.ts

@@ -0,0 +1,8 @@
+import type { DocumentValueTile } from "@overvis/hmi-shared/document";
+import { type TileContext } from "./context.js";
+/** One value by its type, with an optional 24 h sparkline and an optional write button. */
+export declare function ValueTileView({ id, tile, context, }: {
+    id: string;
+    tile: DocumentValueTile;
+    context: TileContext;
+}): import("react").JSX.Element;

package/dist/src/workspace/dashboards/document/view.d.ts

@@ -0,0 +1,16 @@
+import { type AppLocale } from "@overvis/hmi-shared";
+export interface DocumentViewProps {
+    /** The document, such as a document dashboard's `configuration.document`. */
+    document: unknown;
+    workspaceId: string;
+    /** The dashboard showing it: its images are served for it, and parameter problems link to it. */
+    dashboardId: string;
+    locale: AppLocale;
+}
+/**
+ * Renders a document (`@overvis/hmi-shared/document`): its pages as dashboard subpages, rows of
+ * columns of blocks, inputs that set its variables, and values read from parameters, history,
+ * devices and the HMI API. Formulas are evaluated in the browser; a value not known yet, or one a
+ * broken formula cannot give, shows as "—".
+ */
+export declare function DocumentView({ document, workspaceId, dashboardId, locale }: DocumentViewProps): import("react").JSX.Element;

package/dist/src/workspace/dashboards/enabled-switch.d.ts

@@ -0,0 +1,10 @@
+import type { DashboardListItem } from "@overvis/hmi-shared/dashboard";
+export declare function DashboardEnabledSwitch({ workspaceId, dashboard, compact, className, }: {
+    workspaceId: string;
+    dashboard: DashboardListItem;
+    compact?: boolean;
+    className?: string;
+}): import("react").JSX.Element;
+export declare function DashboardDisabledBadge({ dashboard }: {
+    dashboard: DashboardListItem;
+}): import("react").JSX.Element | null;

package/dist/src/workspace/dashboards/entrypoint.d.ts

@@ -0,0 +1,15 @@
+import { type WorkspaceHostMode } from "../context.js";
+export declare function localDashboardEntrypointExists(url: string): Promise<boolean>;
+export declare function resolveDashboardEntrypointUrl(input: {
+    mode: WorkspaceHostMode;
+    dashboardId: string;
+    preferredUrl: string;
+}): Promise<{
+    url: string;
+    usingRemoteFallback: boolean;
+}>;
+/** Same query as the operator page, so Setup settings `import()`s the same URL. */
+export declare function useDashboardEntrypointUrl(dashboardId: string): import("@tanstack/react-query").UseQueryResult<NoInfer<{
+    url: string;
+    usingRemoteFallback: boolean;
+}>, Error>;

package/dist/src/workspace/dashboards/icon.d.ts

@@ -0,0 +1,6 @@
+/** Renders a Lucide glyph for a stored dashboard icon id. */
+export declare function DashboardIconGlyph({ icon, className, strokeWidth, }: {
+    icon: string | null | undefined;
+    className?: string;
+    strokeWidth?: number;
+}): import("react").FunctionComponentElement<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;

package/dist/src/workspace/dashboards/load-module.d.ts

@@ -0,0 +1,40 @@
+import type { GraphicsSymbolDefinition } from "../graphics/symbols/definition.js";
+import type { ComponentType } from "react";
+import type { AppLocale } from "@overvis/hmi-shared";
+import { dashboardConfigurationIssues, type DashboardRootProps } from "@overvis/hmi-shared/dashboard";
+export interface LoadedDashboardModule {
+    component: ComponentType<DashboardRootProps>;
+    graphicsSymbols: GraphicsSymbolDefinition[];
+    dashboardConfigType: Parameters<typeof dashboardConfigurationIssues>[0];
+    supportedLocales: readonly AppLocale[];
+}
+export declare function resolveDashboardLocale(input: {
+    locale: AppLocale;
+    supportedLocales: readonly AppLocale[];
+}): AppLocale;
+export type InspectDashboardModuleResult = {
+    ok: true;
+    module: LoadedDashboardModule;
+} | {
+    ok: false;
+    reason: "invalid_module" | "no_default" | "no_config_type" | "rebuild_required";
+};
+export type DashboardSettingsConfigurationError = {
+    kind: "load_failed";
+} | {
+    kind: "rebuild_required";
+} | {
+    kind: "issues";
+    text: string;
+};
+export declare function dashboardSettingsConfigurationError(loaded: InspectDashboardModuleResult, configuration: Record<string, unknown>): DashboardSettingsConfigurationError | null;
+export declare function inspectDashboardModule(mod: unknown): InspectDashboardModuleResult;
+/**
+ * Manifest URL beside a built bundle (`/static/dashboard/<id>/index.js`, keeping its query). Null
+ * for source entries a local dev server compiles on request, `index.js` included: those always
+ * match the running host.
+ */
+export declare function dashboardManifestUrl(jsUrl: string): string | null;
+/** False when the bundle has no manifest or was built for another host contract. */
+export declare function dashboardBuildMatchesHost(manifestUrl: string): Promise<boolean>;
+export declare function loadDashboardModule(jsUrl: string): Promise<InspectDashboardModuleResult>;

package/dist/src/workspace/dashboards/locale.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode } from "react";
+import type { AppLocale } from "@overvis/hmi-shared";
+export declare function DashboardLocaleProvider({ locale, children, }: {
+    locale: AppLocale;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The dashboard's negotiated locale inside a dashboard, the UI language elsewhere. */
+export declare function useDashboardLocale(): AppLocale;

package/dist/src/workspace/dashboards/module-cache.d.ts

@@ -0,0 +1,9 @@
+import type { QueryClient } from "@tanstack/react-query";
+/** Query key roots of loaded dashboard modules and their resolved entrypoint URLs. */
+export declare const dashboardModuleQueryKey = "dashboard-module";
+export declare const dashboardEntrypointQueryKey = "dashboard-entrypoint";
+/**
+ * Loaded dashboard modules stay cached until this drops them: open dashboards then load their
+ * code again and remount.
+ */
+export declare function reloadDashboardModules(queryClient: QueryClient): void;

package/dist/src/workspace/dashboards/mount-diagnostics.d.ts

@@ -0,0 +1,23 @@
+import type { DashboardHostDiagnostic } from "@overvis/hmi-shared/dashboard";
+import { type InspectDashboardModuleResult } from "./load-module.js";
+type InspectionReason = Extract<InspectDashboardModuleResult, {
+    ok: false;
+}>["reason"];
+/** Keep import exceptions in query state and preserve handled export inspection reasons. */
+export declare function loadDashboardMountModule(entrypointUrl: string): Promise<{
+    kind: "config-export";
+    cacheNonce: string;
+} | {
+    kind: "rebuild-required";
+    cacheNonce: string;
+} | {
+    component: import("react").ComponentType<import("@overvis/hmi-shared/dashboard").DashboardRootProps>;
+    graphicsSymbols: import("../../index.js").GraphicsSymbolDefinition[];
+    dashboardConfigType: Parameters<typeof import("@overvis/hmi-shared/dashboard").dashboardConfigurationIssues>[0];
+    supportedLocales: readonly import("@overvis/hmi-shared").AppLocale[];
+    kind: "ok";
+    cacheNonce: string;
+}>;
+export declare function dashboardMountExportDiagnostic(reason: InspectionReason): DashboardHostDiagnostic;
+export declare function dashboardMountLoadDiagnostic(error: unknown): DashboardHostDiagnostic;
+export {};

package/dist/src/workspace/dashboards/mount.d.ts

@@ -0,0 +1,39 @@
+import type { ReactElement, ReactNode } from "react";
+import { dashboardConfigurationIssues } from "@overvis/hmi-shared/dashboard";
+export declare function dashboardMountPhase(input: {
+    moduleStatus: "loading" | "error" | "success";
+    cssReady: boolean;
+}): "skeleton" | "error" | "ready";
+/** 404 and load both count as ready so an older JS-only board still mounts. */
+export declare function cssSettleAllowsMount(result: string): boolean;
+/** CSS is ready when there is none, or when the link for this fetch's `v=` has settled. */
+export declare function dashboardCssReady(input: {
+    stylesheetUrl: string | null;
+    cacheNonce: string | undefined;
+    settledNonce: string | null;
+}): boolean;
+export declare function dashboardMountConfigConsoleDetail(input: {
+    loaded: {
+        kind: "config-export";
+    };
+    configuration: Record<string, unknown>;
+}): string;
+export declare function dashboardMountConfigConsoleDetail(input: {
+    loaded: {
+        kind: "ok";
+        dashboardConfigType: Parameters<typeof dashboardConfigurationIssues>[0];
+    };
+    configuration: Record<string, unknown>;
+}): string | null;
+export declare function DashboardMountCanvas({ children }: {
+    children: ReactNode;
+}): ReactElement;
+export declare function DashboardMount({ entrypointUrl, stylesheetUrl, configuration, workspaceId, dashboardId, title, }: {
+    entrypointUrl: string;
+    stylesheetUrl: string | null;
+    configuration: Record<string, unknown>;
+    workspaceId: string;
+    dashboardId: string;
+    /** Dashboard name in the UI language, for the page state the assistant reads. */
+    title: string;
+}): ReactElement;

package/dist/src/workspace/dashboards/name.d.ts

@@ -0,0 +1,11 @@
+import { type AppLocale } from "@overvis/hmi-shared";
+/**
+ * A dashboard's name in `locale`, from the workspace's dashboard list, so a dashboard module can
+ * title its pages with the name the user gave it. Null while the list loads or when the
+ * dashboard is not listed.
+ */
+export declare function useDashboardName({ workspaceId, dashboardId, locale, }: {
+    workspaceId: string;
+    dashboardId: string;
+    locale: AppLocale;
+}): string | null;

package/dist/src/workspace/dashboards/navigation.d.ts

@@ -0,0 +1,51 @@
+import { type ComponentProps, type ReactNode } from "react";
+import { type DashboardLocation } from "@overvis/hmi-shared/dashboard";
+/**
+ * `replace` updates the current history entry. `keepScroll` keeps the page's scroll position
+ * although the path changes, for example to open an overlay at its own path. Back to the page it
+ * was opened from keeps it too, also after query or anchor changes on that path.
+ */
+export interface DashboardNavigateOptions {
+    replace?: boolean;
+    keepScroll?: boolean;
+}
+/** Scopes `useDashboardNavigation` to one mounted dashboard; the host mounts each dashboard in one. */
+export declare function DashboardNavigationProvider({ workspaceId, dashboardId, children, }: {
+    workspaceId: string;
+    dashboardId: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * Splits a public href without decoding or normalizing it, so values round-trip through `href`.
+ * Returns null outside the dashboard and for locations `href` would reject, such as traversal.
+ */
+export declare function dashboardLocationFromHref(href: string, base: string): {
+    path: string;
+    search: string;
+    hash: string;
+} | null;
+/** The host owns browser history; dashboard authors own their pages and navigation UI. */
+export declare function useDashboardNavigation(): {
+    href: (target: DashboardLocation) => string;
+    navigate: (target: DashboardLocation, options?: DashboardNavigateOptions) => Promise<void>;
+    location: {
+        path: string;
+        search: string;
+        hash: string;
+    };
+};
+/** Current dashboard location with `href` and `navigate`, as returned by `useDashboardNavigation`. */
+export type DashboardNavigation = ReturnType<typeof useDashboardNavigation>;
+/**
+ * A real anchor supports copying, new tabs, and modified clicks as well as client navigation.
+ * `replace` updates the current history entry, for toggles such as expanding a panel. `keepScroll`
+ * keeps the scroll position on another path, for example an overlay at its own path.
+ */
+export declare function DashboardLink(props: Omit<ComponentProps<"a">, "href"> & {
+    to: DashboardLocation;
+} & DashboardNavigateOptions): import("react").JSX.Element;
+/** `DashboardLink` for components that receive the dashboard navigation as a prop. */
+export declare function DashboardNavigationLink({ navigation, to, replace, keepScroll, onClick, ...props }: Omit<ComponentProps<"a">, "href"> & {
+    navigation: Pick<DashboardNavigation, "href" | "navigate">;
+    to: DashboardLocation;
+} & DashboardNavigateOptions): import("react").JSX.Element;

package/dist/src/workspace/dashboards/page-paths.d.ts

@@ -0,0 +1,7 @@
+/** Whether a dashboard location path opens the page at `pagePath`; a trailing slash is ignored. */
+export declare function dashboardPathMatches(pagePath: string, path: string): boolean;
+/**
+ * The page whose path matches a dashboard path, or null for an unknown page. A trailing slash is
+ * ignored, so `/settings/` opens the `/settings` page.
+ */
+export declare function dashboardPageAt<Page extends string>(pages: Readonly<Record<Page, string>>, path: string): Page | null;

package/dist/src/workspace/dashboards/page-tabs.d.ts

@@ -0,0 +1,23 @@
+import type { ReactElement } from "react";
+/** A dashboard page in `DashboardPageTabs`. */
+export interface DashboardPageTab {
+    path: string;
+    label: string;
+    /**
+     * Marks the current page where its path alone cannot tell, such as a first page that also opens
+     * at its own address. When any tab sets it, only those tabs count as current.
+     */
+    current?: boolean;
+}
+/**
+ * Tabs that link a dashboard's pages, with the current page marked. The row scrolls sideways on
+ * a phone when the labels do not fit. `search` is kept on every link, such as an edit-mode flag.
+ */
+export declare function DashboardPageTabs({ pages, search, }: {
+    pages: readonly DashboardPageTab[];
+    search?: string;
+}): ReactElement;
+/** The state of a dashboard path that matches none of its pages, with a link to `home`. */
+export declare function DashboardPageNotFound({ home }: {
+    home: DashboardPageTab;
+}): ReactElement;

package/dist/src/workspace/dashboards/page.d.ts

@@ -0,0 +1,4 @@
+export declare function DashboardPage({ workspaceId, dashboardId, }: {
+    workspaceId: string;
+    dashboardId: string;
+}): import("react").JSX.Element;

package/dist/src/workspace/dashboards/rotation.d.ts

@@ -0,0 +1,26 @@
+/** How long user input pauses page rotation. */
+export declare const rotationInputPauseMs = 60000;
+/**
+ * Whether rotation moves to the next page now: it is on, nothing pauses it, the page has shown
+ * for its time and the last user input is a minute old.
+ */
+export declare function rotationDue(input: {
+    now: number;
+    shownSince: number;
+    lastInputAt: number;
+    rotateMs: number;
+    paused: boolean;
+}): boolean;
+/** The page after `currentId`, back to the first after the last. */
+export declare function nextPageId(pageIds: readonly string[], currentId: string): string | null;
+/**
+ * Moves a dashboard to its next page every `rotateSeconds`, for wall displays; null turns it off.
+ * It pauses while `paused` (such as in edit mode or with details open), while any dialog is open
+ * and for a minute after any user input. `onRotate` navigates, for example to `nextPageId`.
+ */
+export declare function usePageRotation({ rotateSeconds, currentId, paused, onRotate, }: {
+    rotateSeconds: number | null;
+    currentId: string;
+    paused: boolean;
+    onRotate: () => void;
+}): void;

package/dist/src/workspace/dashboards/search-params.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Router query serialization that keeps every value as the string in the URL. TanStack's default
+ * JSON parsing rewrites values such as `1.0` or `12 ` and folds repeated keys, which breaks
+ * dashboards that read their raw query.
+ */
+export declare function parseRouterSearch(search: string): Record<string, string | string[]>;
+export declare function stringifyRouterSearch(search: Record<string, unknown>): string;

package/dist/src/workspace/dashboards/sortable-grid.d.ts

@@ -0,0 +1,79 @@
+import { type ReactElement, type ReactNode } from "react";
+/** A list of item IDs in order, such as the tiles of one section. */
+export interface SortableGridGroup {
+    id: string;
+    items: readonly string[];
+}
+/**
+ * Where a dragged item came from and where it was dropped. `before` is the order shown when the
+ * drag began, including earlier drops still saving: the baseline to check the move against.
+ */
+export interface SortableGridMove {
+    itemId: string;
+    from: {
+        group: string;
+        index: number;
+    };
+    to: {
+        group: string;
+        index: number;
+    };
+    before: readonly SortableGridGroup[];
+}
+/**
+ * Moves `itemId` to where `targetId` is: before or after another item (in its place), or to the
+ * end of a group when `targetId` is a group, its own included. Returns `groups` unchanged when
+ * nothing moves.
+ */
+export declare function moveSortableGridItem(groups: readonly SortableGridGroup[], itemId: string, targetId: string): readonly SortableGridGroup[];
+/**
+ * Drops still saving: `orders` holds the order each was made from, then the latest drop's order,
+ * as `JSON.stringify` keys; `shown` is the latest drop's order.
+ */
+export interface SortableGridSaving {
+    orders: readonly string[];
+    shown: readonly SortableGridGroup[];
+}
+/**
+ * What drops still saving make of `groups`. While `groups` is one of their orders, the latest
+ * drop shows and the orders before it are done; once it is the latest drop's order, or one that no
+ * drop made, nothing is pending and `groups` shows.
+ */
+export declare function pendingSortableGridOrder(saving: SortableGridSaving | null, groups: readonly SortableGridGroup[]): {
+    shown: readonly SortableGridGroup[];
+    saving: SortableGridSaving | null;
+};
+/**
+ * Drag-and-drop ordering of items in one or more groups, such as tiles in the sections of a page:
+ * items move within a group and between groups. `children` renders the groups in their order
+ * during a drag; `onMove` runs once on drop. With the keyboard, Space or Enter picks an item up by
+ * its handle, the arrow keys move it, Space or Enter drops it and Escape cancels. Each step is
+ * announced with `itemLabel` and `groupLabel`.
+ */
+export declare function SortableGrid({ groups, onMove, itemLabel, groupLabel, children, }: {
+    groups: readonly SortableGridGroup[];
+    /** Saves the move; a rejected promise puts the items back in their order from `groups`. */
+    onMove: (move: SortableGridMove) => Promise<unknown> | undefined;
+    itemLabel: (id: string) => string;
+    groupLabel: (id: string) => string;
+    children: (groups: readonly SortableGridGroup[]) => ReactNode;
+}): ReactElement;
+/** A group's drop area; an item dragged over its empty space moves to its end. */
+export declare function SortableGroup({ id, className, children, }: {
+    id: string;
+    className?: string;
+    children: ReactNode;
+}): ReactElement;
+/**
+ * One item of a `SortableGroup`, at `index` in it. `children` receives the ref for the drag
+ * handle: only the handle starts a drag, so buttons in the item keep working.
+ */
+export declare function SortableItem({ id, index, className, children, }: {
+    id: string;
+    index: number;
+    className?: string;
+    children: (handle: {
+        handleRef: (element: Element | null) => void;
+        isDragging: boolean;
+    }) => ReactNode;
+}): ReactElement;

package/dist/src/workspace/dashboards/stylesheet.d.ts

@@ -0,0 +1,9 @@
+/** Unique `v=` token per dashboard module fetch (ESM caches by full URL). */
+export declare function nextDashboardCacheBust(): string;
+export declare function withCacheBust(url: string, nonce: string): string;
+/** Insert the dashboard stylesheet for this mount; `stop` always unloads, including in-flight. */
+export declare function startDashboardStylesheet(stylesheetUrl: string, cacheNonce: string): {
+    href: string;
+    settled: Promise<"ok" | "missing">;
+    stop: () => void;
+};