@devicechain/widgets 0.21.1-rc.1 → 0.22.0-rc.1

package/dist/chunks/chunk-XQQQNTBX.js

@@ -0,0 +1,76 @@
+// src/level-readout.tsx
+import {
+  css,
+  fitValueFont,
+  fitValueFontCss,
+  FIT_MIN_FONT_PX,
+  fontVar,
+  spaceVar,
+  useStickyChars
+} from "@devicechain/widget-sdk";
+import { jsx, jsxs } from "react/jsx-runtime";
+var MARKER = { above: "\u25B2", below: "\u25BC" };
+function LevelReadout({ text, unit, color, position, size, scale, strings }) {
+  const hasUnit = unit !== void 0 && unit !== "";
+  const marked = position === "above" || position === "below";
+  const chars = useStickyChars(text.length + (hasUnit ? Math.ceil(unit.length / 2) + 1 : 0) + (marked ? 1 : 0));
+  const floor = Math.round(FIT_MIN_FONT_PX * scale);
+  const measured = size.width > 0 && size.height > 0;
+  const px = measured ? fitValueFont(size, chars, { floor }) : void 0;
+  const font = px ?? fitValueFontCss(chars, { floor });
+  const half = px !== void 0 ? Math.round(px / 2) : `calc(${font} / 2)`;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-level-readout": "",
+      style: {
+        fontSize: font,
+        fontWeight: 600,
+        lineHeight: 1.1,
+        whiteSpace: "nowrap",
+        fontVariantNumeric: "tabular-nums",
+        color: color ?? css("foreground"),
+        textAlign: "center"
+      },
+      children: [
+        text,
+        hasUnit ? /* @__PURE__ */ jsx("span", { style: { fontSize: half, color: css("muted-foreground"), marginLeft: spaceVar(1) }, children: unit }) : null,
+        marked ? /* @__PURE__ */ jsx(
+          "span",
+          {
+            role: "img",
+            "aria-label": position === "above" ? strings.aboveScale : strings.belowScale,
+            title: position === "above" ? strings.aboveScale : strings.belowScale,
+            style: { fontSize: half, color: css("muted-foreground"), marginLeft: spaceVar(1) },
+            children: MARKER[position]
+          }
+        ) : null
+      ]
+    }
+  );
+}
+function LevelEmpty({ message }) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-level-empty": "",
+      style: {
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        height: "100%",
+        textAlign: "center",
+        color: css("muted-foreground"),
+        fontSize: fontVar("sm"),
+        overflowWrap: "anywhere"
+      },
+      children: message
+    }
+  );
+}
+
+export {
+  LevelReadout,
+  LevelEmpty
+};
+//# sourceMappingURL=chunk-XQQQNTBX.js.map

package/dist/chunks/chunk-XQQQNTBX.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/level-readout.tsx"],
+  "sourcesContent": ["// Copyright The DeviceChain Authors\n// SPDX-License-Identifier: Apache-2.0\n\n// The fitted DOM readout and the explained empty state the level-and-indicator widgets share.\n// DOM, not canvas text, so the readability gate can measure it.\n\nimport {\n  css,\n  fitValueFont,\n  fitValueFontCss,\n  FIT_MIN_FONT_PX,\n  fontVar,\n  spaceVar,\n  useStickyChars,\n} from '@devicechain/widget-sdk';\n\nimport type { LevelStrings } from './level-strings';\nimport type { ScalePosition } from './value-scale';\n\n// The room the readout may fill (a box inside the frame's content column) and the density scale.\nexport interface ReadoutRoom {\n  size: { width: number; height: number };\n  scale: number;\n}\n\n// The words the off-scale marker is labelled with; the only strings the readout itself reads.\nexport type MarkerStrings = Pick<LevelStrings, 'aboveScale' | 'belowScale'>;\n\n// A readout that can be marked off-scale must be handed the marker's label, so an unlabelled\n// marker cannot be written; one that is never marked (the gauge) needs no strings at all, which\n// keeps the level-strings table out of an eager widget's bundle.\nexport type LevelReadoutProps = ReadoutRoom & {\n  text: string;\n  unit?: string;\n  color?: string;\n} & (\n    | {\n        // Set when the value lies off the scale: a marker is drawn beside it.\n        position?: ScalePosition;\n        strings: MarkerStrings;\n      }\n    | { position?: undefined; strings?: undefined }\n  );\n\nconst MARKER = { above: '\u25B2', below: '\u25BC' } as const;\n\nexport function LevelReadout({ text, unit, color, position, size, scale, strings }: LevelReadoutProps) {\n  const hasUnit = unit !== undefined && unit !== '';\n  const marked = position === 'above' || position === 'below';\n  // The unit and the marker render at half size, so each counts for half its characters.\n  const chars = useStickyChars(text.length + (hasUnit ? Math.ceil(unit.length / 2) + 1 : 0) + (marked ? 1 : 0));\n  const floor = Math.round(FIT_MIN_FONT_PX * scale);\n  const measured = size.width > 0 && size.height > 0;\n  const px = measured ? fitValueFont(size, chars, { floor }) : undefined;\n  const font = px ?? fitValueFontCss(chars, { floor });\n  const half = px !== undefined ? Math.round(px / 2) : `calc(${font} / 2)`;\n  return (\n    <div\n      data-level-readout=\"\"\n      style={{\n        fontSize: font,\n        fontWeight: 600,\n        lineHeight: 1.1,\n        whiteSpace: 'nowrap',\n        fontVariantNumeric: 'tabular-nums',\n        color: color ?? css('foreground'),\n        textAlign: 'center',\n      }}\n    >\n      {text}\n      {hasUnit ? (\n        <span style={{ fontSize: half, color: css('muted-foreground'), marginLeft: spaceVar(1) }}>{unit}</span>\n      ) : null}\n      {marked ? (\n        <span\n          role=\"img\"\n          aria-label={position === 'above' ? strings.aboveScale : strings.belowScale}\n          title={position === 'above' ? strings.aboveScale : strings.belowScale}\n          style={{ fontSize: half, color: css('muted-foreground'), marginLeft: spaceVar(1) }}\n        >\n          {MARKER[position]}\n        </span>\n      ) : null}\n    </div>\n  );\n}\n\n// Why there is nothing to draw: a short sentence in the widget's own box, never a fake value.\nexport function LevelEmpty({ message }: { message: string }) {\n  return (\n    <div\n      data-level-empty=\"\"\n      style={{\n        display: 'flex',\n        alignItems: 'center',\n        justifyContent: 'center',\n        height: '100%',\n        textAlign: 'center',\n        color: css('muted-foreground'),\n        fontSize: fontVar('sm'),\n        overflowWrap: 'anywhere',\n      }}\n    >\n      {message}\n    </div>\n  );\n}\n"],
+  "mappings": ";AAMA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AA2CH,SAcI,KAdJ;AAbJ,IAAM,SAAS,EAAE,OAAO,UAAK,OAAO,SAAI;AAEjC,SAAS,aAAa,EAAE,MAAM,MAAM,OAAO,UAAU,MAAM,OAAO,QAAQ,GAAsB;AACrG,QAAM,UAAU,SAAS,UAAa,SAAS;AAC/C,QAAM,SAAS,aAAa,WAAW,aAAa;AAEpD,QAAM,QAAQ,eAAe,KAAK,UAAU,UAAU,KAAK,KAAK,KAAK,SAAS,CAAC,IAAI,IAAI,MAAM,SAAS,IAAI,EAAE;AAC5G,QAAM,QAAQ,KAAK,MAAM,kBAAkB,KAAK;AAChD,QAAM,WAAW,KAAK,QAAQ,KAAK,KAAK,SAAS;AACjD,QAAM,KAAK,WAAW,aAAa,MAAM,OAAO,EAAE,MAAM,CAAC,IAAI;AAC7D,QAAM,OAAO,MAAM,gBAAgB,OAAO,EAAE,MAAM,CAAC;AACnD,QAAM,OAAO,OAAO,SAAY,KAAK,MAAM,KAAK,CAAC,IAAI,QAAQ,IAAI;AACjE,SACE;AAAA,IAAC;AAAA;AAAA,MACC,sBAAmB;AAAA,MACnB,OAAO;AAAA,QACL,UAAU;AAAA,QACV,YAAY;AAAA,QACZ,YAAY;AAAA,QACZ,YAAY;AAAA,QACZ,oBAAoB;AAAA,QACpB,OAAO,SAAS,IAAI,YAAY;AAAA,QAChC,WAAW;AAAA,MACb;AAAA,MAEC;AAAA;AAAA,QACA,UACC,oBAAC,UAAK,OAAO,EAAE,UAAU,MAAM,OAAO,IAAI,kBAAkB,GAAG,YAAY,SAAS,CAAC,EAAE,GAAI,gBAAK,IAC9F;AAAA,QACH,SACC;AAAA,UAAC;AAAA;AAAA,YACC,MAAK;AAAA,YACL,cAAY,aAAa,UAAU,QAAQ,aAAa,QAAQ;AAAA,YAChE,OAAO,aAAa,UAAU,QAAQ,aAAa,QAAQ;AAAA,YAC3D,OAAO,EAAE,UAAU,MAAM,OAAO,IAAI,kBAAkB,GAAG,YAAY,SAAS,CAAC,EAAE;AAAA,YAEhF,iBAAO,QAAQ;AAAA;AAAA,QAClB,IACE;AAAA;AAAA;AAAA,EACN;AAEJ;AAGO,SAAS,WAAW,EAAE,QAAQ,GAAwB;AAC3D,SACE;AAAA,IAAC;AAAA;AAAA,MACC,oBAAiB;AAAA,MACjB,OAAO;AAAA,QACL,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,gBAAgB;AAAA,QAChB,QAAQ;AAAA,QACR,WAAW;AAAA,QACX,OAAO,IAAI,kBAAkB;AAAA,QAC7B,UAAU,QAAQ,IAAI;AAAA,QACtB,cAAc;AAAA,MAChB;AAAA,MAEC;AAAA;AAAA,EACH;AAEJ;",
+  "names": []
+}

package/dist/chunks/chunk-YPFB6DAL.js

@@ -0,0 +1,157 @@
+// src/widgets/command-status.ts
+import { isTerminalCommandStatus } from "@devicechain/dashboards";
+var STATUS_COLORS = {
+  SUCCESSFUL: "#16a34a",
+  // green-600 — acknowledged by the device
+  FAILED: "#dc2626",
+  // red-600
+  TIMEOUT: "#dc2626",
+  // red-600 — never acknowledged in time
+  EXPIRED: "#64748b",
+  // slate-500 — lapsed before it was ever sent
+  CANCELLED: "#7c3aed",
+  // violet-600 — deliberately called off; a decision, not a failure
+  QUEUED: "#0284c7",
+  // sky-600 — in flight
+  SENT: "#0284c7",
+  HELD: "#d97706",
+  // amber-600 — withheld: the device is absent, the command still stands
+  PARKED: "#f59e0b"
+  // amber-500 — published, nobody home; held for the device's return
+};
+var UNKNOWN_COLOR = "#64748b";
+function commandStatusColor(status) {
+  return STATUS_COLORS[status] ?? UNKNOWN_COLOR;
+}
+function isTerminalStatus(status) {
+  return isTerminalCommandStatus(status);
+}
+function commandStatusLabel(status) {
+  if (!status) return "";
+  return status.charAt(0).toUpperCase() + status.slice(1).toLowerCase();
+}
+
+// src/widgets/command-params.ts
+var DATA_TYPES = /* @__PURE__ */ new Set(["DOUBLE", "INT", "BOOLEAN", "STRING"]);
+function parseParameterSchema(schema) {
+  if (!schema) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(schema);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  const out = [];
+  for (const raw of parsed) {
+    const norm = normalizeParam(raw);
+    if (norm) out.push(norm);
+  }
+  return out;
+}
+function normalizeParam(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const r = raw;
+  if (typeof r.name !== "string") return null;
+  const param = { name: r.name };
+  if (typeof r.description === "string") param.description = r.description;
+  if (r.kind === "OBJECT") param.kind = "OBJECT";
+  else if (r.kind === "SCALAR") param.kind = "SCALAR";
+  if (typeof r.dataType === "string" && DATA_TYPES.has(r.dataType)) {
+    param.dataType = r.dataType;
+  }
+  if (typeof r.unit === "string") param.unit = r.unit;
+  if (r.required === true) param.required = true;
+  if (typeof r.default === "string") param.default = r.default;
+  if (typeof r.minValue === "number" && Number.isFinite(r.minValue)) param.minValue = r.minValue;
+  if (typeof r.maxValue === "number" && Number.isFinite(r.maxValue)) param.maxValue = r.maxValue;
+  if (Array.isArray(r.enum)) {
+    const values = r.enum.filter((v) => typeof v === "string");
+    if (values.length > 0) param.enum = values;
+  }
+  return param;
+}
+function isScalar(param) {
+  return param.kind !== "OBJECT";
+}
+function parseBool(raw) {
+  const s = raw.trim().toLowerCase();
+  return s === "true" || s === "1" || s === "t" || s === "yes" || s === "on";
+}
+function defaultValues(params) {
+  const values = {};
+  for (const p of params) {
+    if (!isScalar(p)) continue;
+    if (p.dataType === "BOOLEAN") values[p.name] = parseBool(p.default ?? "") ? "true" : "false";
+    else if (p.default != null) values[p.name] = p.default;
+  }
+  return values;
+}
+function validateParams(params, values) {
+  const errors = {};
+  for (const p of params) {
+    if (!isScalar(p)) {
+      if (p.required) errors[p.name] = "Structured parameter \u2014 not supported here";
+      continue;
+    }
+    if (p.dataType === "BOOLEAN") continue;
+    const raw = (values[p.name] ?? "").trim();
+    if (raw === "") {
+      if (p.required) errors[p.name] = "Required";
+      continue;
+    }
+    if (p.dataType === "INT" || p.dataType === "DOUBLE") {
+      const n = Number(raw);
+      if (!Number.isFinite(n)) {
+        errors[p.name] = "Must be a number";
+      } else if (p.dataType === "INT" && !Number.isInteger(n)) {
+        errors[p.name] = "Must be a whole number";
+      } else if (p.minValue != null && n < p.minValue) {
+        errors[p.name] = `Must be \u2265 ${p.minValue}`;
+      } else if (p.maxValue != null && n > p.maxValue) {
+        errors[p.name] = `Must be \u2264 ${p.maxValue}`;
+      }
+    }
+  }
+  return errors;
+}
+function buildPayload(params, values) {
+  const payload = {};
+  for (const p of params) {
+    if (!isScalar(p)) continue;
+    const raw = (values[p.name] ?? "").trim();
+    if (p.dataType === "BOOLEAN") {
+      payload[p.name] = parseBool(raw);
+      continue;
+    }
+    if (raw === "") continue;
+    payload[p.name] = coerce(p, raw);
+  }
+  return Object.keys(payload).length === 0 ? void 0 : JSON.stringify(payload);
+}
+function coerce(param, raw) {
+  switch (param.dataType) {
+    case "INT":
+    case "DOUBLE": {
+      const n = Number(raw);
+      return Number.isFinite(n) ? n : raw;
+    }
+    case "BOOLEAN":
+      return parseBool(raw);
+    default:
+      return raw;
+  }
+}
+
+export {
+  commandStatusColor,
+  isTerminalStatus,
+  commandStatusLabel,
+  parseParameterSchema,
+  isScalar,
+  parseBool,
+  defaultValues,
+  validateParams,
+  buildPayload
+};
+//# sourceMappingURL=chunk-YPFB6DAL.js.map

package/dist/chunks/chunk-YPFB6DAL.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/widgets/command-status.ts", "../../src/widgets/command-params.ts"],
+  "sourcesContent": ["// Copyright The DeviceChain Authors\n// SPDX-License-Identifier: Apache-2.0\n\n// Command delivery-status presentation for the command-button widget (command-delivery\n// lifecycle: QUEUED \u2192 SENT \u2192 SUCCESSFUL | FAILED, with HELD for a dispatch withheld from\n// a known-absent device, PARKED for one published to a device that turned out to be\n// unreachable, and TIMEOUT / EXPIRED / CANCELLED as the other terminals).\n// Status color is SEMANTIC (good/working/waiting/bad), deliberately fixed rather than\n// derived from the dashboard accent, so the same status reads the same on every theme \u2014\n// and it mirrors the console's DeviceCommandsPanel status variants (success /\n// destructive / outline / in-flight) so an operator reads the same signal on both\n// surfaces.\n\nimport { isTerminalCommandStatus } from '@devicechain/dashboards';\n\n// \uD83D\uDD34 EVERY STATUS NEEDS AN ENTRY, INCLUDING THE ONES THAT LOOK NEUTRAL. UNKNOWN_COLOR\n// below is the same slate as EXPIRED, so a status with no entry does not merely fall\n// back \u2014 it becomes INDISTINGUISHABLE from \"lapsed before it was sent\". HELD and PARKED\n// (the command is still coming) rendered in EXPIRED's slate tell an operator the opposite\n// of the truth, which is why they, and CANCELLED, are spelled out rather than left to the\n// fallback.\n//\n// The scheme is by MEANING, not by lifecycle position: sky = moving under its own steam,\n// amber = waiting on a device that isn't there. HELD and PARKED share the amber family\n// because they are the same answer to \"why hasn't it arrived?\" \u2014 the device is away \u2014 and\n// take different shades because they are different answers to \"what did the platform\n// already try?\": HELD never left the platform, PARKED was published and found nobody home.\nconst STATUS_COLORS: Record<string, string> = {\n  SUCCESSFUL: '#16a34a', // green-600 \u2014 acknowledged by the device\n  FAILED: '#dc2626', // red-600\n  TIMEOUT: '#dc2626', // red-600 \u2014 never acknowledged in time\n  EXPIRED: '#64748b', // slate-500 \u2014 lapsed before it was ever sent\n  CANCELLED: '#7c3aed', // violet-600 \u2014 deliberately called off; a decision, not a failure\n  QUEUED: '#0284c7', // sky-600 \u2014 in flight\n  SENT: '#0284c7',\n  HELD: '#d97706', // amber-600 \u2014 withheld: the device is absent, the command still stands\n  PARKED: '#f59e0b', // amber-500 \u2014 published, nobody home; held for the device's return\n};\n\nconst UNKNOWN_COLOR = '#64748b';\n\n// commandStatusColor maps a status to its badge color, falling back to muted slate for\n// an unrecognized value (a future/hand-edited status).\nexport function commandStatusColor(status: string): string {\n  return STATUS_COLORS[status] ?? UNKNOWN_COLOR;\n}\n\n// isTerminalStatus reports whether a command has reached a state it can't leave \u2014 the\n// widget stops treating it as in-flight.\n//\n// It is NOT the question \"can this still be cancelled?\": SENT is non-terminal and is not\n// cancellable, so a host gating a cancel control must ask @devicechain/dashboards'\n// isCancellableCommandStatus instead of negating this.\n//\n// It is an alias, not a second definition: the terminal set lives in @devicechain/dashboards\n// so the console, this package and the preview cannot disagree about it. The name is kept\n// because it is part of this package's published surface.\nexport function isTerminalStatus(status: string): boolean {\n  return isTerminalCommandStatus(status);\n}\n\n// commandStatusLabel renders a status in Title Case ('SUCCESSFUL' \u2192 'Successful').\nexport function commandStatusLabel(status: string): string {\n  if (!status) return '';\n  return status.charAt(0).toUpperCase() + status.slice(1).toLowerCase();\n}\n", "// Copyright The DeviceChain Authors\n// SPDX-License-Identifier: Apache-2.0\n\n// Pure form logic for the command-button widget's typed parameter form (ADR-043). The\n// console bakes a command definition's `parameterSchema` (a JSON string) into the\n// widget's options; these helpers parse it, seed defaults, validate operator input, and\n// serialize the typed values back to the JSON payload command-delivery sends the device.\n// Kept separate from the widget so the coercion/validation is unit-tested in isolation.\n//\n// SCOPE: the form types top-level SCALAR parameters (DOUBLE / INT / BOOLEAN / STRING,\n// with enum / bounds / required / default). OBJECT (nested) parameters are not\n// form-editable \u2014 the form blocks sending when one is REQUIRED (it can't be satisfied\n// here) and otherwise omits it. The payload is a flat JSON object keyed by parameter name.\n\nimport type { CommandParameter } from '@devicechain/dashboards';\n\nconst DATA_TYPES = new Set(['DOUBLE', 'INT', 'BOOLEAN', 'STRING']);\n\n// parseParameterSchema turns the baked JSON string into descriptors, defensively:\n// a null/empty/malformed schema (or a non-array root) yields an empty list so a command\n// with no arguments (or a hand-broken schema) renders as a bare Send button, never throws.\n// Each descriptor is NORMALIZED (enum\u2192string[], default\u2192string, bounds\u2192finite number,\n// kind/dataType\u2192known value) so a hand-edited dashboard definition with wrong-typed fields\n// (e.g. `enum: \"on\"` or `default: 5`) can't crash the form at render/send time.\nexport function parseParameterSchema(schema: string | null | undefined): CommandParameter[] {\n  if (!schema) return [];\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(schema);\n  } catch {\n    return [];\n  }\n  if (!Array.isArray(parsed)) return [];\n  const out: CommandParameter[] = [];\n  for (const raw of parsed) {\n    const norm = normalizeParam(raw);\n    if (norm) out.push(norm);\n  }\n  return out;\n}\n\n// normalizeParam validates one descriptor and coerces every field to its expected type,\n// dropping the descriptor entirely if it has no string `name`. Unknown/wrong-typed fields\n// are discarded rather than trusted, so downstream code never sees a non-array enum or a\n// numeric default.\nfunction normalizeParam(raw: unknown): CommandParameter | null {\n  if (typeof raw !== 'object' || raw === null) return null;\n  const r = raw as Record<string, unknown>;\n  if (typeof r.name !== 'string') return null;\n\n  const param: CommandParameter = { name: r.name };\n  if (typeof r.description === 'string') param.description = r.description;\n  if (r.kind === 'OBJECT') param.kind = 'OBJECT';\n  else if (r.kind === 'SCALAR') param.kind = 'SCALAR';\n  if (typeof r.dataType === 'string' && DATA_TYPES.has(r.dataType)) {\n    param.dataType = r.dataType as CommandParameter['dataType'];\n  }\n  if (typeof r.unit === 'string') param.unit = r.unit;\n  if (r.required === true) param.required = true;\n  if (typeof r.default === 'string') param.default = r.default;\n  if (typeof r.minValue === 'number' && Number.isFinite(r.minValue)) param.minValue = r.minValue;\n  if (typeof r.maxValue === 'number' && Number.isFinite(r.maxValue)) param.maxValue = r.maxValue;\n  if (Array.isArray(r.enum)) {\n    const values = r.enum.filter((v): v is string => typeof v === 'string');\n    if (values.length > 0) param.enum = values;\n  }\n  return param;\n}\n\n// isScalar reports whether a parameter is a typed single value the form renders an input\n// for. Kind absent means SCALAR (the Go default); only an explicit OBJECT is nested.\nexport function isScalar(param: CommandParameter): boolean {\n  return param.kind !== 'OBJECT';\n}\n\n// parseBool interprets a schema/string boolean the way the server's strconv.ParseBool\n// does (accepting '1'/'t'/'true'/'yes'/'on', case-insensitively) so a definition default\n// of \"True\" doesn't silently render \u2014 and send \u2014 as false.\nexport function parseBool(raw: string): boolean {\n  const s = raw.trim().toLowerCase();\n  return s === 'true' || s === '1' || s === 't' || s === 'yes' || s === 'on';\n}\n\n// defaultValues seeds the form's value map from each scalar parameter. A BOOLEAN always\n// gets a concrete 'true'/'false' (default false) \u2014 a checkbox is never \"empty\", so the\n// value must reflect the box's state exactly. Other scalars seed from their declared\n// default (as a string \u2014 inputs are string-backed), else start empty.\nexport function defaultValues(params: CommandParameter[]): Record<string, string> {\n  const values: Record<string, string> = {};\n  for (const p of params) {\n    if (!isScalar(p)) continue;\n    if (p.dataType === 'BOOLEAN') values[p.name] = parseBool(p.default ?? '') ? 'true' : 'false';\n    else if (p.default != null) values[p.name] = p.default;\n  }\n  return values;\n}\n\n// validateParams returns a per-parameter error map (empty = valid). It enforces required\n// (a missing value on a required scalar; a BOOLEAN always has a value so is never\n// \"required-missing\"), numeric validity/bounds for INT/DOUBLE, and blocks a REQUIRED\n// OBJECT parameter (it can't be supplied through the typed form).\nexport function validateParams(\n  params: CommandParameter[],\n  values: Record<string, string>,\n): Record<string, string> {\n  const errors: Record<string, string> = {};\n  for (const p of params) {\n    if (!isScalar(p)) {\n      // A required structured parameter can't be satisfied here \u2014 refuse to send an\n      // incomplete command rather than silently omitting it.\n      if (p.required) errors[p.name] = 'Structured parameter \u2014 not supported here';\n      continue;\n    }\n    if (p.dataType === 'BOOLEAN') continue; // a checkbox always carries a valid value\n    const raw = (values[p.name] ?? '').trim();\n    if (raw === '') {\n      if (p.required) errors[p.name] = 'Required';\n      continue; // an empty optional value is fine \u2014 it's just omitted from the payload\n    }\n    if (p.dataType === 'INT' || p.dataType === 'DOUBLE') {\n      const n = Number(raw);\n      if (!Number.isFinite(n)) {\n        errors[p.name] = 'Must be a number';\n      } else if (p.dataType === 'INT' && !Number.isInteger(n)) {\n        errors[p.name] = 'Must be a whole number';\n      } else if (p.minValue != null && n < p.minValue) {\n        errors[p.name] = `Must be \u2265 ${p.minValue}`;\n      } else if (p.maxValue != null && n > p.maxValue) {\n        errors[p.name] = `Must be \u2264 ${p.maxValue}`;\n      }\n    }\n  }\n  return errors;\n}\n\n// buildPayload serializes the typed values to the JSON payload string command-delivery\n// sends the device \u2014 coercing each scalar to its declared type (INT/DOUBLE \u2192 number,\n// BOOLEAN \u2192 boolean, STRING \u2192 string). A BOOLEAN is always included (its checkbox state\n// is meaningful); other empty optional values are omitted. OBJECT parameters are omitted\n// (validateParams blocks a required one first). Returns undefined when no parameter\n// contributes a value (a parameterless command sends no payload).\nexport function buildPayload(\n  params: CommandParameter[],\n  values: Record<string, string>,\n): string | undefined {\n  const payload: Record<string, unknown> = {};\n  for (const p of params) {\n    if (!isScalar(p)) continue;\n    const raw = (values[p.name] ?? '').trim();\n    if (p.dataType === 'BOOLEAN') {\n      payload[p.name] = parseBool(raw);\n      continue;\n    }\n    if (raw === '') continue;\n    payload[p.name] = coerce(p, raw);\n  }\n  return Object.keys(payload).length === 0 ? undefined : JSON.stringify(payload);\n}\n\nfunction coerce(param: CommandParameter, raw: string): unknown {\n  switch (param.dataType) {\n    case 'INT':\n    case 'DOUBLE': {\n      const n = Number(raw);\n      return Number.isFinite(n) ? n : raw; // validation gates this; fall back to raw defensively\n    }\n    case 'BOOLEAN':\n      return parseBool(raw);\n    default:\n      return raw; // STRING (and untyped)\n  }\n}\n"],
+  "mappings": ";AAaA,SAAS,+BAA+B;AAcxC,IAAM,gBAAwC;AAAA,EAC5C,YAAY;AAAA;AAAA,EACZ,QAAQ;AAAA;AAAA,EACR,SAAS;AAAA;AAAA,EACT,SAAS;AAAA;AAAA,EACT,WAAW;AAAA;AAAA,EACX,QAAQ;AAAA;AAAA,EACR,MAAM;AAAA,EACN,MAAM;AAAA;AAAA,EACN,QAAQ;AAAA;AACV;AAEA,IAAM,gBAAgB;AAIf,SAAS,mBAAmB,QAAwB;AACzD,SAAO,cAAc,MAAM,KAAK;AAClC;AAYO,SAAS,iBAAiB,QAAyB;AACxD,SAAO,wBAAwB,MAAM;AACvC;AAGO,SAAS,mBAAmB,QAAwB;AACzD,MAAI,CAAC,OAAQ,QAAO;AACpB,SAAO,OAAO,OAAO,CAAC,EAAE,YAAY,IAAI,OAAO,MAAM,CAAC,EAAE,YAAY;AACtE;;;ACjDA,IAAM,aAAa,oBAAI,IAAI,CAAC,UAAU,OAAO,WAAW,QAAQ,CAAC;AAQ1D,SAAS,qBAAqB,QAAuD;AAC1F,MAAI,CAAC,OAAQ,QAAO,CAAC;AACrB,MAAI;AACJ,MAAI;AACF,aAAS,KAAK,MAAM,MAAM;AAAA,EAC5B,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACA,MAAI,CAAC,MAAM,QAAQ,MAAM,EAAG,QAAO,CAAC;AACpC,QAAM,MAA0B,CAAC;AACjC,aAAW,OAAO,QAAQ;AACxB,UAAM,OAAO,eAAe,GAAG;AAC/B,QAAI,KAAM,KAAI,KAAK,IAAI;AAAA,EACzB;AACA,SAAO;AACT;AAMA,SAAS,eAAe,KAAuC;AAC7D,MAAI,OAAO,QAAQ,YAAY,QAAQ,KAAM,QAAO;AACpD,QAAM,IAAI;AACV,MAAI,OAAO,EAAE,SAAS,SAAU,QAAO;AAEvC,QAAM,QAA0B,EAAE,MAAM,EAAE,KAAK;AAC/C,MAAI,OAAO,EAAE,gBAAgB,SAAU,OAAM,cAAc,EAAE;AAC7D,MAAI,EAAE,SAAS,SAAU,OAAM,OAAO;AAAA,WAC7B,EAAE,SAAS,SAAU,OAAM,OAAO;AAC3C,MAAI,OAAO,EAAE,aAAa,YAAY,WAAW,IAAI,EAAE,QAAQ,GAAG;AAChE,UAAM,WAAW,EAAE;AAAA,EACrB;AACA,MAAI,OAAO,EAAE,SAAS,SAAU,OAAM,OAAO,EAAE;AAC/C,MAAI,EAAE,aAAa,KAAM,OAAM,WAAW;AAC1C,MAAI,OAAO,EAAE,YAAY,SAAU,OAAM,UAAU,EAAE;AACrD,MAAI,OAAO,EAAE,aAAa,YAAY,OAAO,SAAS,EAAE,QAAQ,EAAG,OAAM,WAAW,EAAE;AACtF,MAAI,OAAO,EAAE,aAAa,YAAY,OAAO,SAAS,EAAE,QAAQ,EAAG,OAAM,WAAW,EAAE;AACtF,MAAI,MAAM,QAAQ,EAAE,IAAI,GAAG;AACzB,UAAM,SAAS,EAAE,KAAK,OAAO,CAAC,MAAmB,OAAO,MAAM,QAAQ;AACtE,QAAI,OAAO,SAAS,EAAG,OAAM,OAAO;AAAA,EACtC;AACA,SAAO;AACT;AAIO,SAAS,SAAS,OAAkC;AACzD,SAAO,MAAM,SAAS;AACxB;AAKO,SAAS,UAAU,KAAsB;AAC9C,QAAM,IAAI,IAAI,KAAK,EAAE,YAAY;AACjC,SAAO,MAAM,UAAU,MAAM,OAAO,MAAM,OAAO,MAAM,SAAS,MAAM;AACxE;AAMO,SAAS,cAAc,QAAoD;AAChF,QAAM,SAAiC,CAAC;AACxC,aAAW,KAAK,QAAQ;AACtB,QAAI,CAAC,SAAS,CAAC,EAAG;AAClB,QAAI,EAAE,aAAa,UAAW,QAAO,EAAE,IAAI,IAAI,UAAU,EAAE,WAAW,EAAE,IAAI,SAAS;AAAA,aAC5E,EAAE,WAAW,KAAM,QAAO,EAAE,IAAI,IAAI,EAAE;AAAA,EACjD;AACA,SAAO;AACT;AAMO,SAAS,eACd,QACA,QACwB;AACxB,QAAM,SAAiC,CAAC;AACxC,aAAW,KAAK,QAAQ;AACtB,QAAI,CAAC,SAAS,CAAC,GAAG;AAGhB,UAAI,EAAE,SAAU,QAAO,EAAE,IAAI,IAAI;AACjC;AAAA,IACF;AACA,QAAI,EAAE,aAAa,UAAW;AAC9B,UAAM,OAAO,OAAO,EAAE,IAAI,KAAK,IAAI,KAAK;AACxC,QAAI,QAAQ,IAAI;AACd,UAAI,EAAE,SAAU,QAAO,EAAE,IAAI,IAAI;AACjC;AAAA,IACF;AACA,QAAI,EAAE,aAAa,SAAS,EAAE,aAAa,UAAU;AACnD,YAAM,IAAI,OAAO,GAAG;AACpB,UAAI,CAAC,OAAO,SAAS,CAAC,GAAG;AACvB,eAAO,EAAE,IAAI,IAAI;AAAA,MACnB,WAAW,EAAE,aAAa,SAAS,CAAC,OAAO,UAAU,CAAC,GAAG;AACvD,eAAO,EAAE,IAAI,IAAI;AAAA,MACnB,WAAW,EAAE,YAAY,QAAQ,IAAI,EAAE,UAAU;AAC/C,eAAO,EAAE,IAAI,IAAI,kBAAa,EAAE,QAAQ;AAAA,MAC1C,WAAW,EAAE,YAAY,QAAQ,IAAI,EAAE,UAAU;AAC/C,eAAO,EAAE,IAAI,IAAI,kBAAa,EAAE,QAAQ;AAAA,MAC1C;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAQO,SAAS,aACd,QACA,QACoB;AACpB,QAAM,UAAmC,CAAC;AAC1C,aAAW,KAAK,QAAQ;AACtB,QAAI,CAAC,SAAS,CAAC,EAAG;AAClB,UAAM,OAAO,OAAO,EAAE,IAAI,KAAK,IAAI,KAAK;AACxC,QAAI,EAAE,aAAa,WAAW;AAC5B,cAAQ,EAAE,IAAI,IAAI,UAAU,GAAG;AAC/B;AAAA,IACF;AACA,QAAI,QAAQ,GAAI;AAChB,YAAQ,EAAE,IAAI,IAAI,OAAO,GAAG,GAAG;AAAA,EACjC;AACA,SAAO,OAAO,KAAK,OAAO,EAAE,WAAW,IAAI,SAAY,KAAK,UAAU,OAAO;AAC/E;AAEA,SAAS,OAAO,OAAyB,KAAsB;AAC7D,UAAQ,MAAM,UAAU;AAAA,IACtB,KAAK;AAAA,IACL,KAAK,UAAU;AACb,YAAM,IAAI,OAAO,GAAG;AACpB,aAAO,OAAO,SAAS,CAAC,IAAI,IAAI;AAAA,IAClC;AAAA,IACA,KAAK;AACH,aAAO,UAAU,GAAG;AAAA,IACtB;AACE,aAAO;AAAA,EACX;AACF;",
+  "names": []
+}

package/dist/chunks/chunk-ZR74ORIT.js

@@ -0,0 +1,35 @@
+// src/value-scale.ts
+import { thresholdBands } from "@devicechain/widget-sdk";
+function readRange(configuredMin, configuredMax, fallback) {
+  const min = configuredMin ?? fallback?.min;
+  const max = configuredMax ?? fallback?.max;
+  if (min === void 0 || max === void 0) return { ok: false, reason: "missing" };
+  if (!(max > min)) return { ok: false, reason: "invalid" };
+  return { ok: true, range: { min, max } };
+}
+function fillOf(value, range) {
+  if (value == null || !Number.isFinite(value)) return void 0;
+  const ratio = (value - range.min) / (range.max - range.min);
+  const position = value < range.min ? "below" : value > range.max ? "above" : "within";
+  return { fraction: Math.min(1, Math.max(0, ratio)), position, ratio };
+}
+function bandSpans(thresholds, range) {
+  const width = range.max - range.min;
+  return thresholdBands(thresholds, range.min, range.max).map((b) => ({
+    from: (b.from - range.min) / width,
+    to: (b.to - range.min) / width,
+    level: b.level
+  }));
+}
+function litBars(thresholds, value) {
+  if (value == null || !Number.isFinite(value)) return void 0;
+  return { total: thresholds.length, lit: thresholds.filter((t) => value >= t.value).length };
+}
+
+export {
+  readRange,
+  fillOf,
+  bandSpans,
+  litBars
+};
+//# sourceMappingURL=chunk-ZR74ORIT.js.map

package/dist/chunks/chunk-ZR74ORIT.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/value-scale.ts"],
+  "sourcesContent": ["// Copyright The DeviceChain Authors\n// SPDX-License-Identifier: Apache-2.0\n\n// The arithmetic the level-and-indicator widgets share: reading a [min, max] scale off the\n// options, turning a value into a fill fraction, and laying threshold bands over the scale.\n// Pure and React-free, so every rule is asserted by value in value-scale.test.ts.\n//\n// \uD83D\uDD11 No range is ever invented. A widget that needs a scale either gets BOTH ends from its\n// options or from a fallback its descriptor documents (the battery's 0..100 percent); with\n// neither it reports why, and the widget renders that reason instead of a plausible fill.\n\nimport { thresholdBands, type SeverityLevel, type Threshold } from '@devicechain/widget-sdk';\n\nexport interface ScaleRange {\n  min: number;\n  max: number;\n}\n\nexport type RangeResult = { ok: true; range: ScaleRange } | { ok: false; reason: 'missing' | 'invalid' };\n\n// The scale from the two configured ends. With a `fallback`, an end left unset (undefined) takes\n// the fallback's (the documented default); without one, an unset end is `missing`. An inverted\n// or empty scale (max <= min) is `invalid`: a descriptor constraint says the same at authoring\n// time, but a hand-edited definition reaches the renderer without it.\nexport function readRange(configuredMin: number | undefined, configuredMax: number | undefined, fallback?: ScaleRange): RangeResult {\n  const min = configuredMin ?? fallback?.min;\n  const max = configuredMax ?? fallback?.max;\n  if (min === undefined || max === undefined) return { ok: false, reason: 'missing' };\n  if (!(max > min)) return { ok: false, reason: 'invalid' };\n  return { ok: true, range: { min, max } };\n}\n\nexport type ScalePosition = 'below' | 'within' | 'above';\n\nexport interface Fill {\n  // 0..1, clamped: what is drawn.\n  fraction: number;\n  // Where the value really is. Anything but `within` is marked on the widget, so a clamped fill\n  // is never mistaken for a value that sits exactly on the end.\n  position: ScalePosition;\n  // The unclamped (value - min) / (max - min), for a percent readout.\n  ratio: number;\n}\n\n// The fill for a value on a scale, or undefined with no usable value (null, NaN, +-Infinity).\nexport function fillOf(value: number | null | undefined, range: ScaleRange): Fill | undefined {\n  if (value == null || !Number.isFinite(value)) return undefined;\n  const ratio = (value - range.min) / (range.max - range.min);\n  const position: ScalePosition = value < range.min ? 'below' : value > range.max ? 'above' : 'within';\n  return { fraction: Math.min(1, Math.max(0, ratio)), position, ratio };\n}\n\nexport interface BandSpan {\n  // Fractions of the scale, 0..1.\n  from: number;\n  to: number;\n  level: SeverityLevel | undefined;\n}\n\n// The threshold bands as fractions of the scale: what a track draws behind the fill.\nexport function bandSpans(thresholds: readonly Threshold[], range: ScaleRange): BandSpan[] {\n  const width = range.max - range.min;\n  return thresholdBands(thresholds, range.min, range.max).map((b) => ({\n    from: (b.from - range.min) / width,\n    to: (b.to - range.min) / width,\n    level: b.level,\n  }));\n}\n\n// A signal strength as bars: one bar per threshold, lit for every threshold the value has\n// reached. Below the lowest threshold none is lit, which is a truthful \"no signal\", not a gap.\nexport function litBars(thresholds: readonly Threshold[], value: number | null | undefined): { total: number; lit: number } | undefined {\n  if (value == null || !Number.isFinite(value)) return undefined;\n  return { total: thresholds.length, lit: thresholds.filter((t) => value >= t.value).length };\n}\n"],
+  "mappings": ";AAWA,SAAS,sBAA0D;AAa5D,SAAS,UAAU,eAAmC,eAAmC,UAAoC;AAClI,QAAM,MAAM,iBAAiB,UAAU;AACvC,QAAM,MAAM,iBAAiB,UAAU;AACvC,MAAI,QAAQ,UAAa,QAAQ,OAAW,QAAO,EAAE,IAAI,OAAO,QAAQ,UAAU;AAClF,MAAI,EAAE,MAAM,KAAM,QAAO,EAAE,IAAI,OAAO,QAAQ,UAAU;AACxD,SAAO,EAAE,IAAI,MAAM,OAAO,EAAE,KAAK,IAAI,EAAE;AACzC;AAeO,SAAS,OAAO,OAAkC,OAAqC;AAC5F,MAAI,SAAS,QAAQ,CAAC,OAAO,SAAS,KAAK,EAAG,QAAO;AACrD,QAAM,SAAS,QAAQ,MAAM,QAAQ,MAAM,MAAM,MAAM;AACvD,QAAM,WAA0B,QAAQ,MAAM,MAAM,UAAU,QAAQ,MAAM,MAAM,UAAU;AAC5F,SAAO,EAAE,UAAU,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,KAAK,CAAC,GAAG,UAAU,MAAM;AACtE;AAUO,SAAS,UAAU,YAAkC,OAA+B;AACzF,QAAM,QAAQ,MAAM,MAAM,MAAM;AAChC,SAAO,eAAe,YAAY,MAAM,KAAK,MAAM,GAAG,EAAE,IAAI,CAAC,OAAO;AAAA,IAClE,OAAO,EAAE,OAAO,MAAM,OAAO;AAAA,IAC7B,KAAK,EAAE,KAAK,MAAM,OAAO;AAAA,IACzB,OAAO,EAAE;AAAA,EACX,EAAE;AACJ;AAIO,SAAS,QAAQ,YAAkC,OAA8E;AACtI,MAAI,SAAS,QAAQ,CAAC,OAAO,SAAS,KAAK,EAAG,QAAO;AACrD,SAAO,EAAE,OAAO,WAAW,QAAQ,KAAK,WAAW,OAAO,CAAC,MAAM,SAAS,EAAE,KAAK,EAAE,OAAO;AAC5F;",
+  "names": []
+}