@devicechain/widgets 0.14.0-0

package/dist/map-runtime-context.d.ts

@@ -0,0 +1,91 @@
+import { type ReactNode } from 'react';
+/**
+ * The bundler-produced runtime a map widget needs from its host.
+ *
+ * `workerUrl` is the emitted, host-resolvable URL of MapLibre's worker entry
+ * (`maplibre-gl/dist/maplibre-gl-worker.mjs`). It is handed to MapLibre's `setWorkerUrl`
+ * before the first `Map` is constructed.
+ *
+ * `loadStyles` is OPTIONAL, and imports MapLibre's stylesheet
+ * (`maplibre-gl/dist/maplibre-gl.css`). Omit it and import the stylesheet yourself, the way
+ * every map library asks you to — that is the ordinary path and nothing here second-guesses
+ * it. Supplying it buys one thing: the CSS rides the renderer's lazy chunk instead of your
+ * main stylesheet, which is worth **83 KB raw / 10.7 KB gzipped** to a viewer who never
+ * opens a board with a map on it.
+ *
+ * 🔴 The size is measured against maplibre-gl 6.6.0, the version this package peers on. An
+ * earlier draft said 70 KB "measured, not estimated" — measured, but against a stale
+ * `node_modules` carrying 6.2.0. Measuring the right thing in the wrong tree reads exactly
+ * like measuring, which is why the version is named here.
+ *
+ * 🔴 It is a FUNCTION rather than a boolean or a URL because the host's bundler owns its
+ * CSS pipeline: only the host can say "load this, lazily, your way".
+ */
+export type MapRuntime = {
+    workerUrl: string;
+    loadStyles?: () => Promise<unknown>;
+};
+/**
+ * Supplies the host's MapLibre runtime to every map widget beneath it.
+ *
+ * Install it ONCE, high in the tree, next to TenantBasemapProvider — the console from its
+ * TenantProvider, the /dash viewer from the one place it mounts a DashboardRenderer.
+ *
+ * 🔑 ON VITE, DO NOT WRITE ANY OF THIS — import the ready-made runtime:
+ *
+ * ```tsx
+ * import { viteMapRuntime } from '@devicechain/widgets/vite';
+ *
+ * <MapRuntimeProvider runtime={viteMapRuntime}>{children}</MapRuntimeProvider>
+ * ```
+ *
+ * On any other bundler you supply the URL yourself, and there is ONE REQUIREMENT that
+ * decides whether it works: MapLibre loads the URL as a MODULE worker, so whatever it
+ * serves must be a module with no unresolved imports left in it.
+ * `maplibre-gl/dist/maplibre-gl-worker.mjs` does not satisfy that on its own — its first
+ * line is `import … from './maplibre-gl-shared.mjs'`.
+ *
+ * 🔴 SO DO NOT POINT AT A VERBATIM COPY OF THE WORKER FILE, and in particular do not
+ * reach for `new URL('maplibre-gl/dist/maplibre-gl-worker.mjs', import.meta.url)`. That
+ * looks exactly right and is wrong: webpack treats the target as an ASSET and copies it,
+ * the sibling is never emitted, and the worker dies on its own first line. Measured
+ * against webpack 5, from a packed tarball: the worker URL answered 200, both maps drew
+ * canvases, all markers appeared, tiles loaded, THE BUILD EXITED 0 AND THE CONSOLE WAS
+ * EMPTY — and the bundled basemap rendered ocean with no land on it.
+ *
+ * Two recipes that were measured working, in `hack/consumer-proof`:
+ *
+ * ```js
+ * // webpack — make the worker a second ENTRY, so its imports are bundled into it.
+ * entry: { main: './src/index.tsx', 'maplibre-worker': 'maplibre-gl/dist/maplibre-gl-worker.mjs' }
+ * // …then: <MapRuntimeProvider runtime={{ workerUrl: '/maplibre-worker.js' }}>
+ * ```
+ *
+ * ```js
+ * // any bundler, or none — copy the worker AND ITS SIBLING, under their own names,
+ * // into one served directory: maplibre-gl-worker.mjs + maplibre-gl-shared.mjs
+ * // …then: <MapRuntimeProvider runtime={{ workerUrl: '/vendor/maplibre-gl-worker.mjs' }}>
+ * ```
+ *
+ * 🔴 Hold the runtime in a MODULE CONSTANT, as above, rather than building it inline in
+ * JSX. An object literal in the element is a new identity on every render, and while the
+ * widget deliberately keys its effects on `workerUrl` rather than on the object to survive
+ * that, a host that also passes it anywhere keyed on identity would tear down and rebuild
+ * the map on every parent render. There is nothing per-render in it to justify the risk.
+ *
+ * 🔴 `maplibre-gl` is a PEER dependency of this package precisely so that the copy the host
+ * takes the worker from is the same copy this package renders with. A worker built from one
+ * version driving a main thread from another is the blank map again, by a different route.
+ */
+export declare function MapRuntimeProvider({ runtime, children, }: {
+    runtime: MapRuntime;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * The host's map runtime, or null when no host supplied one.
+ *
+ * 🔴 Callers MUST treat null as a refusal to render a map, not as a default to paper over.
+ * There is no sensible fallback: the only alternative to a host-supplied URL is MapLibre's
+ * own runtime derivation, which is the broken behaviour this seam exists to prevent.
+ */
+export declare function useMapRuntime(): MapRuntime | null;

package/dist/options.d.ts

@@ -0,0 +1,312 @@
+import { type WidgetType } from '@devicechain/dashboards';
+interface OptionSpecBase {
+    doc: string;
+    required?: true;
+}
+export interface StringOptionSpec extends OptionSpecBase {
+    kind: 'string';
+    format?: 'json';
+}
+export interface NumberOptionSpec extends OptionSpecBase {
+    kind: 'number';
+    min?: number;
+    max?: number;
+    integer?: true;
+}
+export interface BooleanOptionSpec extends OptionSpecBase {
+    kind: 'boolean';
+}
+export interface EnumOptionSpec<V extends string = string> extends OptionSpecBase {
+    kind: 'enum';
+    values: readonly V[];
+}
+export type OptionSpec = StringOptionSpec | NumberOptionSpec | BooleanOptionSpec | EnumOptionSpec;
+export type WidgetOptionSpecs = Record<string, OptionSpec>;
+export declare const WIDGET_OPTIONS: {
+    readonly 'timeseries-chart': {
+        readonly title: {
+            readonly kind: 'string';
+            readonly doc: 'Heading shown in the widget frame. Blank hides the frame heading.';
+        };
+        readonly window: {
+            readonly kind: 'number';
+            readonly integer: true;
+            readonly min: 1;
+            readonly doc: 'Samples retained across ALL of the widget\'s measurements before the oldest are dropped. Bounds memory; only the chart draws them. Default 300.';
+        };
+    };
+    readonly 'latest-card': {
+        readonly title: {
+            readonly kind: 'string';
+            readonly doc: 'Heading shown in the widget frame. Defaults to the displayed measurement name.';
+        };
+        readonly measurement: {
+            readonly kind: 'string';
+            readonly doc: 'Which measurement to display. Defaults to the first the datasource selects.';
+        };
+        readonly unit: {
+            readonly kind: 'string';
+            readonly doc: 'Unit suffix shown beside the value.';
+        };
+        readonly precision: {
+            readonly kind: 'number';
+            readonly integer: true;
+            readonly min: 0;
+            readonly max: 100;
+            readonly doc: 'Decimal places to round displayed values to. Unset shows the raw value.';
+        };
+        readonly flashOnChange: {
+            readonly kind: 'boolean';
+            readonly doc: 'Briefly tint a value green on a rise and red on a fall when it changes.';
+        };
+        readonly window: {
+            readonly kind: 'number';
+            readonly integer: true;
+            readonly min: 1;
+            readonly doc: 'Samples retained across ALL of the widget\'s measurements before the oldest are dropped. Bounds memory; only the chart draws them. Default 300.';
+        };
+    };
+    readonly gauge: {
+        readonly title: {
+            readonly kind: 'string';
+            readonly doc: 'Heading shown in the widget frame. Defaults to the displayed measurement name.';
+        };
+        readonly measurement: {
+            readonly kind: 'string';
+            readonly doc: 'Which measurement to display. Defaults to the first the datasource selects.';
+        };
+        readonly min: {
+            readonly kind: 'number';
+            readonly doc: 'Low end of the gauge scale. Default 0.';
+        };
+        readonly max: {
+            readonly kind: 'number';
+            readonly doc: 'High end of the gauge scale. Default 100.';
+        };
+        readonly unit: {
+            readonly kind: 'string';
+            readonly doc: 'Unit suffix shown beside the value.';
+        };
+        readonly flashOnChange: {
+            readonly kind: 'boolean';
+            readonly doc: 'Briefly tint a value green on a rise and red on a fall when it changes.';
+        };
+        readonly window: {
+            readonly kind: 'number';
+            readonly integer: true;
+            readonly min: 1;
+            readonly doc: 'Samples retained across ALL of the widget\'s measurements before the oldest are dropped. Bounds memory; only the chart draws them. Default 300.';
+        };
+    };
+    readonly table: {
+        readonly title: {
+            readonly kind: 'string';
+            readonly doc: 'Heading shown in the widget frame. Blank hides the frame heading.';
+        };
+        readonly precision: {
+            readonly kind: 'number';
+            readonly integer: true;
+            readonly min: 0;
+            readonly max: 100;
+            readonly doc: 'Decimal places to round displayed values to. Unset shows the raw value.';
+        };
+        readonly flashOnChange: {
+            readonly kind: 'boolean';
+            readonly doc: 'Briefly tint a value green on a rise and red on a fall when it changes.';
+        };
+        readonly window: {
+            readonly kind: 'number';
+            readonly integer: true;
+            readonly min: 1;
+            readonly doc: 'Samples retained across ALL of the widget\'s measurements before the oldest are dropped. Bounds memory; only the chart draws them. Default 300.';
+        };
+    };
+    readonly label: {
+        readonly title: {
+            readonly kind: 'string';
+            readonly doc: 'Heading shown in the widget frame. Blank hides the frame heading.';
+        };
+        readonly text: {
+            readonly kind: 'string';
+            readonly required: true;
+            readonly doc: 'The text to show. Rendered as plain text — markup is never interpreted.';
+        };
+        readonly align: {
+            readonly kind: 'enum';
+            readonly values: readonly ["left", "center", "right"];
+            readonly doc: 'Horizontal alignment of the text. Default center.';
+        };
+        readonly fontSize: {
+            readonly kind: 'number';
+            readonly min: 1;
+            readonly doc: 'Text size in pixels. Default 16.';
+        };
+    };
+    readonly image: {
+        readonly title: {
+            readonly kind: 'string';
+            readonly doc: 'Heading shown in the widget frame. Blank hides the frame heading.';
+        };
+        readonly url: {
+            readonly kind: 'string';
+            readonly required: true;
+            readonly doc: 'Source URL of the image.';
+        };
+        readonly alt: {
+            readonly kind: 'string';
+            readonly doc: 'Alternative text describing the image for assistive technology.';
+        };
+        readonly fit: {
+            readonly kind: 'enum';
+            readonly values: readonly ["contain", "cover", "fill"];
+            readonly doc: 'How the image fills its box. Default contain.';
+        };
+    };
+    readonly 'alarm-table': {
+        readonly title: {
+            readonly kind: 'string';
+            readonly doc: 'Heading shown in the widget frame. Blank hides the frame heading.';
+        };
+        readonly state: {
+            readonly kind: 'enum';
+            readonly values: readonly ["ACTIVE", "CLEARED"];
+            readonly doc: 'Show only alarms in this state. Unset shows every state.';
+        };
+        readonly severity: {
+            readonly kind: 'enum';
+            readonly values: readonly ["CRITICAL", "MAJOR", "MINOR", "WARNING", "INDETERMINATE"];
+            readonly doc: 'Show only alarms at this severity. Unset shows every severity.';
+        };
+        readonly acknowledged: {
+            readonly kind: 'enum';
+            readonly values: readonly ["true", "false"];
+            readonly doc: "Show only acknowledged ('true') or unacknowledged ('false') alarms. Unset shows both.";
+        };
+        readonly maxRows: {
+            readonly kind: 'number';
+            readonly integer: true;
+            readonly min: 1;
+            readonly doc: 'Alarms loaded into the table. Default 50.';
+        };
+        readonly precision: {
+            readonly kind: 'number';
+            readonly integer: true;
+            readonly min: 0;
+            readonly max: 100;
+            readonly doc: 'Decimal places to round displayed values to. Unset shows the raw value.';
+        };
+        readonly flashOnChange: {
+            readonly kind: 'boolean';
+            readonly doc: 'Briefly tint a value green on a rise and red on a fall when it changes.';
+        };
+        readonly selectionTarget: {
+            readonly kind: 'string';
+            readonly doc: 'Name of the slot this widget re-points when the viewer picks an entity.';
+        };
+    };
+    readonly 'alarm-count': {
+        readonly title: {
+            readonly kind: 'string';
+            readonly doc: 'Heading shown in the widget frame. Blank hides the frame heading.';
+        };
+        readonly state: {
+            readonly kind: 'enum';
+            readonly values: readonly ["ACTIVE", "CLEARED"];
+            readonly doc: 'Show only alarms in this state. Unset shows every state.';
+        };
+        readonly severity: {
+            readonly kind: 'enum';
+            readonly values: readonly ["CRITICAL", "MAJOR", "MINOR", "WARNING", "INDETERMINATE"];
+            readonly doc: 'Show only alarms at this severity. Unset shows every severity.';
+        };
+        readonly acknowledged: {
+            readonly kind: 'enum';
+            readonly values: readonly ["true", "false"];
+            readonly doc: "Show only acknowledged ('true') or unacknowledged ('false') alarms. Unset shows both.";
+        };
+    };
+    readonly 'command-button': {
+        readonly title: {
+            readonly kind: 'string';
+            readonly doc: 'Heading shown in the widget frame. Blank hides the frame heading.';
+        };
+        readonly commandName: {
+            readonly kind: 'string';
+            readonly required: true;
+            readonly doc: 'Command key issued to the target device. Without it the widget cannot send.';
+        };
+        readonly commandLabel: {
+            readonly kind: 'string';
+            readonly doc: 'Text on the send button. Defaults to the command key.';
+        };
+        readonly parameterSchema: {
+            readonly kind: 'string';
+            readonly format: 'json';
+            readonly doc: "The command's parameter descriptors, baked in as JSON at author time. Drives the typed form.";
+        };
+        readonly maxRows: {
+            readonly kind: 'number';
+            readonly integer: true;
+            readonly min: 1;
+            readonly doc: 'Recent commands shown in the history. Default 20.';
+        };
+    };
+    readonly 'entity-selector': {
+        readonly title: {
+            readonly kind: 'string';
+            readonly doc: 'Heading shown in the widget frame. Blank hides the frame heading.';
+        };
+        readonly selectionTarget: {
+            readonly kind: 'string';
+            readonly doc: 'Name of the slot this widget re-points when the viewer picks an entity.';
+            readonly required: true;
+        };
+    };
+    readonly map: {
+        readonly title: {
+            readonly kind: 'string';
+            readonly doc: 'Heading shown in the widget frame. Blank hides the frame heading.';
+        };
+        readonly tileUrl: {
+            readonly kind: 'string';
+            readonly doc: "Raster tile URL template, e.g. https://tiles.example.com/{z}/{x}/{y}.png. Leave empty to inherit the tenant's basemap; setting one overrides it for this board only.";
+        };
+        readonly attribution: {
+            readonly kind: 'string';
+            readonly doc: 'Credit line the tile source requires, shown on the map. Set whatever the provider you chose asks for.';
+        };
+    };
+};
+type SpecValue<S> = S extends {
+    kind: 'enum';
+    values: readonly (infer V)[];
+} ? V extends string ? V : never : S extends {
+    kind: 'number';
+} ? number : S extends {
+    kind: 'boolean';
+} ? boolean : S extends {
+    kind: 'string';
+} ? string : never;
+type RequiredOptionKeys<S> = {
+    [K in keyof S]: S[K] extends {
+        required: true;
+    } ? K : never;
+}[keyof S];
+type OptionsFor<T extends WidgetType> = {
+    [K in RequiredOptionKeys<(typeof WIDGET_OPTIONS)[T]>]: SpecValue<(typeof WIDGET_OPTIONS)[T][K]>;
+} & {
+    [K in Exclude<keyof (typeof WIDGET_OPTIONS)[T], RequiredOptionKeys<(typeof WIDGET_OPTIONS)[T]>>]?: SpecValue<(typeof WIDGET_OPTIONS)[T][K]>;
+};
+export type WidgetOptions<T extends WidgetType> = T extends WidgetType ? OptionsFor<T> : never;
+export type OptionIssueCode = 'unknown' | 'type' | 'enum' | 'range' | 'missing' | 'json' | 'invariant';
+export interface OptionIssue {
+    widgetType: WidgetType;
+    key: string;
+    code: OptionIssueCode;
+    message: string;
+}
+export declare function validateWidgetOptions(widgetType: WidgetType, options: Record<string, unknown> | undefined): OptionIssue[];
+export declare function numberOptionSpec(type: WidgetType, key: string): NumberOptionSpec | undefined;
+export declare function clampNumberOption(spec: NumberOptionSpec | undefined, value: number): number | undefined;
+export declare function enumOptionValues(type: WidgetType, key: string): readonly string[] | undefined;
+export {};

package/dist/registry.d.ts

@@ -0,0 +1,44 @@
+import type { WidgetType } from '@devicechain/dashboards';
+import type { AlarmStreamState, CommandStreamState, LocationStreamState } from './hooks';
+import type { WidgetComponent } from './widget';
+export type WidgetChannel = 'measurement' | 'alarm' | 'control' | 'selection' | 'location';
+export declare const WIDGET_CHANNEL: {
+    readonly 'timeseries-chart': 'measurement';
+    readonly 'latest-card': 'measurement';
+    readonly gauge: 'measurement';
+    readonly table: 'measurement';
+    readonly label: 'measurement';
+    readonly image: 'measurement';
+    readonly 'alarm-table': 'alarm';
+    readonly 'alarm-count': 'alarm';
+    readonly 'command-button': 'control';
+    readonly 'entity-selector': 'selection';
+    readonly map: 'location';
+};
+type WidgetTypeOn<C extends WidgetChannel> = {
+    [K in WidgetType]: (typeof WIDGET_CHANNEL)[K] extends C ? K : never;
+}[WidgetType];
+type MeasurementWidgetType = WidgetTypeOn<'measurement'>;
+type AlarmWidgetType = WidgetTypeOn<'alarm'>;
+type ControlWidgetType = WidgetTypeOn<'control'>;
+type SelectionWidgetType = WidgetTypeOn<'selection'>;
+type LocationWidgetType = WidgetTypeOn<'location'>;
+export declare const WIDGET_REGISTRY: Record<MeasurementWidgetType, WidgetComponent>;
+export declare const ALARM_WIDGET_REGISTRY: Record<AlarmWidgetType, WidgetComponent<AlarmStreamState>>;
+export declare const CONTROL_WIDGET_REGISTRY: Record<ControlWidgetType, WidgetComponent<CommandStreamState>>;
+export declare const SELECTION_WIDGET_REGISTRY: Record<SelectionWidgetType, WidgetComponent<null>>;
+export declare const LOCATION_WIDGET_REGISTRY: Record<LocationWidgetType, WidgetComponent<LocationStreamState>>;
+export declare const WIDGET_BINDS_DATASOURCE: {
+    readonly 'timeseries-chart': true;
+    readonly 'latest-card': true;
+    readonly gauge: true;
+    readonly table: true;
+    readonly label: false;
+    readonly image: false;
+    readonly 'alarm-table': true;
+    readonly 'alarm-count': true;
+    readonly 'command-button': true;
+    readonly 'entity-selector': false;
+    readonly map: true;
+};
+export {};

package/dist/theme.d.ts

@@ -0,0 +1,9 @@
+export declare function css(name: ThemeVar): string;
+export type ThemeVar = 'background' | 'foreground' | 'card' | 'card-foreground' | 'muted' | 'muted-foreground' | 'primary' | 'border' | 'destructive';
+export interface ChartTheme {
+    foreground: string;
+    mutedForeground: string;
+    border: string;
+    series: string[];
+}
+export declare function resolveChartTheme(el: Element): ChartTheme;

package/dist/vite.d.ts

@@ -0,0 +1,19 @@
+import type { MapRuntime } from './map-runtime-context';
+/**
+ * A complete `MapRuntime` for a Vite host.
+ *
+ * ```tsx
+ * import { MapRuntimeProvider } from '@devicechain/widgets';
+ * import { viteMapRuntime } from '@devicechain/widgets/vite';
+ *
+ * <MapRuntimeProvider runtime={viteMapRuntime}>{children}</MapRuntimeProvider>
+ * ```
+ *
+ * A module constant, so it is referentially stable for the life of the page.
+ *
+ * `loadStyles` keeps MapLibre's 83 KB stylesheet (10.7 KB gzipped) on the renderer's lazy
+ * chunk, so a viewer who opens no map downloads none of it. Import the stylesheet yourself
+ * instead if you would rather have it eagerly — the field is optional and this is only the
+ * default that costs a first-time user nothing to accept.
+ */
+export declare const viteMapRuntime: MapRuntime;

package/dist/vite.js

@@ -0,0 +1,10 @@
+// src/vite.ts
+import workerUrl from "maplibre-gl/dist/maplibre-gl-worker.mjs?worker&url";
+var viteMapRuntime = {
+  workerUrl,
+  loadStyles: () => import("maplibre-gl/dist/maplibre-gl.css")
+};
+export {
+  viteMapRuntime
+};
+//# sourceMappingURL=vite.js.map

package/dist/vite.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/vite.ts"],
+  "sourcesContent": ["// Copyright The DeviceChain Authors\n// SPDX-License-Identifier: Apache-2.0\n\n// `@devicechain/widgets/vite` \u2014 the ready-made map runtime for hosts built with Vite.\n//\n// \uD83D\uDD34 THIS IS THE ONE FILE IN THIS PACKAGE ALLOWED TO WRITE A BUNDLER'S DIALECT, and the\n// exception is deliberate, bounded, and enforced rather than promised. The main entry\n// (`@devicechain/widgets`) contains no bundler-specific specifier at all \u2014 that is what\n// lets a webpack, Next or Rollup consumer build it \u2014 and the dialect gate proves it by\n// building the two entries SEPARATELY: zero dialect specifiers reachable from `index.ts`,\n// exactly one from here. So the carve-out cannot quietly widen, and it cannot leak into\n// the portable entry, because a consumer only ever gets this module by importing it BY\n// NAME.\n//\n// \uD83D\uDD34 WHY THE EXCEPTION IS WORTH IT. Without it every Vite consumer \u2014 which today means\n// every likely consumer, including this repo's own console and /dash \u2014 must learn that\n// MapLibre needs a worker URL, learn their bundler's idiom for emitting one, and write it\n// correctly, to render a map. That is a lot of ceremony to hand someone who asked for a map\n// widget, and getting it wrong has a famously quiet failure mode. Simplicity for the\n// consumer is worth one carefully fenced file.\n//\n// VERIFIED, not assumed: a package inside `node_modules` writing `?worker&url` is resolved\n// correctly by a CONSUMER's Vite \u2014 tested outside this monorepo against Vite 6.4.3 and\n// 8.2.2, with the worker emitted as its own entry and its `maplibre-gl-shared.mjs` sibling\n// INLINED into it. That last part is why `?worker&url` and not plain `?url`: the plain form\n// copies one file verbatim and leaves the sibling dangling.\n\nimport type { MapRuntime } from './map-runtime-context';\n\n// `?worker&url` makes Vite treat the module as a worker ENTRY \u2014 bundling what it imports\n// along with it \u2014 and hand back the emitted, hashed URL.\nimport workerUrl from 'maplibre-gl/dist/maplibre-gl-worker.mjs?worker&url';\n\n/**\n * A complete `MapRuntime` for a Vite host.\n *\n * ```tsx\n * import { MapRuntimeProvider } from '@devicechain/widgets';\n * import { viteMapRuntime } from '@devicechain/widgets/vite';\n *\n * <MapRuntimeProvider runtime={viteMapRuntime}>{children}</MapRuntimeProvider>\n * ```\n *\n * A module constant, so it is referentially stable for the life of the page.\n *\n * `loadStyles` keeps MapLibre's 83 KB stylesheet (10.7 KB gzipped) on the renderer's lazy\n * chunk, so a viewer who opens no map downloads none of it. Import the stylesheet yourself\n * instead if you would rather have it eagerly \u2014 the field is optional and this is only the\n * default that costs a first-time user nothing to accept.\n */\nexport const viteMapRuntime: MapRuntime = {\n  workerUrl,\n  loadStyles: () => import('maplibre-gl/dist/maplibre-gl.css'),\n};\n"],
+  "mappings": ";AA+BA,OAAO,eAAe;AAmBf,IAAM,iBAA6B;AAAA,EACxC;AAAA,EACA,YAAY,MAAM,OAAO,kCAAkC;AAC7D;",
+  "names": []
+}

package/dist/widget.d.ts

@@ -0,0 +1,16 @@
+import type { MeasurementSample, WidgetActions, WidgetInstance } from '@devicechain/dashboards';
+import type { ComponentType } from 'react';
+import type { MeasurementStreamState } from './hooks';
+export interface WidgetProps<D = MeasurementStreamState> {
+    widget: WidgetInstance;
+    data: D;
+    actions?: WidgetActions;
+}
+export type WidgetComponent<D = MeasurementStreamState> = ComponentType<WidgetProps<D>>;
+export declare function pickSample(latest: Record<string, MeasurementSample>, name: string | undefined): MeasurementSample | undefined;
+type Options = Record<string, unknown> | undefined;
+export declare function optString(options: Options, key: string): string | undefined;
+export declare function optNumber(options: Options, key: string): number | undefined;
+export declare function optBoolean(options: Options, key: string): boolean;
+export declare function primaryMeasurementName(widget: WidgetInstance): string | undefined;
+export {};

package/dist/widgets/alarm-count.d.ts

@@ -0,0 +1,3 @@
+import type { AlarmStreamState } from '../hooks';
+import { type WidgetProps } from '../widget';
+export declare function AlarmCount({ widget, data }: WidgetProps<AlarmStreamState>): import("react").JSX.Element;

package/dist/widgets/alarm-table.d.ts

@@ -0,0 +1,3 @@
+import type { AlarmStreamState } from '../hooks';
+import { type WidgetProps } from '../widget';
+export declare function AlarmTable({ widget, data, actions }: WidgetProps<AlarmStreamState>): import("react").JSX.Element;

package/dist/widgets/command-button.d.ts

@@ -0,0 +1,3 @@
+import type { CommandStreamState } from '../hooks';
+import { type WidgetProps } from '../widget';
+export declare function CommandButton({ widget, data, actions }: WidgetProps<CommandStreamState>): import("react").JSX.Element;

package/dist/widgets/command-params.d.ts

@@ -0,0 +1,7 @@
+import type { CommandParameter } from '@devicechain/dashboards';
+export declare function parseParameterSchema(schema: string | null | undefined): CommandParameter[];
+export declare function isScalar(param: CommandParameter): boolean;
+export declare function parseBool(raw: string): boolean;
+export declare function defaultValues(params: CommandParameter[]): Record<string, string>;
+export declare function validateParams(params: CommandParameter[], values: Record<string, string>): Record<string, string>;
+export declare function buildPayload(params: CommandParameter[], values: Record<string, string>): string | undefined;

package/dist/widgets/command-status.d.ts

@@ -0,0 +1,3 @@
+export declare function commandStatusColor(status: string): string;
+export declare function isTerminalStatus(status: string): boolean;
+export declare function commandStatusLabel(status: string): string;

package/dist/widgets/entity-selector.d.ts

@@ -0,0 +1,2 @@
+import { type WidgetProps } from '../widget';
+export declare function EntitySelector({ widget }: WidgetProps<null>): import("react").JSX.Element;

package/dist/widgets/gauge.d.ts

@@ -0,0 +1,2 @@
+import { type WidgetProps } from '../widget';
+export declare function Gauge({ widget, data }: WidgetProps): import("react").JSX.Element;

package/dist/widgets/image.d.ts

@@ -0,0 +1,2 @@
+import { type WidgetProps } from '../widget';
+export declare function Image({ widget }: WidgetProps): import("react").JSX.Element;

package/dist/widgets/label.d.ts

@@ -0,0 +1,2 @@
+import { type WidgetProps } from '../widget';
+export declare function Label({ widget }: WidgetProps): import("react").JSX.Element;

package/dist/widgets/latest-card.d.ts

@@ -0,0 +1,2 @@
+import { type WidgetProps } from '../widget';
+export declare function LatestCard({ widget, data }: WidgetProps): import("react").JSX.Element;

package/dist/widgets/map-geometry.d.ts

@@ -0,0 +1,17 @@
+import type { LocationSample } from '@devicechain/dashboards';
+export interface PlaceableLocation extends LocationSample {
+    latitude: number;
+    longitude: number;
+}
+export declare function placeable(samples: readonly LocationSample[]): PlaceableLocation[];
+export interface PanelPoint {
+    x: number;
+    y: number;
+}
+export declare function projectToPanel(positions: readonly PlaceableLocation[]): PanelPoint[];
+export declare function formatDegrees(value: number): string;
+export declare function describePosition(sample: PlaceableLocation): string;
+export declare function rasterStyleFor(tileUrl: string, attribution: string | undefined): unknown;
+export declare const BUNDLED_BASEMAP_ATTRIBUTION = "Made with Natural Earth";
+export declare function landStyleFrom(land: unknown, boundaries: unknown): unknown;
+export declare function loadLandStyle(): Promise<unknown>;

package/dist/widgets/map.d.ts

@@ -0,0 +1,3 @@
+import type { LocationStreamState } from '../hooks';
+import { type WidgetProps } from '../widget';
+export declare function MapWidget({ widget, data }: WidgetProps<LocationStreamState>): import("react").JSX.Element;

package/dist/widgets/natural-earth-data.d.ts

@@ -0,0 +1,5 @@
+export interface NaturalEarthData {
+    land: unknown;
+    boundaries: unknown;
+}
+export declare const NATURAL_EARTH: NaturalEarthData;

package/dist/widgets/severity.d.ts

@@ -0,0 +1,4 @@
+export declare function severityColor(severity: string): string;
+export declare function severityRank(severity: string): number;
+export declare function severityLabel(severity: string): string;
+export declare function highestSeverity(severities: string[]): string | undefined;

package/dist/widgets/table.d.ts

@@ -0,0 +1,2 @@
+import { type WidgetProps } from '../widget';
+export declare function Table({ widget, data }: WidgetProps): import("react").JSX.Element;

package/dist/widgets/time-series-chart.d.ts

@@ -0,0 +1,2 @@
+import { type WidgetProps } from '../widget';
+export declare function TimeSeriesChart({ widget, data }: WidgetProps): import("react").JSX.Element;