@devicechain/dashboards 0.14.0-0

package/dist/internal/alarm-doc.d.ts

@@ -0,0 +1,48 @@
+import type { TypedDocument } from '@devicechain/client';
+import type { AlarmRow } from '../types';
+export interface AlarmSearchCriteriaInput {
+    pageNumber: number;
+    pageSize: number;
+    originatorType?: string | null;
+    originator?: string | null;
+    state?: string | null;
+    severity?: string | null;
+    acknowledged?: boolean | null;
+    alarmKey?: string | null;
+}
+export interface AlarmsQueryResult {
+    alarms: {
+        results: AlarmRow[];
+        pagination: {
+            totalRecords: number;
+        };
+    };
+}
+export interface AlarmsQueryVariables {
+    criteria: AlarmSearchCriteriaInput;
+}
+export declare const ALARMS_QUERY: TypedDocument<AlarmsQueryResult, AlarmsQueryVariables>;
+export interface AlarmStreamResult {
+    alarmStream: {
+        alarmToken: string;
+        eventType: string;
+    };
+}
+export interface AlarmStreamVariables {
+    originatorType?: string | null;
+    originator?: string | null;
+    state?: string | null;
+    severity?: string | null;
+    alarmKey?: string | null;
+}
+export declare const ALARM_STREAM: TypedDocument<AlarmStreamResult, AlarmStreamVariables>;
+export interface AlarmMutationVariables {
+    token: string;
+}
+export interface AlarmMutationResult {
+    [key: string]: {
+        token: string;
+    };
+}
+export declare const ACKNOWLEDGE_ALARM: TypedDocument<AlarmMutationResult, AlarmMutationVariables>;
+export declare const CLEAR_ALARM: TypedDocument<AlarmMutationResult, AlarmMutationVariables>;

package/dist/internal/command-doc.d.ts

@@ -0,0 +1,43 @@
+import type { TypedDocument } from '@devicechain/client';
+import type { CommandRow } from '../types';
+export interface CommandSearchCriteriaInput {
+    pageNumber: number;
+    pageSize: number;
+    deviceToken?: string | null;
+    status?: string | null;
+    statuses?: string[] | null;
+}
+export interface CommandsQueryResult {
+    commands: {
+        results: CommandRow[];
+        pagination: {
+            totalRecords: number;
+        };
+    };
+}
+export interface CommandsQueryVariables {
+    criteria: CommandSearchCriteriaInput;
+}
+export declare const COMMANDS_QUERY: TypedDocument<CommandsQueryResult, CommandsQueryVariables>;
+export interface CreateCommandRequestInput {
+    token: string;
+    deviceToken: string;
+    name: string;
+    payload?: string | null;
+}
+export interface CreateCommandResult {
+    createCommand: {
+        command: {
+            token: string;
+            status: string;
+        } | null;
+        rejection: {
+            code: string;
+            reason: string;
+        } | null;
+    };
+}
+export interface CreateCommandVariables {
+    request: CreateCommandRequestInput;
+}
+export declare const CREATE_COMMAND: TypedDocument<CreateCommandResult, CreateCommandVariables>;

package/dist/internal/location-doc.d.ts

@@ -0,0 +1,9 @@
+import type { TypedDocument } from '@devicechain/client';
+import type { LocationSample } from '../types';
+export interface LatestLocationsResult {
+    latestLocations: LocationSample[];
+}
+export interface LatestLocationsVariables {
+    deviceTokens: string[];
+}
+export declare const LATEST_LOCATIONS_QUERY: TypedDocument<LatestLocationsResult, LatestLocationsVariables>;

package/dist/internal/measurement-doc.d.ts

@@ -0,0 +1,10 @@
+import type { TypedDocument } from '@devicechain/client';
+import type { MeasurementSample } from '../types';
+export interface MeasurementStreamResult {
+    measurementStream: MeasurementSample;
+}
+export interface MeasurementStreamVariables {
+    deviceToken?: string | null;
+    name?: string | null;
+}
+export declare const MEASUREMENT_STREAM: TypedDocument<MeasurementStreamResult, MeasurementStreamVariables>;

package/dist/queries.d.ts

@@ -0,0 +1,72 @@
+import type { TypedDocument } from '@devicechain/client';
+export interface EntityRelationshipsResult {
+    entityRelationships: {
+        results: Array<{
+            source: {
+                token: string;
+            };
+        }>;
+    };
+}
+export interface EntityRelationshipsVariables {
+    criteria: {
+        pageNumber: number;
+        pageSize: number;
+        sourceType: string;
+        targetType: string;
+        target: string;
+        relationshipType?: string | null;
+    };
+}
+export declare const DEVICES_FOR_ANCHOR: TypedDocument<EntityRelationshipsResult, EntityRelationshipsVariables>;
+export interface DevicesByTokenResult {
+    devicesByToken: Array<{
+        token: string;
+    }>;
+}
+export interface DevicesByTokenVariables {
+    tokens: string[];
+}
+export declare const DEVICES_BY_TOKEN: TypedDocument<DevicesByTokenResult, DevicesByTokenVariables>;
+export interface EntityListResult {
+    results: Array<{
+        token: string;
+        name: string | null;
+    }>;
+}
+export interface EntityListVariables {
+    criteria: {
+        pageNumber: number;
+        pageSize: number;
+    };
+}
+export declare const LIST_DEVICES: TypedDocument<{
+    devices: EntityListResult;
+}, EntityListVariables>;
+export declare const LIST_CUSTOMERS: TypedDocument<{
+    customers: EntityListResult;
+}, EntityListVariables>;
+export declare const LIST_AREAS: TypedDocument<{
+    areas: EntityListResult;
+}, EntityListVariables>;
+export declare const LIST_ASSETS: TypedDocument<{
+    assets: EntityListResult;
+}, EntityListVariables>;
+export interface MeasurementBucket {
+    bucketStart: string;
+    name: string;
+    avg: number | null;
+}
+export interface BucketedMeasurementsResult {
+    bucketedMeasurements: MeasurementBucket[];
+}
+export interface BucketedMeasurementsVariables {
+    criteria: {
+        deviceToken: string;
+        name?: string | null;
+        startTime: string;
+        endTime: string;
+        intervalSeconds: number;
+    };
+}
+export declare const BUCKETED_MEASUREMENTS: TypedDocument<BucketedMeasurementsResult, BucketedMeasurementsVariables>;

package/dist/resolver.d.ts

@@ -0,0 +1,2 @@
+import type { DeviceResolver } from './hub';
+export declare function createDeviceResolver(): DeviceResolver;

package/dist/slots.d.ts

@@ -0,0 +1,22 @@
+import type { AnchorTarget, DashboardDefinition, LocationSelection, SlotBinding, SlotScope, WidgetInstance } from './types';
+export declare function sameBinding(a: SlotBinding | undefined, b: SlotBinding | undefined): boolean;
+export declare function migrateToSlots(def: DashboardDefinition): DashboardDefinition;
+export declare function bindWidgetSlot(def: DashboardDefinition, widgetId: string, binding: SlotBinding, measurements: string[], location?: LocationSelection): DashboardDefinition;
+export declare function clearWidgetDatasource(def: DashboardDefinition, widgetId: string): DashboardDefinition;
+export declare function pruneSlots(def: DashboardDefinition): DashboardDefinition;
+export declare function anchorSlotNames(def: DashboardDefinition): string[];
+export declare function setSlotScope(def: DashboardDefinition, slotName: string, scope: SlotScope | undefined): DashboardDefinition;
+export declare function widgetBinding(def: DashboardDefinition, widget: WidgetInstance): SlotBinding | undefined;
+export declare function widgetSlotName(widget: WidgetInstance): string | undefined;
+export type ConcreteSelector = {
+    kind: 'device';
+    deviceToken: string;
+    measurements: string[];
+    location?: LocationSelection;
+} | {
+    kind: 'anchor';
+    anchor: AnchorTarget;
+    measurements: string[];
+    location?: LocationSelection;
+};
+export declare function resolveConcrete(def: DashboardDefinition, widget: WidgetInstance): ConcreteSelector | undefined;

package/dist/synthetic.d.ts

@@ -0,0 +1,36 @@
+import type { AlarmStreamSink, AlarmSubscription, CommandDispatch, CommandStreamSink, CommandSubscription, LocationStreamSink, LocationSubscription, WidgetActions, WidgetDataSource, WidgetStreamSink } from './hub';
+import type { DatasourceSelector } from './types';
+export type SyntheticGenerator = 'sine' | 'ramp' | 'random-walk';
+export declare const SYNTHETIC_GENERATORS: ReadonlyArray<{
+    value: SyntheticGenerator;
+    label: string;
+}>;
+export interface SyntheticDataSourceConfig {
+    generator?: SyntheticGenerator;
+    intervalMs?: number;
+    backfill?: number;
+    min?: number;
+    max?: number;
+    periodMs?: number;
+}
+export declare class SyntheticDataSource implements WidgetDataSource, WidgetActions {
+    private readonly generator;
+    private readonly intervalMs;
+    private readonly backfill;
+    private readonly min;
+    private readonly max;
+    private readonly periodMs;
+    private readonly timers;
+    constructor(config?: SyntheticDataSourceConfig);
+    subscribeWidget(datasource: DatasourceSelector, sink: WidgetStreamSink): () => void;
+    subscribeAlarms(subscription: AlarmSubscription, sink: AlarmStreamSink): () => void;
+    subscribeCommands(subscription: CommandSubscription, sink: CommandStreamSink): () => void;
+    subscribeLocations(subscription: LocationSubscription, sink: LocationStreamSink): () => void;
+    isDatasourceAvailable(): Promise<boolean>;
+    can(): boolean;
+    acknowledgeAlarm(): Promise<void>;
+    clearAlarm(): Promise<void>;
+    sendCommand(): Promise<CommandDispatch>;
+    disposeAll(): void;
+    private valueFor;
+}

package/dist/types.d.ts

@@ -0,0 +1,190 @@
+export type LocationSeries = 'latest';
+export interface LocationSelection {
+    series: LocationSeries;
+}
+export interface DeviceSelector {
+    kind: 'device';
+    deviceToken: string;
+    measurements: string[];
+    location?: LocationSelection;
+}
+export interface AnchorTarget {
+    relationship: string;
+    targetType: 'customer' | 'area' | 'asset';
+    targetToken: string;
+}
+export interface AnchorAggregation {
+    window: string;
+    fn: 'avg' | 'min' | 'max' | 'sum' | 'count';
+}
+export interface AnchorSelector {
+    kind: 'anchor';
+    anchor: AnchorTarget;
+    measurements: string[];
+    location?: LocationSelection;
+    aggregation?: AnchorAggregation;
+}
+export interface DevicesSelector {
+    kind: 'devices';
+    deviceTokens: string[];
+    measurements: string[];
+    location?: LocationSelection;
+}
+export interface RelatedTraversalSelector {
+    kind: 'relatedTraversal';
+    from: string;
+    relationship: string;
+    measurements: string[];
+    location?: LocationSelection;
+}
+export interface SlotSelector {
+    kind: 'slot';
+    slot: string;
+    measurements: string[];
+    location?: LocationSelection;
+}
+export type DatasourceSelector = DeviceSelector | AnchorSelector | DevicesSelector | RelatedTraversalSelector | SlotSelector;
+export declare const WIDGET_TYPES: readonly ['timeseries-chart', 'latest-card', 'gauge', 'table', 'label', 'image', 'alarm-table', 'alarm-count', 'command-button', 'entity-selector', 'map'];
+export type WidgetType = (typeof WIDGET_TYPES)[number];
+export interface WidgetBox {
+    col: number;
+    colSpan: number;
+    row: number;
+    rowSpan: number;
+    z: number;
+    offset?: {
+        x: number;
+        y: number;
+    };
+}
+export type WidgetLayout = Record<string, WidgetBox>;
+export interface WidgetInstance {
+    id: string;
+    type: WidgetType;
+    layout: WidgetLayout;
+    datasource?: DatasourceSelector;
+    options?: Record<string, unknown>;
+}
+export interface CanvasBackground {
+    color?: string | null;
+    imageUrl?: string | null;
+}
+export interface CanvasGrid {
+    columns: number;
+    gap: number | {
+        row: number;
+        col: number;
+    };
+    rowHeight: number;
+}
+export type CanvasSizing = 'fill' | {
+    width: number;
+} | {
+    height: number;
+};
+export type Breakpoints = Record<string, number>;
+export interface Canvas {
+    background?: CanvasBackground;
+    grid: CanvasGrid;
+    sizing: CanvasSizing;
+    breakpoints: Breakpoints;
+}
+export type SlotBinding = {
+    kind: 'device';
+    deviceToken: string;
+} | {
+    kind: 'anchor';
+    anchor: AnchorTarget;
+};
+export interface SlotScope {
+    parent: string;
+    strategy: 'first' | 'manual';
+}
+export interface SlotDefinition {
+    type: 'device' | 'anchor';
+    label?: string;
+    defaultBinding?: SlotBinding;
+    scope?: SlotScope;
+}
+export type EntityListKind = 'device' | 'customer' | 'area' | 'asset';
+export type EntityCandidateLister = (kind: EntityListKind) => Promise<Array<{
+    token: string;
+    name?: string | null;
+}>>;
+export interface SelectionCandidate {
+    binding: SlotBinding;
+    label: string;
+    selected: boolean;
+}
+export interface SelectionTarget {
+    slot: string;
+    binding: SlotBinding;
+}
+export interface DashboardDefinition {
+    schemaVersion: number;
+    title: string;
+    canvas: Canvas;
+    widgets: WidgetInstance[];
+    slots?: Record<string, SlotDefinition>;
+}
+export interface MeasurementSample {
+    id: string;
+    deviceToken: string;
+    eventType: number;
+    occurredTime: string | null;
+    name: string;
+    value: number | null;
+    classifier: string | null;
+}
+export interface AlarmRow {
+    token: string;
+    originatorType: string;
+    originatorToken: string | null;
+    alarmKey: string;
+    metricKey: string;
+    state: string;
+    acknowledged: boolean;
+    severity: string;
+    raisedTime: string | null;
+    clearedTime: string | null;
+    acknowledgedTime: string | null;
+    acknowledgedBy: string | null;
+    lastValue: number | null;
+    message: string | null;
+}
+export interface LocationSample {
+    id: string;
+    deviceToken: string;
+    latitude: number | null;
+    longitude: number | null;
+    elevation: number | null;
+    accuracy: number | null;
+    speed: number | null;
+    heading: number | null;
+    occurredTime: string | null;
+}
+export interface CommandRow {
+    token: string;
+    name: string;
+    status: string;
+    payload: string | null;
+    responsePayload: string | null;
+    error: string | null;
+    queuedTime: string | null;
+    sentTime: string | null;
+    respondedTime: string | null;
+}
+export type CommandParamDataType = 'DOUBLE' | 'INT' | 'BOOLEAN' | 'STRING';
+export interface CommandParameter {
+    name: string;
+    description?: string;
+    kind?: 'SCALAR' | 'OBJECT';
+    dataType?: CommandParamDataType;
+    unit?: string;
+    required?: boolean;
+    default?: string | null;
+    minValue?: number | null;
+    maxValue?: number | null;
+    enum?: string[];
+    parameters?: CommandParameter[];
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@devicechain/dashboards",
+  "version": "0.14.0-0",
+  "description": "DeviceChain dashboard runtime — the DashboardHub (telemetry subscription multiplexing over the client wire, plus the alarm, command and location channels) and the dashboard-definition, selector, slot, and binding-manifest types.",
+  "keywords": [
+    "devicechain",
+    "iot",
+    "dashboard",
+    "telemetry",
+    "graphql"
+  ],
+  "license": "Apache-2.0",
+  "homepage": "https://devicechain.io",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/devicechain-io/devicechain.git",
+    "directory": "frontend/packages/dashboards"
+  },
+  "bugs": {
+    "url": "https://github.com/devicechain-io/devicechain/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node ../../scripts/build-package.mjs",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@graphql-typed-document-node/core": "^3.2.0"
+  },
+  "peerDependencies": {
+    "@devicechain/client": "0.14.0-0",
+    "graphql": "^16.0.0 || ^17.0.0"
+  },
+  "devDependencies": {
+    "@devicechain/client": "0.14.0-0",
+    "graphql": "^17.0.2",
+    "typescript": "~7.0.2",
+    "vitest": "^4.1.11"
+  }
+}