@glasshome/widget-sdk 0.5.1 → 1.0.0

package/dist/data.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Home Assistant data and service hooks, re-exported from
+ * @glasshome/sync-layer. Widgets must import these from the SDK instead of
+ * sync-layer directly: the single store instance lives in the host (via the
+ * import map), and a direct import would bundle a second, disconnected
+ * store. Phase 4 routes these through capability checks.
+ */
+export { getForecasts, getStream, getWebRtcClientConfig, sendWebRtcCandidate, startWebRtcSession, state, trackEntityHistory, untrackEntityHistory, } from "@glasshome/sync-layer";
+export type { AreaView } from "@glasshome/sync-layer";
+export { byDomain, useArea, useCamera, useConnection, useCurrency, useEntities, useEntity, useEntityHistory, useEntityStatistics, useForecast, useHassConfig, useLocale, useService, useStore, useTemperatureUnit, useToggle, useTurnOn, useUnitSystem, } from "@glasshome/sync-layer/solid";

package/dist/framework/dialogs/WidgetDialog.d.ts

@@ -21,6 +21,9 @@ export interface WidgetDialogProps {
     class?: string;
     maxWidth?: "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "4xl";
     defaultTab?: string;
+    /** Controlled active tab (pair with `onActiveTabChange`); overrides `defaultTab`. */
+    activeTab?: string;
+    onActiveTabChange?: (tab: string) => void;
     headerActions?: JSX.Element;
     configSchema?: ZodType;
     config?: Record<string, unknown>;

package/dist/framework/gestures/use-widget-gestures.d.ts

@@ -1,22 +1,9 @@
 /**
- * Widget Gestures Hook — Mobile-aware
+ * Widget Gestures Hook — tap, hold, and slide on every pointer type.
  *
- * Two grammars by pointer type:
- *
- *   TOUCH (phone, tablet):
- *     - tap    → primary action
- *     - hold   → detail dialog (with haptic bump)
- *     - slide  → DISABLED. Fine control lives in the detail dialog instead.
- *     This eliminates the slide-vs-page-scroll conflict that makes mobile
- *     gestures fragile. `touch-action: manipulation` ensures the browser
- *     handles scroll natively without our interference.
- *
- *   MOUSE / PEN (desktop, hybrid devices):
- *     - tap, hold, slide all active. Slide arms immediately on pointerdown —
- *     no scroll conflict to worry about (mouse uses wheel for scroll).
- *
- * Pointer type is decided per press at pointerdown. A hybrid device (tablet
- * + bluetooth mouse) gets the right grammar based on which input fired.
+ * Touch slide vs page scroll is split per axis: `touch-action` cedes the
+ * cross axis to the browser, and a press only commits to sliding when
+ * movement is dominantly on the slide axis.
  */
 import type { GestureConfig } from "../types";
 type GestureOrientation = "horizontal" | "vertical" | "square";
@@ -33,11 +20,7 @@ export interface GestureHandlers {
      * receives the pointer handlers.
      */
     bindElement: (el: HTMLElement) => void;
-    /**
-     * CSS `touch-action` for the gesture root. Always `manipulation` when any
-     * gesture is configured — mobile slide is intentionally dropped, so the
-     * browser owns scroll completely on touch surfaces.
-     */
+    /** CSS `touch-action` for the gesture root. */
     touchAction: () => string;
     /** Cancel any pending hold timer. Call on component unmount via onCleanup. */
     dispose: () => void;

package/dist/framework/hooks/use-widget-context.d.ts

@@ -20,6 +20,9 @@ export interface ReactiveWidgetContext {
     updateConfig: (config: Record<string, unknown>) => void;
     /** Measured shell dimensions in CSS px. (0,0) before first layout. */
     dimensions: () => WidgetDimensions;
+    /** Host RPC: `useWidgetDialog` registers its opener here so the host can
+        open the widget's dialog on a chosen tab. Called with `null` on cleanup. */
+    registerDialogOpener?: (open: ((tab?: string) => void) | null) => void;
 }
 export declare const WidgetCtx: import("solid-js").Context<ReactiveWidgetContext | undefined>;
 export declare function useWidgetContext(): ReactiveWidgetContext;

package/dist/framework/hooks/use-widget-dialog.d.ts

@@ -1,22 +1,22 @@
 /**
  * Widget Dialog Hook
  *
- * Provides signal-based dialog state management with optional tab tracking.
+ * Single source of truth for a widget's dialog state: open/closed and the
+ * active tab. Registers an imperative opener on the host context so the
+ * host can open the dialog on a chosen tab (e.g. dashboard edit mode
+ * opening "edit" directly).
  *
  * @example
  * ```tsx
  * function MyWidget() {
- *   const { showDialog, openDialog, closeDialog } = useWidgetDialog();
+ *   const { openDialog, dialogProps } = useWidgetDialog();
  *
  *   return (
  *     <>
  *       <Widget gestures={{ hold: { action: openDialog } }}>
  *         {/* widget content *\/}
  *       </Widget>
- *       <WidgetDialog
- *         open={showDialog()}
- *         onOpenChange={setShowDialog}
- *       />
+ *       <WidgetDialog {...dialogProps} />
  *     </>
  *   );
  * }
@@ -27,19 +27,27 @@ export interface WidgetDialogReturn {
     showDialog: () => boolean;
     /** Set dialog state directly */
     setShowDialog: (open: boolean) => void;
-    /** Open the dialog */
-    openDialog: () => void;
+    /** Open the dialog, optionally landing on a specific tab */
+    openDialog: (tab?: string) => void;
     /** Close the dialog */
     closeDialog: () => void;
     /** Current active tab accessor */
     activeTab: () => string;
     /** Set active tab */
     setActiveTab: (tab: string) => void;
+    /** Spread onto `<WidgetDialog>` to wire open + tab state. */
+    dialogProps: {
+        open: boolean;
+        onOpenChange: (open: boolean) => void;
+        activeTab: string;
+        onActiveTabChange: (tab: string) => void;
+    };
 }
 /**
  * Hook for managing widget dialog state
  *
- * @param defaultTab - Default active tab (default: "edit")
+ * @param defaultTab - Tab the dialog lands on when no explicit tab is
+ *   requested (default: "controls")
  * @returns Dialog state and control functions
  */
 export declare function useWidgetDialog(defaultTab?: string): WidgetDialogReturn;

package/dist/framework/theming/tokens.d.ts

@@ -2,7 +2,7 @@
  * Minimal document-shape needed for token injection. Allows tests to pass
  * a stub without a full DOM implementation.
  */
-interface InjectTokensRoot {
+export interface InjectTokensRoot {
     head: {
         appendChild: (node: unknown) => void;
         querySelector?: (sel: string) => unknown;
@@ -13,12 +13,17 @@ interface InjectTokensRoot {
     };
 }
 /**
- * Inject the SDK tokens stylesheet into <head>. Idempotent across:
+ * Inject the SDK tokens stylesheet into the widget's root.
+ *
+ * ShadowRoot: adopts a shared constructed CSSStyleSheet (one instance for
+ * all widget shadow roots), idempotent per root via WeakSet.
+ *
+ * Document (or no argument, legacy): appends a <style> to <head>.
+ * Idempotent across:
  *  - Repeated calls within the same module instance (boolean sentinel).
  *  - Multiple SDK module instances (DOM sentinel data-glasshome-tokens).
  *  - SSR / non-browser environments (no-op when document is undefined).
  */
-export declare function injectTokens(doc?: InjectTokensRoot): void;
+export declare function injectTokens(root?: Document | ShadowRoot): void;
 /** Test-only: reset the module-level sentinel. Not exported from the package root. */
 export declare function __resetInjectedForTests(): void;
-export {};

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { defineWidget } from "./define-widget";
+export * from "./data";
 export * from "./framework";
 export { monotoneCubicPath } from "./shared/spline";
 export { formatSchemaError, WidgetManifestSchema } from "./schemas";