@floegence/floe-webapp-core 0.1.0

package/dist/components/ui/Dialog.d.ts

@@ -0,0 +1,29 @@
+import { type JSX } from 'solid-js';
+export interface DialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title?: string;
+    description?: string;
+    children: JSX.Element;
+    footer?: JSX.Element;
+    class?: string;
+}
+/**
+ * Modal dialog component
+ */
+export declare function Dialog(props: DialogProps): JSX.Element;
+/**
+ * Confirm dialog helper
+ */
+export interface ConfirmDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    description?: string;
+    confirmText?: string;
+    cancelText?: string;
+    variant?: 'default' | 'destructive';
+    onConfirm: () => void | Promise<void>;
+    loading?: boolean;
+}
+export declare function ConfirmDialog(props: ConfirmDialogProps): JSX.Element;

package/dist/components/ui/Dropdown.d.ts

@@ -0,0 +1,35 @@
+import { type JSX } from 'solid-js';
+export interface DropdownItem {
+    id: string;
+    label: string;
+    icon?: () => JSX.Element;
+    disabled?: boolean;
+    separator?: boolean;
+}
+export interface DropdownProps {
+    trigger: JSX.Element;
+    items: DropdownItem[];
+    value?: string;
+    onSelect: (id: string) => void;
+    align?: 'start' | 'center' | 'end';
+    class?: string;
+}
+/**
+ * Dropdown menu component
+ */
+export declare function Dropdown(props: DropdownProps): JSX.Element;
+/**
+ * Simple select dropdown
+ */
+export interface SelectProps {
+    value: string;
+    onChange: (value: string) => void;
+    options: {
+        value: string;
+        label: string;
+    }[];
+    placeholder?: string;
+    disabled?: boolean;
+    class?: string;
+}
+export declare function Select(props: SelectProps): JSX.Element;

package/dist/components/ui/FloatingWindow.d.ts

@@ -0,0 +1,45 @@
+import { type JSX } from 'solid-js';
+export interface FloatingWindowProps {
+    /** Whether the window is open */
+    open: boolean;
+    /** Callback when window open state changes */
+    onOpenChange: (open: boolean) => void;
+    /** Window title */
+    title?: string;
+    /** Window content */
+    children: JSX.Element;
+    /** Optional footer content */
+    footer?: JSX.Element;
+    /** Default position (centered if not provided) */
+    defaultPosition?: {
+        x: number;
+        y: number;
+    };
+    /** Default size */
+    defaultSize?: {
+        width: number;
+        height: number;
+    };
+    /** Minimum window size */
+    minSize?: {
+        width: number;
+        height: number;
+    };
+    /** Maximum window size */
+    maxSize?: {
+        width: number;
+        height: number;
+    };
+    /** Whether the window can be resized */
+    resizable?: boolean;
+    /** Whether the window can be dragged */
+    draggable?: boolean;
+    /** Additional CSS class */
+    class?: string;
+    /** z-index for the window */
+    zIndex?: number;
+}
+/**
+ * Floating window component with drag, resize, maximize/restore functionality
+ */
+export declare function FloatingWindow(props: FloatingWindowProps): JSX.Element;

package/dist/components/ui/Input.d.ts

@@ -0,0 +1,16 @@
+import { type JSX } from 'solid-js';
+export type InputSize = 'sm' | 'md' | 'lg';
+export interface InputProps extends Omit<JSX.InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    size?: InputSize;
+    error?: string;
+    leftIcon?: JSX.Element;
+    rightIcon?: JSX.Element;
+}
+export declare function Input(props: InputProps): JSX.Element;
+/**
+ * Textarea variant
+ */
+export interface TextareaProps extends JSX.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    error?: string;
+}
+export declare function Textarea(props: TextareaProps): JSX.Element;

package/dist/components/ui/Tooltip.d.ts

@@ -0,0 +1,12 @@
+import { type JSX } from 'solid-js';
+export interface TooltipProps {
+    content: string | JSX.Element;
+    children: JSX.Element;
+    placement?: 'top' | 'bottom' | 'left' | 'right';
+    delay?: number;
+    class?: string;
+}
+/**
+ * Simple tooltip component
+ */
+export declare function Tooltip(props: TooltipProps): JSX.Element;

package/dist/components/ui/index.d.ts

@@ -0,0 +1,8 @@
+export { Button, type ButtonProps, type ButtonVariant, type ButtonSize } from './Button';
+export { Input, Textarea, type InputProps, type InputSize, type TextareaProps } from './Input';
+export { Dialog, ConfirmDialog, type DialogProps, type ConfirmDialogProps } from './Dialog';
+export { FloatingWindow, type FloatingWindowProps } from './FloatingWindow';
+export { Dropdown, Select, type DropdownProps, type DropdownItem, type SelectProps } from './Dropdown';
+export { Tooltip, type TooltipProps } from './Tooltip';
+export { CommandPalette } from './CommandPalette';
+export { Card, CardHeader, CardTitle, CardDescription, CardContent, CardFooter, Interactive3DCard, AnimatedBorderCard, NeonCard, MorphCard, type CardProps, type CardVariant, type CardHeaderProps, type CardTitleProps, type CardDescriptionProps, type CardContentProps, type CardFooterProps, type Interactive3DCardProps, type AnimatedBorderCardProps, type NeonCardProps, type MorphCardProps, } from './Card';

package/dist/context/CommandContext.d.ts

@@ -0,0 +1,30 @@
+import { type Accessor, type Component } from 'solid-js';
+export interface Command {
+    id: string;
+    title: string;
+    description?: string;
+    icon?: Component<{
+        class?: string;
+    }>;
+    keybind?: string;
+    category?: string;
+    execute: () => void | Promise<void>;
+}
+export interface CommandContextValue {
+    isOpen: Accessor<boolean>;
+    search: Accessor<string>;
+    commands: Accessor<Command[]>;
+    filteredCommands: Accessor<Command[]>;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    setSearch: (value: string) => void;
+    register: (command: Command) => () => void;
+    registerAll: (commands: Command[]) => () => void;
+    execute: (id: string) => void;
+    getKeybindDisplay: (keybind: string) => string;
+}
+export declare function createCommandService(): CommandContextValue;
+export declare const CommandProvider: (props: {
+    children: import("solid-js").JSX.Element;
+}) => import("solid-js").JSX.Element, useCommand: () => CommandContextValue;

package/dist/context/ComponentRegistry.d.ts

@@ -0,0 +1,90 @@
+import { type Accessor, type Component } from 'solid-js';
+import type { ThemeContextValue } from './ThemeContext';
+import type { LayoutContextValue } from './LayoutContext';
+import type { CommandContextValue } from './CommandContext';
+import type { NotificationContextValue } from './NotificationContext';
+/**
+ * Component registration system for pluggable architecture
+ * Designed to match `.design.md` 8.x: contributions + lifecycle + explicit mount/unmount.
+ */
+export interface Logger {
+    debug: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+}
+export interface ComponentStorage {
+    get: <T>(key: string, defaultValue: T) => T;
+    set: <T>(key: string, value: T) => void;
+    remove: (key: string) => void;
+}
+export interface ComponentContext<TProtocol = unknown> {
+    protocol?: TProtocol;
+    theme: ThemeContextValue;
+    layout: LayoutContextValue;
+    commands: CommandContextValue;
+    notifications: NotificationContextValue;
+    storage: ComponentStorage;
+    logger: Logger;
+}
+export interface CommandContribution<TProtocol = unknown> {
+    id: string;
+    title: string;
+    description?: string;
+    icon?: Component<{
+        class?: string;
+    }>;
+    keybind?: string;
+    category?: string;
+    execute: (ctx: ComponentContext<TProtocol>) => void | Promise<void>;
+}
+export interface StatusBarContribution {
+    id: string;
+    position: 'left' | 'right';
+    order?: number;
+    component: Component;
+}
+export interface FloeComponent<TProtocol = unknown> {
+    id: string;
+    name: string;
+    icon?: Component<{
+        class?: string;
+    }>;
+    description?: string;
+    component: Component;
+    sidebar?: {
+        order?: number;
+        badge?: () => number | string | undefined;
+        /** When true, this component uses the full content area without sidebar */
+        fullScreen?: boolean;
+        /** When true, this component is hidden in the activity bar on mobile */
+        hiddenOnMobile?: boolean;
+    };
+    commands?: CommandContribution<TProtocol>[];
+    statusBar?: StatusBarContribution[];
+    onMount?: (context: ComponentContext<TProtocol>) => void | Promise<void>;
+    onUnmount?: () => void | Promise<void>;
+}
+export interface ComponentRegistryValue<TProtocol = unknown> {
+    register: (component: FloeComponent<TProtocol>) => void;
+    registerAll: (componentList: FloeComponent<TProtocol>[]) => void;
+    unregister: (componentId: string) => Promise<void>;
+    mount: (componentId: string, context: ComponentContext<TProtocol>) => Promise<void>;
+    unmount: (componentId: string) => Promise<void>;
+    mountAll: (contextFactory: (componentId: string) => ComponentContext<TProtocol>) => Promise<void>;
+    unmountAll: () => Promise<void>;
+    components: Accessor<Map<string, FloeComponent<TProtocol>>>;
+    mountedComponents: Accessor<Set<string>>;
+    sidebarItems: Accessor<Array<FloeComponent<TProtocol> & {
+        order: number;
+    }>>;
+    allCommands: Accessor<CommandContribution<TProtocol>[]>;
+    statusBarItems: Accessor<StatusBarContribution[]>;
+    getComponent: (id: string) => FloeComponent<TProtocol> | undefined;
+}
+export declare function useComponentContextFactory<TProtocol = unknown>(): (componentId: string, extra?: Pick<ComponentContext<TProtocol>, "protocol">) => ComponentContext<TProtocol>;
+export declare const ComponentRegistryProvider: (props: {
+    children: import("solid-js").JSX.Element;
+}) => import("solid-js").JSX.Element;
+export declare function useComponentRegistry<TProtocol = unknown>(): ComponentRegistryValue<TProtocol>;
+export declare function createComponentRegistry(): ComponentRegistryValue<unknown>;

package/dist/context/DeckContext.d.ts

@@ -0,0 +1,88 @@
+import { type Accessor } from 'solid-js';
+import type { GridPosition } from '../utils/gridCollision';
+/**
+ * Widget instance on the deck
+ */
+export interface DeckWidget {
+    id: string;
+    type: string;
+    position: GridPosition;
+    config?: Record<string, unknown>;
+    title?: string;
+}
+/**
+ * Deck layout (saveable)
+ */
+export interface DeckLayout {
+    id: string;
+    name: string;
+    widgets: DeckWidget[];
+    isPreset?: boolean;
+    createdAt: number;
+    updatedAt: number;
+}
+/**
+ * Drag state for a widget being moved
+ */
+export interface DragState {
+    widgetId: string;
+    originalPosition: GridPosition;
+    currentPosition: GridPosition;
+    /** Pixel offset for smooth visual following */
+    pixelOffset: {
+        x: number;
+        y: number;
+    };
+    startX: number;
+    startY: number;
+}
+/**
+ * Resize state for a widget being resized
+ */
+export interface ResizeState {
+    widgetId: string;
+    edge: 'n' | 's' | 'e' | 'w' | 'ne' | 'nw' | 'se' | 'sw';
+    originalPosition: GridPosition;
+    currentPosition: GridPosition;
+    startX: number;
+    startY: number;
+}
+export interface DeckContextValue {
+    layouts: Accessor<DeckLayout[]>;
+    activeLayoutId: Accessor<string>;
+    activeLayout: Accessor<DeckLayout | undefined>;
+    setActiveLayout: (id: string) => void;
+    createLayout: (name: string, widgets?: DeckWidget[]) => DeckLayout;
+    duplicateLayout: (id: string, newName: string) => DeckLayout | undefined;
+    deleteLayout: (id: string) => void;
+    renameLayout: (id: string, name: string) => void;
+    editMode: Accessor<boolean>;
+    setEditMode: (enabled: boolean) => void;
+    toggleEditMode: () => void;
+    addWidget: (type: string, position?: Partial<GridPosition>, config?: Record<string, unknown>) => string | undefined;
+    removeWidget: (widgetId: string) => void;
+    updateWidgetPosition: (widgetId: string, position: GridPosition) => void;
+    updateWidgetConfig: (widgetId: string, config: Record<string, unknown>) => void;
+    updateWidgetTitle: (widgetId: string, title: string) => void;
+    /** Change widget type while preserving position */
+    changeWidgetType: (widgetId: string, newType: string) => void;
+    dragState: Accessor<DragState | null>;
+    startDrag: (widgetId: string, startX: number, startY: number) => void;
+    updateDrag: (currentPosition: GridPosition, pixelOffset: {
+        x: number;
+        y: number;
+    }) => void;
+    endDrag: (commit: boolean) => void;
+    resizeState: Accessor<ResizeState | null>;
+    startResize: (widgetId: string, edge: ResizeState['edge'], startX: number, startY: number) => void;
+    updateResize: (currentPosition: GridPosition) => void;
+    endResize: (commit: boolean) => void;
+    getWidgetMinConstraints: (type: string) => {
+        minColSpan: number;
+        minRowSpan: number;
+    };
+}
+export declare const DeckProvider: (props: {
+    children: import("solid-js").JSX.Element;
+}) => import("solid-js").JSX.Element, useDeck: () => DeckContextValue;
+export declare function createDeckService(): DeckContextValue;

package/dist/context/FloeConfigContext.d.ts

@@ -0,0 +1,133 @@
+import { type JSX } from 'solid-js';
+export interface FloeStorageAdapter {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+    removeItem: (key: string) => void;
+    /**
+     * Optional key listing for clearAll(). When not provided, clearAll becomes a no-op.
+     * This keeps custom adapters minimal while still supporting localStorage.
+     */
+    keys?: () => string[];
+}
+export interface FloeStorageConfig {
+    /** Namespace prefix for all persisted keys. */
+    namespace: string;
+    /** Disable all persistence when false. */
+    enabled: boolean;
+    /** Storage adapter (defaults to localStorage when available). */
+    adapter?: FloeStorageAdapter;
+}
+export interface FloeCommandsConfig {
+    /** Whether to install the global keydown listener. */
+    enableGlobalKeybinds: boolean;
+    /**
+     * When true, global keybinds are ignored while typing in form fields or contenteditable,
+     * unless the active element is inside an opt-in container (see allowWhenTypingWithin).
+     */
+    ignoreWhenTyping: boolean;
+    /** CSS selector to opt-in global keybinds while typing (e.g. code editor). */
+    allowWhenTypingWithin: string;
+    palette: {
+        /** Keybind to toggle the command palette. */
+        keybind: string;
+        enabled: boolean;
+    };
+    save: {
+        /**
+         * Whether to intercept the browser default save dialog (Cmd/Ctrl+S).
+         * When enabled, we still only run a command when saveCommandId exists.
+         */
+        enabled: boolean;
+        keybind: string;
+        /** Registered command id to run on save (default: file.save). */
+        commandId: string;
+        /**
+         * When true, preventDefault even if no save command is registered.
+         * This matches VSCode-style behavior for apps that manage their own saving.
+         */
+        preventDefaultWhenNoHandler: boolean;
+    };
+}
+export interface FloeLayoutConfig {
+    storageKey: string;
+    mobileQuery: string;
+    sidebar: {
+        defaultWidth: number;
+        clamp: {
+            min: number;
+            max: number;
+        };
+        defaultActiveTab: string;
+        defaultCollapsed: boolean;
+    };
+    terminal: {
+        defaultOpened: boolean;
+        defaultHeight: number;
+        clamp: {
+            min: number;
+            max: number;
+        };
+    };
+}
+export interface FloeThemeConfig {
+    storageKey: string;
+    defaultTheme: 'light' | 'dark' | 'system';
+}
+export interface FloeDeckConfig {
+    storageKey: string;
+}
+export interface FloeStrings {
+    topBar: {
+        searchPlaceholder: string;
+    };
+    commandPalette: {
+        placeholder: string;
+        empty: string;
+        esc: string;
+    };
+    confirmDialog: {
+        cancel: string;
+        confirm: string;
+    };
+    statusIndicator: {
+        connected: string;
+        disconnected: string;
+        connecting: string;
+        error: string;
+    };
+}
+export interface FloeConfig {
+    storage: FloeStorageConfig;
+    commands: FloeCommandsConfig;
+    layout: FloeLayoutConfig;
+    theme: FloeThemeConfig;
+    deck: FloeDeckConfig;
+    strings: FloeStrings;
+}
+export interface PersistApi {
+    key: (key: string) => string;
+    load: <T>(key: string, defaultValue: T) => T;
+    save: <T>(key: string, value: T) => void;
+    debouncedSave: <T>(key: string, value: T, delayMs?: number) => void;
+    remove: (key: string) => void;
+    clearAll: () => void;
+}
+export interface FloeConfigValue {
+    config: FloeConfig;
+    persist: PersistApi;
+}
+export type DeepPartial<T> = T extends (...args: never[]) => unknown ? T : T extends readonly (infer U)[] ? readonly U[] : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+export declare const DEFAULT_FLOE_CONFIG: FloeConfig;
+export interface FloeConfigProviderProps {
+    config?: DeepPartial<FloeConfig>;
+    children: JSX.Element;
+}
+export declare function FloeConfigProvider(props: FloeConfigProviderProps): JSX.Element;
+export declare function useFloeConfig(): FloeConfigValue;
+/**
+ * Safe accessor for internal services/tests. When the provider is missing,
+ * we fall back to DEFAULT_FLOE_CONFIG instead of throwing.
+ */
+export declare function useResolvedFloeConfig(): FloeConfigValue;

package/dist/context/LayoutContext.d.ts

@@ -0,0 +1,20 @@
+import { type Accessor } from 'solid-js';
+export interface LayoutContextValue {
+    sidebarWidth: Accessor<number>;
+    sidebarActiveTab: Accessor<string>;
+    sidebarCollapsed: Accessor<boolean>;
+    setSidebarWidth: (width: number) => void;
+    setSidebarActiveTab: (tab: string) => void;
+    setSidebarCollapsed: (collapsed: boolean) => void;
+    toggleSidebarCollapse: () => void;
+    terminalOpened: Accessor<boolean>;
+    terminalHeight: Accessor<number>;
+    toggleTerminal: () => void;
+    setTerminalHeight: (height: number) => void;
+    isMobile: Accessor<boolean>;
+    setIsMobile: (mobile: boolean) => void;
+}
+export declare const LayoutProvider: (props: {
+    children: import("solid-js").JSX.Element;
+}) => import("solid-js").JSX.Element, useLayout: () => LayoutContextValue;
+export declare function createLayoutService(): LayoutContextValue;

package/dist/context/NotificationContext.d.ts

@@ -0,0 +1,32 @@
+import { type Accessor } from 'solid-js';
+export type NotificationType = 'info' | 'success' | 'warning' | 'error';
+export interface Notification {
+    id: string;
+    type: NotificationType;
+    title: string;
+    message?: string;
+    duration?: number;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}
+export interface NotificationContextValue {
+    notifications: Accessor<Notification[]>;
+    show: (notification: Omit<Notification, 'id'>) => string;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+    info: (title: string, message?: string) => string;
+    success: (title: string, message?: string) => string;
+    warning: (title: string, message?: string) => string;
+    error: (title: string, message?: string) => string;
+}
+export declare function createNotificationService(): NotificationContextValue;
+export declare const NotificationProvider: (props: {
+    children: import("solid-js").JSX.Element;
+}) => import("solid-js").JSX.Element, useNotification: () => NotificationContextValue;
+/**
+ * Notification toast container component
+ * Place this at the root of your app
+ */
+export declare function NotificationContainer(): import("solid-js").JSX.Element;

package/dist/context/ThemeContext.d.ts

@@ -0,0 +1,12 @@
+import { type Accessor } from 'solid-js';
+import { type ThemeType } from '../styles/themes';
+export interface ThemeContextValue {
+    theme: Accessor<ThemeType>;
+    resolvedTheme: Accessor<'light' | 'dark'>;
+    setTheme: (theme: ThemeType) => void;
+    toggleTheme: () => void;
+}
+export declare function createThemeService(): ThemeContextValue;
+export declare const ThemeProvider: (props: {
+    children: import("solid-js").JSX.Element;
+}) => import("solid-js").JSX.Element, useTheme: () => ThemeContextValue;

package/dist/context/WidgetRegistry.d.ts

@@ -0,0 +1,37 @@
+import { type Accessor, type Component } from 'solid-js';
+/**
+ * Widget type definition for the dashboard
+ */
+export interface WidgetDefinition {
+    type: string;
+    name: string;
+    icon?: Component<{
+        class?: string;
+    }>;
+    category: 'sidebar' | 'metrics' | 'terminal' | 'custom';
+    component: Component<WidgetProps>;
+    minColSpan?: number;
+    minRowSpan?: number;
+    defaultColSpan?: number;
+    defaultRowSpan?: number;
+}
+/**
+ * Props passed to widget components
+ */
+export interface WidgetProps {
+    widgetId: string;
+    config?: Record<string, unknown>;
+    isEditMode?: boolean;
+}
+export interface WidgetRegistryValue {
+    register: (widget: WidgetDefinition) => void;
+    registerAll: (widgets: WidgetDefinition[]) => void;
+    unregister: (type: string) => void;
+    widgets: Accessor<Map<string, WidgetDefinition>>;
+    getWidget: (type: string) => WidgetDefinition | undefined;
+    getWidgetsByCategory: (category: WidgetDefinition['category']) => WidgetDefinition[];
+}
+export declare const WidgetRegistryProvider: (props: {
+    children: import("solid-js").JSX.Element;
+}) => import("solid-js").JSX.Element, useWidgetRegistry: () => WidgetRegistryValue;
+export declare function createWidgetRegistry(): WidgetRegistryValue;

package/dist/context/createSimpleContext.d.ts

@@ -0,0 +1,15 @@
+import { type JSX } from 'solid-js';
+/**
+ * Factory for creating simple context providers
+ * Follows the pattern from opencode implementation
+ */
+export declare function createSimpleContext<T>(options: {
+    name: string;
+    init: () => T;
+}): {
+    Provider: (props: {
+        children: JSX.Element;
+    }) => JSX.Element;
+    use: () => T;
+    Context: import("solid-js").Context<T | undefined>;
+};

package/dist/context/index.d.ts

@@ -0,0 +1,9 @@
+export { createSimpleContext } from './createSimpleContext';
+export { FloeConfigProvider, useFloeConfig, useResolvedFloeConfig, DEFAULT_FLOE_CONFIG, type FloeConfig, type FloeConfigValue, type DeepPartial, type FloeStorageAdapter, type PersistApi, } from './FloeConfigContext';
+export { ThemeProvider, useTheme, createThemeService, type ThemeContextValue } from './ThemeContext';
+export { LayoutProvider, useLayout, createLayoutService, type LayoutContextValue } from './LayoutContext';
+export { CommandProvider, useCommand, createCommandService, type Command, type CommandContextValue } from './CommandContext';
+export { NotificationProvider, useNotification, createNotificationService, NotificationContainer, type Notification, type NotificationType, type NotificationContextValue, } from './NotificationContext';
+export { ComponentRegistryProvider, useComponentRegistry, useComponentContextFactory, createComponentRegistry, type FloeComponent, type ComponentContext, type CommandContribution, type StatusBarContribution, type ComponentRegistryValue, } from './ComponentRegistry';
+export { WidgetRegistryProvider, useWidgetRegistry, createWidgetRegistry, type WidgetDefinition, type WidgetProps, type WidgetRegistryValue, } from './WidgetRegistry';
+export { DeckProvider, useDeck, createDeckService, type DeckWidget, type DeckLayout, type DragState, type ResizeState, type DeckContextValue, } from './DeckContext';

package/dist/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export { useMediaQuery } from './useMediaQuery';
+export { useDebounce } from './useDebounce';
+export { useResizeObserver, type Size } from './useResizeObserver';
+export { useKeybind } from './useKeybind';
+export { usePersisted } from './usePersisted';
+export { useDeckDrag } from './useDeckDrag';

package/dist/hooks/useDebounce.d.ts

@@ -0,0 +1,5 @@
+import { type Accessor } from 'solid-js';
+/**
+ * Debounced signal value
+ */
+export declare function useDebounce<T>(value: Accessor<T>, delay: number): Accessor<T>;

package/dist/hooks/useDeckDrag.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hook to set up drag handling for deck widgets
+ * Listens for pointer events on elements with data-widget-drag-handle attribute
+ * Only active when edit mode is enabled
+ */
+export declare function useDeckDrag(): void;

package/dist/hooks/useKeybind.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Global keybind listener
+ */
+export declare function useKeybind(keybind: string, callback: () => void): void;

package/dist/hooks/useMediaQuery.d.ts

@@ -0,0 +1,5 @@
+import { type Accessor } from 'solid-js';
+/**
+ * Reactive media query hook
+ */
+export declare function useMediaQuery(query: string): Accessor<boolean>;

package/dist/hooks/usePersisted.d.ts

@@ -0,0 +1,5 @@
+import { type Accessor } from 'solid-js';
+/**
+ * Persisted signal using Floe's configured persistence (storage adapter + namespace).
+ */
+export declare function usePersisted<T>(key: string, defaultValue: T): [Accessor<T>, (value: T) => void];