@glasshome/widget-sdk 0.5.1 → 0.5.2

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;