@devicechain/widget-sdk 0.0.0-bootstrap.0 → 0.0.0-stage

package/dist/index.js

@@ -1,546 +0,0 @@
-import {
-  WidgetCandidatesProvider,
-  WidgetSelectProvider,
-  WidgetSubjectProvider,
-  WidgetThemeRootProvider,
-  WidgetTimeZoneProvider,
-  useWidgetCandidates,
-  useWidgetSelect,
-  useWidgetSubject,
-  useWidgetThemeRoot,
-  useWidgetTimeZone
-} from "./chunks/chunk-CC2V7LVI.js";
-
-// src/define-widget.ts
-function defineWidget(definition) {
-  return definition;
-}
-
-// src/registry.ts
-import {
-  WidgetCatalogError,
-  collectCatalogIssues,
-  createWidgetCatalog
-} from "@devicechain/dashboards";
-var WidgetRegistryError = class extends WidgetCatalogError {
-  constructor(issues) {
-    super(issues, "widget registry");
-    this.name = "WidgetRegistryError";
-  }
-};
-function isComponent(value) {
-  if (typeof value === "function") return true;
-  return typeof value === "object" && value !== null && "$$typeof" in value;
-}
-function createWidgetRegistry(definitions) {
-  if (!Array.isArray(definitions)) {
-    throw new WidgetRegistryError([{ id: "#?", path: "", message: "definitions must be an array" }]);
-  }
-  const issues = collectCatalogIssues(definitions.map((d) => d?.descriptor));
-  definitions.forEach((definition, index) => {
-    const id = definition?.descriptor?.id;
-    const label = typeof id === "string" && id !== "" ? id : `#${index}`;
-    const add = (path, message) => {
-      issues.push({ id: label, path, message });
-    };
-    const impl = definition?.implementation;
-    if (typeof impl !== "object" || impl === null) {
-      add("implementation", "a definition needs an implementation");
-      return;
-    }
-    if (impl.kind !== "trusted-react") {
-      add("implementation.kind", `kind must be "trusted-react", got ${JSON.stringify(impl.kind)}`);
-    }
-    if (!isComponent(impl.component)) add("implementation.component", "component must be a React component");
-    if (impl.editor !== void 0 && !isComponent(impl.editor)) {
-      add("implementation.editor", "editor, when given, must be a React component");
-    }
-  });
-  if (issues.length > 0) throw new WidgetRegistryError(issues);
-  const catalog = createWidgetCatalog(definitions.map((d) => d.descriptor));
-  const byId = /* @__PURE__ */ new Map();
-  for (const definition of definitions) {
-    byId.set(
-      definition.descriptor.id,
-      Object.freeze({
-        descriptor: catalog.get(definition.descriptor.id),
-        implementation: Object.freeze({ ...definition.implementation })
-      })
-    );
-  }
-  const ordered = Object.freeze([...byId.values()]);
-  return Object.freeze({
-    catalog,
-    descriptor: (id) => catalog.get(id),
-    implementation: (id) => byId.get(id)?.implementation,
-    list: () => ordered
-  });
-}
-
-// src/theme.ts
-function css(name) {
-  return `hsl(var(--${name}))`;
-}
-
-// src/frame.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
-function WidgetFrame({ title, subtitle, children, bodyStyle }) {
-  const subject = useWidgetSubject();
-  const sub = subtitle ?? subject;
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      style: {
-        display: "flex",
-        flexDirection: "column",
-        width: "100%",
-        height: "100%",
-        boxSizing: "border-box",
-        background: css("card"),
-        color: css("card-foreground"),
-        border: `1px solid ${css("border")}`,
-        borderRadius: "var(--radius, 8px)",
-        overflow: "hidden"
-      },
-      children: [
-        title || sub ? /* @__PURE__ */ jsxs(
-          "div",
-          {
-            style: {
-              padding: "8px 12px",
-              borderBottom: `1px solid ${css("border")}`
-            },
-            children: [
-              title ? /* @__PURE__ */ jsx("div", { style: { fontSize: 12, fontWeight: 600, color: css("muted-foreground") }, children: title }) : null,
-              sub ? /* @__PURE__ */ jsx(
-                "div",
-                {
-                  title: sub,
-                  style: {
-                    fontSize: 11,
-                    fontWeight: 400,
-                    color: css("muted-foreground"),
-                    opacity: 0.75,
-                    marginTop: title ? 2 : 0,
-                    whiteSpace: "nowrap",
-                    overflow: "hidden",
-                    textOverflow: "ellipsis"
-                  },
-                  children: sub
-                }
-              ) : null
-            ]
-          }
-        ) : null,
-        /* @__PURE__ */ jsx("div", { style: { flex: 1, minHeight: 0, ...bodyStyle }, children })
-      ]
-    }
-  );
-}
-
-// src/format.ts
-function formatTimestamp(iso, timeZone) {
-  if (!iso) return "";
-  const date = new Date(iso);
-  if (Number.isNaN(date.getTime())) return iso;
-  return timeZone ? date.toLocaleTimeString(void 0, { timeZone, timeZoneName: "short" }) : date.toLocaleTimeString();
-}
-function formatDateTime(iso, timeZone) {
-  if (!iso) return "";
-  const date = new Date(iso);
-  if (Number.isNaN(date.getTime())) return iso;
-  return timeZone ? date.toLocaleString(void 0, { timeZone, timeZoneName: "short" }) : date.toLocaleString();
-}
-function formatValue(value, precision) {
-  if (value == null) return "\u2014";
-  if (precision == null) return String(value);
-  const places = Math.min(100, Math.max(0, Math.trunc(precision)));
-  return value.toFixed(places);
-}
-
-// src/flash.tsx
-import { useEffect, useRef, useState } from "react";
-import { jsx as jsx2 } from "react/jsx-runtime";
-var UP = {
-  fg: "var(--flash-up, hsl(142 72% 40%))",
-  bg: "var(--flash-up-bg, hsl(142 72% 45% / 0.16))"
-};
-var DOWN = {
-  fg: "var(--flash-down, hsl(0 72% 51%))",
-  bg: "var(--flash-down-bg, hsl(0 72% 55% / 0.16))"
-};
-var HOLD_MS = 400;
-var FADE_MS = 600;
-function useFlashOnChange(value, enabled, identity) {
-  const prev = useRef(value);
-  const prevIdentity = useRef(identity);
-  const [direction, setDirection] = useState(null);
-  useEffect(() => {
-    const before = prev.current;
-    const sameEntity = prevIdentity.current === identity;
-    prev.current = value;
-    prevIdentity.current = identity;
-    if (!enabled || !sameEntity || typeof value !== "number" || typeof before !== "number" || !Number.isFinite(value) || !Number.isFinite(before) || value === before) {
-      setDirection(null);
-      return;
-    }
-    setDirection(value > before ? "up" : "down");
-    const timer = setTimeout(() => setDirection(null), HOLD_MS);
-    return () => clearTimeout(timer);
-  }, [value, enabled, identity]);
-  return enabled ? direction : null;
-}
-function flashTextStyle(direction, fadeMs = FADE_MS) {
-  if (direction) return { color: direction === "up" ? UP.fg : DOWN.fg, transition: "none" };
-  return { transition: `color ${fadeMs}ms ease-out` };
-}
-function flashBackgroundStyle(direction, fadeMs = FADE_MS) {
-  if (direction) {
-    return { backgroundColor: direction === "up" ? UP.bg : DOWN.bg, transition: "none" };
-  }
-  return { transition: `background-color ${fadeMs}ms ease-out` };
-}
-function FlashValue({
-  value,
-  precision,
-  enabled,
-  identity,
-  baseColor = "inherit",
-  style
-}) {
-  const direction = useFlashOnChange(value, enabled, identity);
-  return /* @__PURE__ */ jsx2("span", { style: { color: baseColor, ...style, ...flashTextStyle(direction) }, children: formatValue(value, precision) });
-}
-
-// src/widget-options.ts
-function pickSample(latest, name) {
-  return name ? latest[name] : Object.values(latest)[0];
-}
-function optString(options, key) {
-  const value = options?.[key];
-  return typeof value === "string" ? value : void 0;
-}
-function optNumber(options, key) {
-  const value = options?.[key];
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function optBoolean(options, key) {
-  return options?.[key] === true;
-}
-function primaryMeasurementName(widget) {
-  const explicit = optString(widget.options, "measurement");
-  if (explicit) return explicit;
-  const ds = widget.datasource;
-  if (ds && ds.measurements.length > 0) return ds.measurements[0];
-  return void 0;
-}
-
-// src/hooks.ts
-import {
-  bindingsWithoutScopedSlots,
-  DashboardHub,
-  hasScopedSlots,
-  resolveContextBindings,
-  resolveSlotCandidates
-} from "@devicechain/dashboards";
-import { useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState2 } from "react";
-function useDashboardHub(resolver, authorities) {
-  const authoritiesKey = JSON.stringify(authorities ?? []);
-  const hub = useMemo(
-    () => new DashboardHub({ resolver, authorities }),
-    // authorities read via authoritiesKey (value identity), not reference.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [resolver, authoritiesKey]
-  );
-  useEffect2(() => () => hub.disposeAll(), [hub]);
-  return hub;
-}
-function useResolvedBindings(definition, base, selection, resolver) {
-  const scoped = useMemo(() => hasScopedSlots(definition), [definition]);
-  const overlaid = useMemo(() => ({ ...base, ...selection }), [base, selection]);
-  const [resolved, setResolved] = useState2(() => bindingsWithoutScopedSlots(definition, overlaid));
-  const genRef = useRef2(0);
-  useEffect2(() => {
-    if (!scoped) {
-      setResolved((prev) => sameBindings(prev, overlaid) ? prev : overlaid);
-      return;
-    }
-    const gen = ++genRef.current;
-    let live = true;
-    resolveContextBindings(definition, base, selection, resolver).then((next) => {
-      if (!live || gen !== genRef.current) return;
-      setResolved((prev) => sameBindings(prev, next) ? prev : next);
-    }).catch(() => {
-    });
-    return () => {
-      live = false;
-    };
-  }, [scoped, definition, base, selection, resolver, overlaid]);
-  return scoped ? resolved : overlaid;
-}
-function sameBindings(a, b) {
-  const ak = Object.keys(a).sort();
-  const bk = Object.keys(b).sort();
-  if (ak.length !== bk.length) return false;
-  for (let i = 0; i < ak.length; i += 1) {
-    if (ak[i] !== bk[i]) return false;
-    if (JSON.stringify(a[ak[i]]) !== JSON.stringify(b[bk[i]])) return false;
-  }
-  return true;
-}
-function useSlotCandidates(definition, bindings, resolver, lister) {
-  const bindingsKey = JSON.stringify(bindings);
-  return useMemo(
-    () => {
-      if (!lister) return void 0;
-      return (slot) => resolveSlotCandidates(definition, slot, bindings, resolver, lister);
-    },
-    // bindings read via bindingsKey (value identity), not reference.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [definition, bindingsKey, resolver, lister]
-  );
-}
-function useCandidates(slot) {
-  const provider = useWidgetCandidates();
-  const wired = !!provider;
-  const [state, setState] = useState2(() => ({
-    candidates: [],
-    loading: Boolean(provider && slot),
-    error: null
-  }));
-  const genRef = useRef2(0);
-  useEffect2(() => {
-    if (!provider || !slot) {
-      setState({ candidates: [], loading: false, error: null });
-      return;
-    }
-    const gen = ++genRef.current;
-    let live = true;
-    setState((prev) => ({ ...prev, loading: true, error: null }));
-    provider(slot).then((candidates) => {
-      if (live && gen === genRef.current) setState({ candidates, loading: false, error: null });
-    }).catch((error) => {
-      if (live && gen === genRef.current) setState({ candidates: [], loading: false, error });
-    });
-    return () => {
-      live = false;
-    };
-  }, [provider, slot]);
-  return { ...state, wired };
-}
-var EMPTY = { latest: {}, samples: [], error: null };
-function latestOf(samples) {
-  const latest = {};
-  for (const s of samples) latest[s.name] = s;
-  return latest;
-}
-function useMeasurementStream(hub, datasource, options = {}) {
-  const windowSize = options.window ?? 300;
-  const initialSamples = options.initialSamples;
-  const key = datasource ? JSON.stringify(datasource) : null;
-  const [tagged, setTagged] = useState2({
-    key,
-    state: EMPTY
-  });
-  const live = tagged.key === key ? tagged.state : EMPTY;
-  useEffect2(() => {
-    setTagged({ key, state: EMPTY });
-    if (!datasource) return;
-    const update = (fn) => setTagged((prev) => prev.key === key ? { key, state: fn(prev.state) } : prev);
-    return hub.subscribeWidget(datasource, {
-      next: (sample) => update((prev) => {
-        const samples = prev.samples.concat(sample);
-        if (samples.length > windowSize) samples.splice(0, samples.length - windowSize);
-        return { latest: { ...prev.latest, [sample.name]: sample }, samples, error: null };
-      }),
-      error: (err) => update((prev) => ({ ...prev, error: err }))
-    });
-  }, [hub, key, windowSize]);
-  return useMemo(() => {
-    if (!initialSamples || initialSamples.length === 0) return live;
-    const merged = initialSamples.concat(live.samples);
-    const samples = merged.length > windowSize ? merged.slice(merged.length - windowSize) : merged;
-    return {
-      latest: { ...latestOf(initialSamples), ...live.latest },
-      samples,
-      error: live.error
-    };
-  }, [initialSamples, live, windowSize]);
-}
-var EMPTY_ALARMS = { alarms: [], total: 0, loading: true, error: null };
-function useAlarmStream(hub, subscription) {
-  const [state, setState] = useState2(EMPTY_ALARMS);
-  const key = JSON.stringify(subscription);
-  useEffect2(() => {
-    setState(EMPTY_ALARMS);
-    return hub.subscribeAlarms(subscription, {
-      next: (snapshot) => setState({ alarms: snapshot.alarms, total: snapshot.total, loading: false, error: null }),
-      error: (err) => setState((prev) => ({ ...prev, loading: false, error: err }))
-    });
-  }, [hub, key]);
-  return state;
-}
-var EMPTY_COMMANDS = {
-  deviceToken: null,
-  commands: [],
-  total: 0,
-  loading: true,
-  error: null
-};
-function useCommandStream(hub, subscription) {
-  const [state, setState] = useState2(EMPTY_COMMANDS);
-  const key = JSON.stringify(subscription);
-  useEffect2(() => {
-    setState(EMPTY_COMMANDS);
-    return hub.subscribeCommands(subscription, {
-      next: (snapshot) => setState({
-        deviceToken: snapshot.deviceToken,
-        commands: snapshot.commands,
-        total: snapshot.total,
-        loading: false,
-        error: null
-      }),
-      error: (err) => setState((prev) => ({ ...prev, loading: false, error: err }))
-    });
-  }, [hub, key]);
-  return state;
-}
-var EMPTY_LOCATIONS = {
-  locations: [],
-  deviceTokens: [],
-  forbidden: false,
-  loading: true,
-  error: null
-};
-function useLocationStream(hub, subscription) {
-  const [state, setState] = useState2(EMPTY_LOCATIONS);
-  const key = JSON.stringify(subscription);
-  useEffect2(() => {
-    setState(EMPTY_LOCATIONS);
-    return hub.subscribeLocations(subscription, {
-      next: (snapshot) => setState(
-        snapshot.kind === "forbidden" ? { locations: [], deviceTokens: [], forbidden: true, loading: false, error: null } : {
-          locations: snapshot.locations,
-          deviceTokens: snapshot.deviceTokens,
-          forbidden: false,
-          loading: false,
-          error: null
-        }
-      ),
-      error: (err) => setState((prev) => ({ ...prev, loading: false, error: err }))
-    });
-  }, [hub, key]);
-  return state;
-}
-var AVAILABILITY_REVALIDATE_MS = 6e4;
-function useDatasourceAvailability(hub, datasource) {
-  const [state, setState] = useState2("unknown");
-  const key = datasource ? JSON.stringify(datasource) : null;
-  useEffect2(() => {
-    if (!datasource) {
-      setState("available");
-      return;
-    }
-    setState("unknown");
-    let cancelled = false;
-    let timer;
-    const stopTimer = () => {
-      if (timer) {
-        clearInterval(timer);
-        timer = void 0;
-      }
-    };
-    const check = () => {
-      hub.isDatasourceAvailable(datasource).then((ok) => {
-        if (cancelled) return;
-        setState(ok ? "available" : "unavailable");
-        if (ok) stopTimer();
-      }).catch(() => {
-        if (cancelled) return;
-        setState("available");
-        stopTimer();
-      });
-    };
-    check();
-    timer = setInterval(check, AVAILABILITY_REVALIDATE_MS);
-    return () => {
-      cancelled = true;
-      stopTimer();
-    };
-  }, [hub, key]);
-  return state;
-}
-function useElementSize() {
-  const ref = useRef2(null);
-  const [size, setSize] = useState2({ width: 0, height: 0 });
-  useEffect2(() => {
-    const el = ref.current;
-    if (!el || typeof ResizeObserver === "undefined") return;
-    const observer = new ResizeObserver((entries) => {
-      const rect = entries[0]?.contentRect;
-      if (!rect) return;
-      setSize(
-        (prev) => prev.width === rect.width && prev.height === rect.height ? prev : { width: rect.width, height: rect.height }
-      );
-    });
-    observer.observe(el);
-    return () => observer.disconnect();
-  }, []);
-  return [ref, size];
-}
-
-// src/index.ts
-import {
-  SDK_API_VERSION,
-  WidgetCatalogError as WidgetCatalogError2,
-  defineWidgetDescriptor,
-  isBuiltinWidgetId,
-  isNamespacedWidgetId,
-  validateWidgetDescriptor
-} from "@devicechain/dashboards";
-export {
-  FlashValue,
-  SDK_API_VERSION,
-  WidgetCandidatesProvider,
-  WidgetCatalogError2 as WidgetCatalogError,
-  WidgetFrame,
-  WidgetRegistryError,
-  WidgetSelectProvider,
-  WidgetSubjectProvider,
-  WidgetThemeRootProvider,
-  WidgetTimeZoneProvider,
-  createWidgetRegistry,
-  css,
-  defineWidget,
-  defineWidgetDescriptor,
-  flashBackgroundStyle,
-  flashTextStyle,
-  formatDateTime,
-  formatTimestamp,
-  formatValue,
-  isBuiltinWidgetId,
-  isNamespacedWidgetId,
-  optBoolean,
-  optNumber,
-  optString,
-  pickSample,
-  primaryMeasurementName,
-  useAlarmStream,
-  useCandidates,
-  useCommandStream,
-  useDashboardHub,
-  useDatasourceAvailability,
-  useElementSize,
-  useFlashOnChange,
-  useLocationStream,
-  useMeasurementStream,
-  useResolvedBindings,
-  useSlotCandidates,
-  useWidgetCandidates,
-  useWidgetSelect,
-  useWidgetSubject,
-  useWidgetThemeRoot,
-  useWidgetTimeZone,
-  validateWidgetDescriptor
-};
-//# sourceMappingURL=index.js.map