@akashjs/runtime 0.2.2 → 0.2.7

package/dist/a11y.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkTDKDZ3QJ_cjs=require('./chunk-TDKDZ3QJ.cjs');require('./chunk-WOZWFMOK.cjs'),require('./chunk-XPLIEN2G.cjs');Object.defineProperty(exports,"useAnnounce",{enumerable:true,get:function(){return chunkTDKDZ3QJ_cjs.b}});Object.defineProperty(exports,"useFocusTrap",{enumerable:true,get:function(){return chunkTDKDZ3QJ_cjs.a}});Object.defineProperty(exports,"useKeyboard",{enumerable:true,get:function(){return chunkTDKDZ3QJ_cjs.c}});//# sourceMappingURL=a11y.cjs.map
+//# sourceMappingURL=a11y.cjs.map

package/dist/a11y.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"a11y.cjs"}

package/dist/a11y.d.cts

@@ -0,0 +1,99 @@
+import { R as ReadonlySignal } from './signals-DionyGGY.cjs';
+
+/**
+ * Accessibility composables.
+ *
+ * Built-in a11y primitives that no other framework ships natively.
+ * Focus management, screen reader announcements, and keyboard shortcuts.
+ */
+
+interface FocusTrapOptions {
+    /** CSS selector or element to focus initially (default: first focusable) */
+    initialFocus?: string | HTMLElement;
+    /** Return focus to the previously focused element on deactivate */
+    returnFocus?: boolean;
+    /** Escape key deactivates the trap (default: true) */
+    escapeDeactivates?: boolean;
+    /** Allow clicks outside the trap container (default: false) */
+    allowOutsideClick?: boolean;
+    /** Callback when Escape deactivates */
+    onDeactivate?: () => void;
+}
+interface FocusTrap {
+    /** Activate the focus trap */
+    activate(): void;
+    /** Deactivate the focus trap */
+    deactivate(): void;
+    /** Whether the trap is currently active */
+    active: ReadonlySignal<boolean>;
+}
+/**
+ * Trap focus inside a container element.
+ *
+ * ```ts
+ * const trap = useFocusTrap(dialogRef, {
+ *   initialFocus: '#first-input',
+ *   returnFocus: true,
+ *   escapeDeactivates: true,
+ * });
+ * trap.activate();   // on open
+ * trap.deactivate(); // on close
+ * ```
+ */
+declare function useFocusTrap(container: HTMLElement | (() => HTMLElement | null), options?: FocusTrapOptions): FocusTrap;
+type AriaLive = 'polite' | 'assertive' | 'off';
+/**
+ * Screen reader announcements via ARIA live regions.
+ *
+ * ```ts
+ * const announce = useAnnounce();
+ * announce('Page loaded: Dashboard');
+ * announce('Error: Invalid email', 'assertive');
+ * ```
+ */
+declare function useAnnounce(): (message: string, politeness?: AriaLive) => void;
+interface KeyBinding {
+    /** Key combo: 'mod+k', 'Escape', 'ArrowDown', 'shift+Enter' */
+    key: string;
+    /** Handler function */
+    handler: (e: KeyboardEvent) => void;
+    /** Optional scope (only active when scope is enabled) */
+    scope?: string;
+    /** Description for help dialog */
+    description?: string;
+    /** Prevent default browser behavior (default: true) */
+    preventDefault?: boolean;
+}
+interface KeyboardManager {
+    /** Register a binding */
+    bind(key: string, handler: (e: KeyboardEvent) => void, options?: {
+        scope?: string;
+        description?: string;
+        preventDefault?: boolean;
+    }): () => void;
+    /** Enable a scope */
+    enableScope(scope: string): void;
+    /** Disable a scope */
+    disableScope(scope: string): void;
+    /** Get all bindings (for help dialog) */
+    getBindings(): Array<{
+        key: string;
+        description: string;
+        scope?: string;
+    }>;
+    /** Dispose all bindings */
+    dispose(): void;
+}
+/**
+ * Keyboard shortcut manager with scope support.
+ *
+ * ```ts
+ * const kb = useKeyboard();
+ * kb.bind('mod+k', () => openSearch(), { description: 'Open search' });
+ * kb.bind('Escape', () => close(), { scope: 'modal' });
+ * kb.enableScope('modal');
+ * ```
+ */
+declare function useKeyboard(): KeyboardManager;
+
+export { type AriaLive, type FocusTrap, type FocusTrapOptions, type KeyBinding, type KeyboardManager, useAnnounce, useFocusTrap, useKeyboard };

package/dist/a11y.d.ts

@@ -0,0 +1,99 @@
+import { R as ReadonlySignal } from './signals-DionyGGY.js';
+
+/**
+ * Accessibility composables.
+ *
+ * Built-in a11y primitives that no other framework ships natively.
+ * Focus management, screen reader announcements, and keyboard shortcuts.
+ */
+
+interface FocusTrapOptions {
+    /** CSS selector or element to focus initially (default: first focusable) */
+    initialFocus?: string | HTMLElement;
+    /** Return focus to the previously focused element on deactivate */
+    returnFocus?: boolean;
+    /** Escape key deactivates the trap (default: true) */
+    escapeDeactivates?: boolean;
+    /** Allow clicks outside the trap container (default: false) */
+    allowOutsideClick?: boolean;
+    /** Callback when Escape deactivates */
+    onDeactivate?: () => void;
+}
+interface FocusTrap {
+    /** Activate the focus trap */
+    activate(): void;
+    /** Deactivate the focus trap */
+    deactivate(): void;
+    /** Whether the trap is currently active */
+    active: ReadonlySignal<boolean>;
+}
+/**
+ * Trap focus inside a container element.
+ *
+ * ```ts
+ * const trap = useFocusTrap(dialogRef, {
+ *   initialFocus: '#first-input',
+ *   returnFocus: true,
+ *   escapeDeactivates: true,
+ * });
+ * trap.activate();   // on open
+ * trap.deactivate(); // on close
+ * ```
+ */
+declare function useFocusTrap(container: HTMLElement | (() => HTMLElement | null), options?: FocusTrapOptions): FocusTrap;
+type AriaLive = 'polite' | 'assertive' | 'off';
+/**
+ * Screen reader announcements via ARIA live regions.
+ *
+ * ```ts
+ * const announce = useAnnounce();
+ * announce('Page loaded: Dashboard');
+ * announce('Error: Invalid email', 'assertive');
+ * ```
+ */
+declare function useAnnounce(): (message: string, politeness?: AriaLive) => void;
+interface KeyBinding {
+    /** Key combo: 'mod+k', 'Escape', 'ArrowDown', 'shift+Enter' */
+    key: string;
+    /** Handler function */
+    handler: (e: KeyboardEvent) => void;
+    /** Optional scope (only active when scope is enabled) */
+    scope?: string;
+    /** Description for help dialog */
+    description?: string;
+    /** Prevent default browser behavior (default: true) */
+    preventDefault?: boolean;
+}
+interface KeyboardManager {
+    /** Register a binding */
+    bind(key: string, handler: (e: KeyboardEvent) => void, options?: {
+        scope?: string;
+        description?: string;
+        preventDefault?: boolean;
+    }): () => void;
+    /** Enable a scope */
+    enableScope(scope: string): void;
+    /** Disable a scope */
+    disableScope(scope: string): void;
+    /** Get all bindings (for help dialog) */
+    getBindings(): Array<{
+        key: string;
+        description: string;
+        scope?: string;
+    }>;
+    /** Dispose all bindings */
+    dispose(): void;
+}
+/**
+ * Keyboard shortcut manager with scope support.
+ *
+ * ```ts
+ * const kb = useKeyboard();
+ * kb.bind('mod+k', () => openSearch(), { description: 'Open search' });
+ * kb.bind('Escape', () => close(), { scope: 'modal' });
+ * kb.enableScope('modal');
+ * ```
+ */
+declare function useKeyboard(): KeyboardManager;
+
+export { type AriaLive, type FocusTrap, type FocusTrapOptions, type KeyBinding, type KeyboardManager, useAnnounce, useFocusTrap, useKeyboard };

package/dist/a11y.js

@@ -0,0 +1,2 @@
+export{b as useAnnounce,a as useFocusTrap,c as useKeyboard}from'./chunk-L3ZZX36S.js';import'./chunk-YXKQTEPR.js';import'./chunk-U65WRXZC.js';//# sourceMappingURL=a11y.js.map
+//# sourceMappingURL=a11y.js.map

package/dist/a11y.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"a11y.js"}

package/dist/async-component.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkTFEHO7SF_cjs=require('./chunk-TFEHO7SF.cjs');require('./chunk-XWVNLE2W.cjs'),require('./chunk-IQGSDFBI.cjs'),require('./chunk-PPNEAFKE.cjs'),require('./chunk-WOZWFMOK.cjs'),require('./chunk-XPLIEN2G.cjs');Object.defineProperty(exports,"defineAsyncComponent",{enumerable:true,get:function(){return chunkTFEHO7SF_cjs.a}});//# sourceMappingURL=async-component.cjs.map
+//# sourceMappingURL=async-component.cjs.map

package/dist/async-component.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"async-component.cjs"}

package/dist/async-component.d.cts

@@ -0,0 +1,44 @@
+import { C as Component } from './component-CxlupKuc.cjs';
+import { A as AkashNode } from './types-DjZCk1xT.cjs';
+
+/**
+ * defineAsyncComponent — lazy component loading.
+ *
+ * Wraps a dynamic import() into a component that shows a loading
+ * state while the chunk downloads, an error state if it fails,
+ * and the real component once resolved.
+ *
+ * ```ts
+ * const LazyChart = defineAsyncComponent(() => import('./Chart.akash'));
+ *
+ * // With loading/error:
+ * const LazyChart = defineAsyncComponent({
+ *   loader: () => import('./Chart.akash'),
+ *   loading: () => <Spinner />,
+ *   error: (err) => <p>Failed: {err.message}</p>,
+ *   timeout: 10000,
+ * });
+ * ```
+ */
+
+type AsyncComponentLoader<P extends Record<string, unknown> = any> = () => Promise<{
+    default: Component<P>;
+}>;
+interface AsyncComponentOptions<P extends Record<string, unknown> = any> {
+    /** The async loader function (dynamic import) */
+    loader: AsyncComponentLoader<P>;
+    /** Component to show while loading */
+    loading?: () => AkashNode;
+    /** Component to show on error */
+    error?: (error: Error) => AkashNode;
+    /** Timeout in ms — show error after this (default: none) */
+    timeout?: number;
+    /** Delay in ms before showing loading state (default: 200) */
+    delay?: number;
+}
+/**
+ * Define a component that loads asynchronously via dynamic import.
+ */
+declare function defineAsyncComponent<P extends Record<string, unknown> = any>(loaderOrOptions: AsyncComponentLoader<P> | AsyncComponentOptions<P>): Component<P>;
+
+export { type AsyncComponentLoader, type AsyncComponentOptions, defineAsyncComponent };

package/dist/async-component.d.ts

@@ -0,0 +1,44 @@
+import { C as Component } from './component-CPVtkASo.js';
+import { A as AkashNode } from './types-DjZCk1xT.js';
+
+/**
+ * defineAsyncComponent — lazy component loading.
+ *
+ * Wraps a dynamic import() into a component that shows a loading
+ * state while the chunk downloads, an error state if it fails,
+ * and the real component once resolved.
+ *
+ * ```ts
+ * const LazyChart = defineAsyncComponent(() => import('./Chart.akash'));
+ *
+ * // With loading/error:
+ * const LazyChart = defineAsyncComponent({
+ *   loader: () => import('./Chart.akash'),
+ *   loading: () => <Spinner />,
+ *   error: (err) => <p>Failed: {err.message}</p>,
+ *   timeout: 10000,
+ * });
+ * ```
+ */
+
+type AsyncComponentLoader<P extends Record<string, unknown> = any> = () => Promise<{
+    default: Component<P>;
+}>;
+interface AsyncComponentOptions<P extends Record<string, unknown> = any> {
+    /** The async loader function (dynamic import) */
+    loader: AsyncComponentLoader<P>;
+    /** Component to show while loading */
+    loading?: () => AkashNode;
+    /** Component to show on error */
+    error?: (error: Error) => AkashNode;
+    /** Timeout in ms — show error after this (default: none) */
+    timeout?: number;
+    /** Delay in ms before showing loading state (default: 200) */
+    delay?: number;
+}
+/**
+ * Define a component that loads asynchronously via dynamic import.
+ */
+declare function defineAsyncComponent<P extends Record<string, unknown> = any>(loaderOrOptions: AsyncComponentLoader<P> | AsyncComponentOptions<P>): Component<P>;
+
+export { type AsyncComponentLoader, type AsyncComponentOptions, defineAsyncComponent };

package/dist/async-component.js

@@ -0,0 +1,2 @@
+export{a as defineAsyncComponent}from'./chunk-SXYPAP4B.js';import'./chunk-KE7BJTCD.js';import'./chunk-VUMMC2P5.js';import'./chunk-AOFLE33X.js';import'./chunk-YXKQTEPR.js';import'./chunk-U65WRXZC.js';//# sourceMappingURL=async-component.js.map
+//# sourceMappingURL=async-component.js.map

package/dist/async-component.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"async-component.js"}

package/dist/await-block.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkYURIYBTN_cjs=require('./chunk-YURIYBTN.cjs');require('./chunk-XWVNLE2W.cjs'),require('./chunk-IQGSDFBI.cjs'),require('./chunk-PPNEAFKE.cjs'),require('./chunk-WOZWFMOK.cjs'),require('./chunk-XPLIEN2G.cjs');Object.defineProperty(exports,"Await",{enumerable:true,get:function(){return chunkYURIYBTN_cjs.a}});Object.defineProperty(exports,"awaitSignal",{enumerable:true,get:function(){return chunkYURIYBTN_cjs.b}});//# sourceMappingURL=await-block.cjs.map
+//# sourceMappingURL=await-block.cjs.map

package/dist/await-block.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"await-block.cjs"}

package/dist/await-block.d.cts

@@ -0,0 +1,37 @@
+import { C as Component } from './component-CxlupKuc.cjs';
+import { A as AkashNode } from './types-DjZCk1xT.cjs';
+
+interface AwaitProps<T> {
+    /** The promise to await */
+    promise: Promise<T>;
+    /** Render while pending */
+    pending?: () => AkashNode;
+    /** Render when resolved */
+    then: (value: T) => AkashNode;
+    /** Render when rejected */
+    catch?: (error: Error) => AkashNode;
+}
+type AwaitState<T> = {
+    status: 'pending';
+} | {
+    status: 'resolved';
+    value: T;
+} | {
+    status: 'rejected';
+    error: Error;
+};
+/**
+ * <Await> component — declarative promise handling.
+ */
+declare const Await: Component<AwaitProps<any>>;
+/**
+ * Functional await block — returns a signal that updates as the promise resolves.
+ *
+ * ```ts
+ * const result = awaitSignal(fetchData());
+ * result().status; // 'pending' | 'resolved' | 'rejected'
+ * ```
+ */
+declare function awaitSignal<T>(promise: Promise<T>): () => AwaitState<T>;
+
+export { Await, type AwaitProps, awaitSignal };

package/dist/await-block.d.ts

@@ -0,0 +1,37 @@
+import { C as Component } from './component-CPVtkASo.js';
+import { A as AkashNode } from './types-DjZCk1xT.js';
+
+interface AwaitProps<T> {
+    /** The promise to await */
+    promise: Promise<T>;
+    /** Render while pending */
+    pending?: () => AkashNode;
+    /** Render when resolved */
+    then: (value: T) => AkashNode;
+    /** Render when rejected */
+    catch?: (error: Error) => AkashNode;
+}
+type AwaitState<T> = {
+    status: 'pending';
+} | {
+    status: 'resolved';
+    value: T;
+} | {
+    status: 'rejected';
+    error: Error;
+};
+/**
+ * <Await> component — declarative promise handling.
+ */
+declare const Await: Component<AwaitProps<any>>;
+/**
+ * Functional await block — returns a signal that updates as the promise resolves.
+ *
+ * ```ts
+ * const result = awaitSignal(fetchData());
+ * result().status; // 'pending' | 'resolved' | 'rejected'
+ * ```
+ */
+declare function awaitSignal<T>(promise: Promise<T>): () => AwaitState<T>;
+
+export { Await, type AwaitProps, awaitSignal };

package/dist/await-block.js

@@ -0,0 +1,2 @@
+export{a as Await,b as awaitSignal}from'./chunk-NJXXC5JB.js';import'./chunk-KE7BJTCD.js';import'./chunk-VUMMC2P5.js';import'./chunk-AOFLE33X.js';import'./chunk-YXKQTEPR.js';import'./chunk-U65WRXZC.js';//# sourceMappingURL=await-block.js.map
+//# sourceMappingURL=await-block.js.map

package/dist/await-block.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"await-block.js"}

package/dist/browser.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkR65RPMQX_cjs=require('./chunk-R65RPMQX.cjs');require('./chunk-WOZWFMOK.cjs'),require('./chunk-XPLIEN2G.cjs');Object.defineProperty(exports,"useBreakpoint",{enumerable:true,get:function(){return chunkR65RPMQX_cjs.b}});Object.defineProperty(exports,"useClickOutside",{enumerable:true,get:function(){return chunkR65RPMQX_cjs.h}});Object.defineProperty(exports,"useClipboard",{enumerable:true,get:function(){return chunkR65RPMQX_cjs.d}});Object.defineProperty(exports,"useGeolocation",{enumerable:true,get:function(){return chunkR65RPMQX_cjs.f}});Object.defineProperty(exports,"useMediaQuery",{enumerable:true,get:function(){return chunkR65RPMQX_cjs.a}});Object.defineProperty(exports,"useOnline",{enumerable:true,get:function(){return chunkR65RPMQX_cjs.e}});Object.defineProperty(exports,"useStorage",{enumerable:true,get:function(){return chunkR65RPMQX_cjs.c}});Object.defineProperty(exports,"useWindowSize",{enumerable:true,get:function(){return chunkR65RPMQX_cjs.g}});//# sourceMappingURL=browser.cjs.map
+//# sourceMappingURL=browser.cjs.map

package/dist/browser.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"browser.cjs"}

package/dist/browser.d.cts

@@ -0,0 +1,125 @@
+import { R as ReadonlySignal, S as Signal } from './signals-DionyGGY.cjs';
+
+/**
+ * Browser API composables.
+ *
+ * Signal-based wrappers for common browser APIs.
+ * All composables are SSR-safe — they return fallback values
+ * when `window` is not available.
+ */
+
+/**
+ * Reactive media query matcher.
+ *
+ * ```ts
+ * const isMobile = useMediaQuery('(max-width: 768px)');
+ * isMobile(); // true/false, updates on resize
+ * ```
+ */
+declare function useMediaQuery(query: string): ReadonlySignal<boolean>;
+interface Breakpoints {
+    [name: string]: number;
+}
+/**
+ * Reactive breakpoint tracker (Tailwind-style).
+ *
+ * ```ts
+ * const bp = useBreakpoint();
+ * bp.current();  // 'md'
+ * bp.gte('lg');  // false
+ * bp.lt('sm');   // false
+ * ```
+ */
+declare function useBreakpoint(breakpoints?: Breakpoints): {
+    current: () => string;
+    gte: (name: string) => boolean;
+    lt: (name: string) => boolean;
+    width: ReadonlySignal<number>;
+};
+/**
+ * Signal backed by localStorage or sessionStorage.
+ * Persists across page refreshes.
+ *
+ * ```ts
+ * const name = useStorage('user-name', 'Guest');
+ * name();       // reads from localStorage or 'Guest'
+ * name.set('Alice'); // writes to localStorage
+ * ```
+ */
+declare function useStorage<T>(key: string, initialValue: T, storage?: 'local' | 'session'): Signal<T>;
+/**
+ * Reactive clipboard access.
+ *
+ * ```ts
+ * const { text, copy, copied } = useClipboard();
+ * await copy('Hello');
+ * copied(); // true for 2 seconds
+ * ```
+ */
+declare function useClipboard(options?: {
+    timeout?: number;
+}): {
+    text: ReadonlySignal<string>;
+    copied: ReadonlySignal<boolean>;
+    copy: (value: string) => Promise<void>;
+};
+/**
+ * Reactive online/offline status.
+ *
+ * ```ts
+ * const online = useOnline();
+ * online(); // true/false
+ * ```
+ */
+declare function useOnline(): ReadonlySignal<boolean>;
+interface GeolocationState {
+    latitude: number | null;
+    longitude: number | null;
+    accuracy: number | null;
+    error: GeolocationPositionError | null;
+    loading: boolean;
+}
+/**
+ * Reactive geolocation.
+ *
+ * ```ts
+ * const geo = useGeolocation();
+ * geo().latitude;  // number | null
+ * geo().loading;   // boolean
+ * ```
+ */
+declare function useGeolocation(options?: PositionOptions): ReadonlySignal<GeolocationState>;
+/**
+ * Reactive window dimensions.
+ */
+declare function useWindowSize(): {
+    width: ReadonlySignal<number>;
+    height: ReadonlySignal<number>;
+};
+/**
+ * Detect clicks outside an element. Essential for closing
+ * dropdowns, modals, popovers, and context menus.
+ *
+ * ```ts
+ * const dropdown = document.querySelector('.dropdown')!;
+ * const dispose = useClickOutside(dropdown, () => {
+ *   closeDropdown();
+ * });
+ *
+ * // With options:
+ * useClickOutside(dropdown, onClose, {
+ *   events: ['mousedown', 'touchstart'],
+ *   ignore: ['.trigger-button'],
+ * });
+ * ```
+ */
+declare function useClickOutside(target: HTMLElement | (() => HTMLElement | null), handler: (event: Event) => void, options?: {
+    /** Events to listen for (default: ['pointerdown']) */
+    events?: string[];
+    /** Selectors or elements to ignore (clicks on these won't trigger) */
+    ignore?: (string | HTMLElement)[];
+    /** Whether the listener is active (default: true) */
+    active?: boolean;
+}): () => void;
+
+export { type Breakpoints, type GeolocationState, useBreakpoint, useClickOutside, useClipboard, useGeolocation, useMediaQuery, useOnline, useStorage, useWindowSize };

package/dist/browser.d.ts

@@ -0,0 +1,125 @@
+import { R as ReadonlySignal, S as Signal } from './signals-DionyGGY.js';
+
+/**
+ * Browser API composables.
+ *
+ * Signal-based wrappers for common browser APIs.
+ * All composables are SSR-safe — they return fallback values
+ * when `window` is not available.
+ */
+
+/**
+ * Reactive media query matcher.
+ *
+ * ```ts
+ * const isMobile = useMediaQuery('(max-width: 768px)');
+ * isMobile(); // true/false, updates on resize
+ * ```
+ */
+declare function useMediaQuery(query: string): ReadonlySignal<boolean>;
+interface Breakpoints {
+    [name: string]: number;
+}
+/**
+ * Reactive breakpoint tracker (Tailwind-style).
+ *
+ * ```ts
+ * const bp = useBreakpoint();
+ * bp.current();  // 'md'
+ * bp.gte('lg');  // false
+ * bp.lt('sm');   // false
+ * ```
+ */
+declare function useBreakpoint(breakpoints?: Breakpoints): {
+    current: () => string;
+    gte: (name: string) => boolean;
+    lt: (name: string) => boolean;
+    width: ReadonlySignal<number>;
+};
+/**
+ * Signal backed by localStorage or sessionStorage.
+ * Persists across page refreshes.
+ *
+ * ```ts
+ * const name = useStorage('user-name', 'Guest');
+ * name();       // reads from localStorage or 'Guest'
+ * name.set('Alice'); // writes to localStorage
+ * ```
+ */
+declare function useStorage<T>(key: string, initialValue: T, storage?: 'local' | 'session'): Signal<T>;
+/**
+ * Reactive clipboard access.
+ *
+ * ```ts
+ * const { text, copy, copied } = useClipboard();
+ * await copy('Hello');
+ * copied(); // true for 2 seconds
+ * ```
+ */
+declare function useClipboard(options?: {
+    timeout?: number;
+}): {
+    text: ReadonlySignal<string>;
+    copied: ReadonlySignal<boolean>;
+    copy: (value: string) => Promise<void>;
+};
+/**
+ * Reactive online/offline status.
+ *
+ * ```ts
+ * const online = useOnline();
+ * online(); // true/false
+ * ```
+ */
+declare function useOnline(): ReadonlySignal<boolean>;
+interface GeolocationState {
+    latitude: number | null;
+    longitude: number | null;
+    accuracy: number | null;
+    error: GeolocationPositionError | null;
+    loading: boolean;
+}
+/**
+ * Reactive geolocation.
+ *
+ * ```ts
+ * const geo = useGeolocation();
+ * geo().latitude;  // number | null
+ * geo().loading;   // boolean
+ * ```
+ */
+declare function useGeolocation(options?: PositionOptions): ReadonlySignal<GeolocationState>;
+/**
+ * Reactive window dimensions.
+ */
+declare function useWindowSize(): {
+    width: ReadonlySignal<number>;
+    height: ReadonlySignal<number>;
+};
+/**
+ * Detect clicks outside an element. Essential for closing
+ * dropdowns, modals, popovers, and context menus.
+ *
+ * ```ts
+ * const dropdown = document.querySelector('.dropdown')!;
+ * const dispose = useClickOutside(dropdown, () => {
+ *   closeDropdown();
+ * });
+ *
+ * // With options:
+ * useClickOutside(dropdown, onClose, {
+ *   events: ['mousedown', 'touchstart'],
+ *   ignore: ['.trigger-button'],
+ * });
+ * ```
+ */
+declare function useClickOutside(target: HTMLElement | (() => HTMLElement | null), handler: (event: Event) => void, options?: {
+    /** Events to listen for (default: ['pointerdown']) */
+    events?: string[];
+    /** Selectors or elements to ignore (clicks on these won't trigger) */
+    ignore?: (string | HTMLElement)[];
+    /** Whether the listener is active (default: true) */
+    active?: boolean;
+}): () => void;
+
+export { type Breakpoints, type GeolocationState, useBreakpoint, useClickOutside, useClipboard, useGeolocation, useMediaQuery, useOnline, useStorage, useWindowSize };

package/dist/browser.js

@@ -0,0 +1,2 @@
+export{b as useBreakpoint,h as useClickOutside,d as useClipboard,f as useGeolocation,a as useMediaQuery,e as useOnline,c as useStorage,g as useWindowSize}from'./chunk-JQCN42XX.js';import'./chunk-YXKQTEPR.js';import'./chunk-U65WRXZC.js';//# sourceMappingURL=browser.js.map
+//# sourceMappingURL=browser.js.map

package/dist/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"browser.js"}