@omnitron-dev/prism 0.1.3 → 0.3.0

package/dist/core/hooks/use-event-listener.d.ts

@@ -0,0 +1,37 @@
+import type { RefObject } from 'react';
+/**
+ * Supported event maps for different targets.
+ */
+type WindowEventMap = globalThis.WindowEventMap;
+type HTMLElementEventMap = globalThis.HTMLElementEventMap;
+type DocumentEventMap = globalThis.DocumentEventMap;
+/**
+ * Hook to attach event listeners with automatic cleanup.
+ *
+ * @template K - Event type key
+ * @param {K} eventName - Name of the event
+ * @param {function} handler - Event handler
+ * @param {RefObject<HTMLElement>} [element] - Target element (defaults to window)
+ * @param {AddEventListenerOptions} [options] - Event listener options
+ *
+ * @example
+ * ```tsx
+ * // Window event
+ * function ScrollTracker() {
+ *   useEventListener('scroll', () => console.log('Scrolled!'));
+ *   return null;
+ * }
+ *
+ * // Element event
+ * function ClickTracker() {
+ *   const ref = useRef<HTMLDivElement>(null);
+ *   useEventListener('click', (e) => console.log('Clicked!', e), ref);
+ *   return <div ref={ref}>Click me</div>;
+ * }
+ * ```
+ */
+export declare function useEventListener<K extends keyof WindowEventMap>(eventName: K, handler: (event: WindowEventMap[K]) => void, element?: undefined, options?: AddEventListenerOptions): void;
+export declare function useEventListener<K extends keyof HTMLElementEventMap>(eventName: K, handler: (event: HTMLElementEventMap[K]) => void, element: RefObject<HTMLElement | null>, options?: AddEventListenerOptions): void;
+export declare function useEventListener<K extends keyof DocumentEventMap>(eventName: K, handler: (event: DocumentEventMap[K]) => void, element: RefObject<Document>, options?: AddEventListenerOptions): void;
+export {};
+//# sourceMappingURL=use-event-listener.d.ts.map

package/dist/core/hooks/use-event-listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-event-listener.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/use-event-listener.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC;;GAEG;AACH,KAAK,cAAc,GAAG,UAAU,CAAC,cAAc,CAAC;AAChD,KAAK,mBAAmB,GAAG,UAAU,CAAC,mBAAmB,CAAC;AAC1D,KAAK,gBAAgB,GAAG,UAAU,CAAC,gBAAgB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,cAAc,EAC7D,SAAS,EAAE,CAAC,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,IAAI,EAC3C,OAAO,CAAC,EAAE,SAAS,EACnB,OAAO,CAAC,EAAE,uBAAuB,GAChC,IAAI,CAAC;AAER,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,mBAAmB,EAClE,SAAS,EAAE,CAAC,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,KAAK,IAAI,EAChD,OAAO,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EACtC,OAAO,CAAC,EAAE,uBAAuB,GAChC,IAAI,CAAC;AAER,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,gBAAgB,EAC/D,SAAS,EAAE,CAAC,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,KAAK,IAAI,EAC7C,OAAO,EAAE,SAAS,CAAC,QAAQ,CAAC,EAC5B,OAAO,CAAC,EAAE,uBAAuB,GAChC,IAAI,CAAC"}

package/dist/core/hooks/use-interval.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Hook to run a callback at a specified interval.
+ *
+ * @param {function} callback - Function to call on each interval
+ * @param {number | null} delay - Interval delay in ms (null to pause)
+ *
+ * @example
+ * ```tsx
+ * function Timer() {
+ *   const [seconds, setSeconds] = useState(0);
+ *   const [isRunning, setIsRunning] = useState(true);
+ *
+ *   useInterval(
+ *     () => setSeconds((s) => s + 1),
+ *     isRunning ? 1000 : null
+ *   );
+ *
+ *   return (
+ *     <div>
+ *       <p>Seconds: {seconds}</p>
+ *       <button onClick={() => setIsRunning(!isRunning)}>
+ *         {isRunning ? 'Pause' : 'Resume'}
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useInterval(callback: () => void, delay: number | null): void;
+//# sourceMappingURL=use-interval.d.ts.map

package/dist/core/hooks/use-interval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-interval.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/use-interval.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAmB5E"}

package/dist/core/hooks/use-is-client.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Return type for useIsClient hook.
+ */
+export type UseIsClientReturn = boolean;
+/**
+ * Hook to detect client-side rendering.
+ *
+ * @returns {boolean} True if running on client, false during SSR
+ *
+ * @example
+ * ```tsx
+ * function ClientOnlyComponent() {
+ *   const isClient = useIsClient();
+ *
+ *   if (!isClient) {
+ *     return <Skeleton />;
+ *   }
+ *
+ *   return <BrowserOnlyFeature />;
+ * }
+ * ```
+ */
+export declare function useIsClient(): UseIsClientReturn;
+//# sourceMappingURL=use-is-client.d.ts.map

package/dist/core/hooks/use-is-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-is-client.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/use-is-client.ts"],"names":[],"mappings":"AAaA;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC;AAExC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,IAAI,iBAAiB,CAQ/C"}

package/dist/core/hooks/use-local-storage.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Return type for useLocalStorage hook.
+ */
+export type UseLocalStorageReturn<T> = [
+    /** Current value */
+    T,
+    /** Set value (accepts value or updater function) */
+    (value: T | ((prev: T) => T)) => void,
+    /** Remove value from storage */
+    () => void
+];
+/**
+ * Hook for persisting state to localStorage.
+ *
+ * @param key - Storage key
+ * @param initialValue - Initial value (used if no stored value exists)
+ * @returns Tuple of [value, setValue, removeValue]
+ *
+ * @example
+ * ```tsx
+ * function Settings() {
+ *   const [theme, setTheme] = useLocalStorage('theme', 'light');
+ *
+ *   return (
+ *     <Select
+ *       value={theme}
+ *       onChange={(e) => setTheme(e.target.value)}
+ *     >
+ *       <MenuItem value="light">Light</MenuItem>
+ *       <MenuItem value="dark">Dark</MenuItem>
+ *     </Select>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function Counter() {
+ *   const [count, setCount] = useLocalStorage('counter', 0);
+ *
+ *   return (
+ *     <>
+ *       <span>{count}</span>
+ *       <Button onClick={() => setCount((prev) => prev + 1)}>
+ *         Increment
+ *       </Button>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export declare function useLocalStorage<T>(key: string, initialValue: T): UseLocalStorageReturn<T>;
+/**
+ * Hook for reading localStorage value (read-only).
+ *
+ * @param key - Storage key
+ * @param fallback - Fallback value if key doesn't exist
+ * @returns Current stored value
+ */
+export declare function useReadLocalStorage<T>(key: string, fallback: T): T;
+//# sourceMappingURL=use-local-storage.d.ts.map

package/dist/core/hooks/use-local-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-local-storage.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/use-local-storage.ts"],"names":[],"mappings":"AA8CA;;GAEG;AACH,MAAM,MAAM,qBAAqB,CAAC,CAAC,IAAI;IACrC,oBAAoB;IACpB,CAAC;IACD,oDAAoD;IACpD,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,IAAI;IACrC,gCAAgC;IAChC,MAAM,IAAI;CACX,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAsFzF;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CA8BlE"}

package/dist/core/hooks/use-media-query.d.ts

@@ -0,0 +1,107 @@
+/**
+ * useMediaQuery Hook
+ *
+ * Re-export and extension of MUI's useMediaQuery.
+ *
+ * @module core/hooks/use-media-query
+ */
+import { useMediaQuery as useMuiMediaQuery } from '@mui/material';
+import type { UseMediaQueryOptions } from '@mui/material';
+export { useMuiMediaQuery as useMediaQuery };
+export type { UseMediaQueryOptions };
+/**
+ * Hook for detecting system color scheme preference.
+ *
+ * @returns true if user prefers dark mode
+ *
+ * @example
+ * ```tsx
+ * function ThemeToggle() {
+ *   const prefersDark = usePrefersDarkMode();
+ *   const { setMode } = usePrismContext();
+ *
+ *   useEffect(() => {
+ *     setMode(prefersDark ? 'dark' : 'light');
+ *   }, [prefersDark, setMode]);
+ *
+ *   return null;
+ * }
+ * ```
+ */
+export declare function usePrefersDarkMode(): boolean;
+/**
+ * Hook for detecting reduced motion preference.
+ *
+ * @returns true if user prefers reduced motion
+ *
+ * @example
+ * ```tsx
+ * function AnimatedComponent() {
+ *   const prefersReducedMotion = usePrefersReducedMotion();
+ *
+ *   return (
+ *     <motion.div
+ *       animate={{ x: 100 }}
+ *       transition={{
+ *         duration: prefersReducedMotion ? 0 : 0.3,
+ *       }}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export declare function usePrefersReducedMotion(): boolean;
+/**
+ * Hook for detecting high contrast preference.
+ *
+ * @returns true if user prefers high contrast
+ */
+export declare function usePrefersHighContrast(): boolean;
+/**
+ * Hook for detecting touch device.
+ *
+ * @returns true if device supports hover (likely not touch)
+ *
+ * @example
+ * ```tsx
+ * function Tooltip() {
+ *   const canHover = useCanHover();
+ *
+ *   // Only show hover tooltips on non-touch devices
+ *   if (!canHover) {
+ *     return <TouchTooltip />;
+ *   }
+ *
+ *   return <HoverTooltip />;
+ * }
+ * ```
+ */
+export declare function useCanHover(): boolean;
+/**
+ * Hook for detecting print mode.
+ *
+ * @returns true if currently printing
+ */
+export declare function useIsPrinting(): boolean;
+/**
+ * Hook that resolves 'system' mode to actual 'light' or 'dark' based on system preference.
+ * If mode is already 'light' or 'dark', returns it unchanged.
+ *
+ * @param mode - The theme mode ('light' | 'dark' | 'system')
+ * @returns Resolved mode ('light' | 'dark')
+ *
+ * @example
+ * ```tsx
+ * function ThemeProvider({ mode, children }) {
+ *   const resolvedMode = useResolvedMode(mode);
+ *
+ *   return (
+ *     <MuiThemeProvider theme={createTheme({ mode: resolvedMode })}>
+ *       {children}
+ *     </MuiThemeProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare function useResolvedMode(mode: 'light' | 'dark' | 'system'): 'light' | 'dark';
+//# sourceMappingURL=use-media-query.d.ts.map

package/dist/core/hooks/use-media-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-media-query.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/use-media-query.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,OAAO,EAAE,aAAa,IAAI,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE1D,OAAO,EAAE,gBAAgB,IAAI,aAAa,EAAE,CAAC;AAC7C,YAAY,EAAE,oBAAoB,EAAE,CAAC;AAErC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,IAAI,OAAO,CAEjD;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,IAAI,OAAO,CAErC;AAED;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAQnF"}

package/dist/core/hooks/use-mounted.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Return type for useMounted hook.
+ */
+export interface UseMountedReturn {
+    /** Check if component is currently mounted */
+    isMounted: () => boolean;
+}
+/**
+ * Hook to check if a component is currently mounted.
+ * Useful for preventing state updates on unmounted components.
+ *
+ * @returns {UseMountedReturn} Mount state checker
+ *
+ * @example
+ * ```tsx
+ * function AsyncComponent() {
+ *   const [data, setData] = useState(null);
+ *   const { isMounted } = useMounted();
+ *
+ *   useEffect(() => {
+ *     fetchData().then((result) => {
+ *       if (isMounted()) {
+ *         setData(result);
+ *       }
+ *     });
+ *   }, [isMounted]);
+ *
+ *   return <div>{data}</div>;
+ * }
+ * ```
+ */
+export declare function useMounted(): UseMountedReturn;
+//# sourceMappingURL=use-mounted.d.ts.map

package/dist/core/hooks/use-mounted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-mounted.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/use-mounted.ts"],"names":[],"mappings":"AAYA;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,8CAA8C;IAC9C,SAAS,EAAE,MAAM,OAAO,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,IAAI,gBAAgB,CAc7C"}

package/dist/core/hooks/use-multi-select.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Options for useMultiSelect.
+ */
+export interface UseMultiSelectOptions<T> {
+    /** Initial selected items */
+    initial?: T[];
+    /** Maximum selection count */
+    maxSelections?: number;
+    /** Callback when selection changes */
+    onChange?: (selected: T[]) => void;
+}
+/**
+ * Return type for useMultiSelect.
+ */
+export interface UseMultiSelectReturn<T> {
+    /** Currently selected items */
+    selected: T[];
+    /** Number of selected items */
+    count: number;
+    /** Whether nothing is selected */
+    isEmpty: boolean;
+    /** Check if item is selected */
+    isSelected: (item: T) => boolean;
+    /** Toggle item selection */
+    toggle: (item: T) => void;
+    /** Select an item */
+    select: (item: T) => void;
+    /** Deselect an item */
+    deselect: (item: T) => void;
+    /** Select multiple items */
+    selectMany: (items: T[]) => void;
+    /** Deselect multiple items */
+    deselectMany: (items: T[]) => void;
+    /** Clear all selections */
+    clear: () => void;
+    /** Replace all selections */
+    setSelected: (items: T[]) => void;
+    /** Select all items from a list */
+    selectAll: (allItems: T[]) => void;
+    /** Check if all items are selected */
+    isAllSelected: (allItems: T[]) => boolean;
+    /** Check if some items are selected (for indeterminate state) */
+    isPartiallySelected: (allItems: T[]) => boolean;
+}
+/**
+ * useMultiSelect - Multi-selection state management.
+ *
+ * @example
+ * ```tsx
+ * function UserList() {
+ *   const users = ['Alice', 'Bob', 'Charlie'];
+ *   const selection = useMultiSelect<string>();
+ *
+ *   return (
+ *     <>
+ *       <Checkbox
+ *         checked={selection.isAllSelected(users)}
+ *         indeterminate={selection.isPartiallySelected(users)}
+ *         onChange={() => {
+ *           if (selection.isAllSelected(users)) {
+ *             selection.clear();
+ *           } else {
+ *             selection.selectAll(users);
+ *           }
+ *         }}
+ *       />
+ *       {users.map((user) => (
+ *         <Checkbox
+ *           key={user}
+ *           checked={selection.isSelected(user)}
+ *           onChange={() => selection.toggle(user)}
+ *         />
+ *       ))}
+ *       <Button disabled={selection.isEmpty}>
+ *         Delete ({selection.count})
+ *       </Button>
+ *     </>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With objects and custom max
+ * interface Item {
+ *   id: string;
+ *   name: string;
+ * }
+ *
+ * function ItemPicker() {
+ *   const items: Item[] = [...];
+ *   const selection = useMultiSelect<string>({
+ *     maxSelections: 5,
+ *     onChange: (selected) => console.log('Selected:', selected),
+ *   });
+ *
+ *   return items.map((item) => (
+ *     <Chip
+ *       key={item.id}
+ *       selected={selection.isSelected(item.id)}
+ *       onClick={() => selection.toggle(item.id)}
+ *     >
+ *       {item.name}
+ *     </Chip>
+ *   ));
+ * }
+ * ```
+ *
+ * @param options - Hook options
+ * @returns Selection state and controls
+ */
+export declare function useMultiSelect<T>(options?: UseMultiSelectOptions<T>): UseMultiSelectReturn<T>;
+//# sourceMappingURL=use-multi-select.d.ts.map

package/dist/core/hooks/use-multi-select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-multi-select.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/use-multi-select.ts"],"names":[],"mappings":"AAYA;;GAEG;AACH,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACtC,6BAA6B;IAC7B,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC;IACd,8BAA8B;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB,CAAC,CAAC;IACrC,+BAA+B;IAC/B,QAAQ,EAAE,CAAC,EAAE,CAAC;IACd,+BAA+B;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,kCAAkC;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,gCAAgC;IAChC,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;IACjC,4BAA4B;IAC5B,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAC1B,qBAAqB;IACrB,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAC1B,uBAAuB;IACvB,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAC5B,4BAA4B;IAC5B,UAAU,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC;IACjC,8BAA8B;IAC9B,YAAY,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC;IACnC,2BAA2B;IAC3B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,6BAA6B;IAC7B,WAAW,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC;IAClC,mCAAmC;IACnC,SAAS,EAAE,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC;IACnC,sCAAsC;IACtC,aAAa,EAAE,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC;IAC1C,iEAAiE;IACjE,mBAAmB,EAAE,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC;CACjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,GAAE,qBAAqB,CAAC,CAAC,CAAM,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAiIjG"}

package/dist/core/hooks/use-previous.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Hook to track the previous value.
+ *
+ * @template T - Type of the value
+ * @param {T} value - Current value to track
+ * @returns {T | undefined} Previous value (undefined on first render)
+ *
+ * @example
+ * ```tsx
+ * function Counter() {
+ *   const [count, setCount] = useState(0);
+ *   const prevCount = usePrevious(count);
+ *
+ *   return (
+ *     <div>
+ *       Current: {count}, Previous: {prevCount ?? 'N/A'}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function usePrevious<T>(value: T): T | undefined;
+//# sourceMappingURL=use-previous.d.ts.map

package/dist/core/hooks/use-previous.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-previous.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/use-previous.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAQtD"}

package/dist/core/hooks/use-set-state.d.ts

@@ -0,0 +1,56 @@
+/**
+ * State updater function type.
+ * Accepts partial state or a function that returns partial state.
+ */
+export type SetState<T extends Record<string, unknown>> = (patch: Partial<T> | ((prevState: T) => Partial<T>)) => void;
+/**
+ * Return type for useSetState.
+ */
+export interface UseSetStateReturn<T extends Record<string, unknown>> {
+    /** Current state */
+    state: T;
+    /** Update state with partial values */
+    setState: SetState<T>;
+    /** Reset state to initial value */
+    resetState: () => void;
+}
+/**
+ * useSetState - State hook with partial update support.
+ * Works like React class component's setState method.
+ *
+ * @example
+ * ```tsx
+ * interface FormState {
+ *   name: string;
+ *   email: string;
+ *   phone: string;
+ * }
+ *
+ * function Form() {
+ *   const { state, setState, resetState } = useSetState<FormState>({
+ *     name: '',
+ *     email: '',
+ *     phone: '',
+ *   });
+ *
+ *   return (
+ *     <>
+ *       <TextField
+ *         value={state.name}
+ *         onChange={(e) => setState({ name: e.target.value })}
+ *       />
+ *       <TextField
+ *         value={state.email}
+ *         onChange={(e) => setState({ email: e.target.value })}
+ *       />
+ *       <Button onClick={resetState}>Reset</Button>
+ *     </>
+ *   );
+ * }
+ * ```
+ *
+ * @param initialState - Initial state object
+ * @returns State, setState, and resetState
+ */
+export declare function useSetState<T extends Record<string, unknown>>(initialState: T | (() => T)): UseSetStateReturn<T>;
+//# sourceMappingURL=use-set-state.d.ts.map

package/dist/core/hooks/use-set-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-set-state.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/use-set-state.ts"],"names":[],"mappings":"AAaA;;;GAGG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AAEvH;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAClE,oBAAoB;IACpB,KAAK,EAAE,CAAC,CAAC;IACT,uCAAuC;IACvC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IACtB,mCAAmC;IACnC,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAmBhH"}

package/dist/core/hooks/use-tabs.d.ts

@@ -0,0 +1,74 @@
+import type { SyntheticEvent } from 'react';
+/**
+ * Return type for useTabs hook.
+ */
+export interface UseTabsReturn<T extends string | number | false> {
+    /** Current tab value */
+    value: T;
+    /** Set tab value directly */
+    setValue: (value: T) => void;
+    /** MUI Tabs onChange handler */
+    onChange: (event: SyntheticEvent, newValue: T) => void;
+    /** Reset to initial value */
+    reset: () => void;
+    /** Check if a specific tab is selected */
+    isSelected: (tabValue: T) => boolean;
+    /** Select next tab (for array-based tabs) */
+    selectNext: (tabs: readonly T[]) => void;
+    /** Select previous tab (for array-based tabs) */
+    selectPrevious: (tabs: readonly T[]) => void;
+}
+/**
+ * Options for useTabs hook.
+ */
+export interface UseTabsOptions<T> {
+    /**
+     * Callback when tab changes.
+     */
+    onChange?: (value: T) => void;
+}
+/**
+ * Hook to manage tab state with proper memoization.
+ *
+ * @template T - Type of tab value (string, number, or false)
+ * @param {T} defaultValue - Initial tab value
+ * @param {UseTabsOptions<T>} options - Hook options
+ * @returns {UseTabsReturn<T>} Tab state and handlers
+ *
+ * @example
+ * ```tsx
+ * function MyTabs() {
+ *   const tabs = useTabs('overview');
+ *
+ *   return (
+ *     <>
+ *       <Tabs value={tabs.value} onChange={tabs.onChange}>
+ *         <Tab label="Overview" value="overview" />
+ *         <Tab label="Details" value="details" />
+ *         <Tab label="Settings" value="settings" />
+ *       </Tabs>
+ *       {tabs.value === 'overview' && <Overview />}
+ *       {tabs.value === 'details' && <Details />}
+ *       {tabs.value === 'settings' && <Settings />}
+ *     </>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With keyboard navigation
+ * const TABS = ['overview', 'details', 'settings'] as const;
+ *
+ * function MyTabs() {
+ *   const tabs = useTabs<typeof TABS[number]>('overview');
+ *
+ *   useKeyboardShortcut({ key: 'ArrowRight' }, () => tabs.selectNext(TABS));
+ *   useKeyboardShortcut({ key: 'ArrowLeft' }, () => tabs.selectPrevious(TABS));
+ *
+ *   return <Tabs value={tabs.value} onChange={tabs.onChange}>...</Tabs>;
+ * }
+ * ```
+ */
+export declare function useTabs<T extends string | number | false = string>(defaultValue: T, options?: UseTabsOptions<T>): UseTabsReturn<T>;
+//# sourceMappingURL=use-tabs.d.ts.map

package/dist/core/hooks/use-tabs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-tabs.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/use-tabs.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,KAAK;IAC9D,wBAAwB;IACxB,KAAK,EAAE,CAAC,CAAC;IACT,6BAA6B;IAC7B,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC7B,gCAAgC;IAChC,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,CAAC,KAAK,IAAI,CAAC;IACvD,6BAA6B;IAC7B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,0CAA0C;IAC1C,UAAU,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,OAAO,CAAC;IACrC,6CAA6C;IAC7C,UAAU,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,KAAK,IAAI,CAAC;IACzC,iDAAiD;IACjD,cAAc,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,KAAK,IAAI,CAAC;CAC9C;AAED;;GAEG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B;;OAEG;IACH,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,EAChE,YAAY,EAAE,CAAC,EACf,OAAO,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,GAC1B,aAAa,CAAC,CAAC,CAAC,CA0DlB"}

package/dist/core/hooks/use-timeout.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Return type for useTimeout hook.
+ */
+export interface UseTimeoutReturn {
+    /** Reset the timeout */
+    reset: () => void;
+    /** Clear the timeout */
+    clear: () => void;
+    /** Whether the timeout is active */
+    isActive: boolean;
+}
+/**
+ * Hook to run a callback after a specified delay.
+ *
+ * @param {function} callback - Function to call after delay
+ * @param {number} delay - Delay in milliseconds
+ * @returns {UseTimeoutReturn} Timeout controls
+ *
+ * @example
+ * ```tsx
+ * function AutoSave() {
+ *   const [content, setContent] = useState('');
+ *   const { reset } = useTimeout(() => {
+ *     saveContent(content);
+ *   }, 3000);
+ *
+ *   const handleChange = (value: string) => {
+ *     setContent(value);
+ *     reset(); // Reset timer on each change
+ *   };
+ *
+ *   return <textarea value={content} onChange={(e) => handleChange(e.target.value)} />;
+ * }
+ * ```
+ */
+export declare function useTimeout(callback: () => void, delay: number): UseTimeoutReturn;
+//# sourceMappingURL=use-timeout.d.ts.map

package/dist/core/hooks/use-timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-timeout.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/use-timeout.ts"],"names":[],"mappings":"AAYA;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,wBAAwB;IACxB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,wBAAwB;IACxB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,oCAAoC;IACpC,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,gBAAgB,CAmChF"}