@omnitron-dev/prism 0.2.0 → 0.3.1

package/dist/core/hooks/use-click-outside.d.ts

@@ -0,0 +1,26 @@
+import type { RefObject } from 'react';
+/**
+ * Hook to detect clicks outside of an element.
+ *
+ * @template T - Element type (defaults to HTMLElement)
+ * @param {function} handler - Callback when clicked outside
+ * @param {RefObject<T>} [providedRef] - Optional external ref
+ * @returns {RefObject<T>} Ref to attach to the element
+ *
+ * @example
+ * ```tsx
+ * function Dropdown() {
+ *   const [isOpen, setIsOpen] = useState(false);
+ *   const ref = useClickOutside<HTMLDivElement>(() => setIsOpen(false));
+ *
+ *   return (
+ *     <div ref={ref}>
+ *       <button onClick={() => setIsOpen(true)}>Open</button>
+ *       {isOpen && <DropdownMenu />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useClickOutside<T extends HTMLElement = HTMLElement>(handler: (event: MouseEvent | TouchEvent) => void, providedRef?: RefObject<T | null>): RefObject<T | null>;
+//# sourceMappingURL=use-click-outside.d.ts.map

package/dist/core/hooks/use-click-outside.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-click-outside.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/use-click-outside.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EACjE,OAAO,EAAE,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,KAAK,IAAI,EACjD,WAAW,CAAC,EAAE,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,GAChC,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,CA8BrB"}

package/dist/core/hooks/use-copy-to-clipboard.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Copy state types.
+ */
+export type CopyState = 'idle' | 'success' | 'error';
+/**
+ * Return type for useCopyToClipboard.
+ */
+export interface UseCopyToClipboardReturn {
+    /** Current copy state */
+    state: CopyState;
+    /** Copied text (null if not copied) */
+    copiedText: string | null;
+    /** Copy text to clipboard */
+    copy: (text: string) => Promise<boolean>;
+    /** Reset state to idle */
+    reset: () => void;
+}
+/**
+ * Options for useCopyToClipboard.
+ */
+export interface UseCopyToClipboardOptions {
+    /** Reset to idle after this many ms (default: 2000) */
+    resetTimeout?: number;
+    /** Callback on successful copy */
+    onSuccess?: (text: string) => void;
+    /** Callback on copy error */
+    onError?: (error: Error) => void;
+}
+/**
+ * useCopyToClipboard - Copy text to clipboard with state tracking.
+ *
+ * @example
+ * ```tsx
+ * function CopyButton({ text }: { text: string }) {
+ *   const { state, copy } = useCopyToClipboard();
+ *
+ *   return (
+ *     <Button onClick={() => copy(text)}>
+ *       {state === 'success' ? 'Copied!' : 'Copy'}
+ *     </Button>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With callback
+ * function ShareLink({ url }: { url: string }) {
+ *   const { state, copy } = useCopyToClipboard({
+ *     onSuccess: () => enqueueSnackbar('Link copied!'),
+ *     onError: (err) => enqueueSnackbar(`Failed to copy: ${err.message}`, { variant: 'error' }),
+ *   });
+ *
+ *   return (
+ *     <IconButton onClick={() => copy(url)}>
+ *       {state === 'success' ? <CheckIcon /> : <CopyIcon />}
+ *     </IconButton>
+ *   );
+ * }
+ * ```
+ *
+ * @param options - Hook options
+ * @returns Copy function and state
+ */
+export declare function useCopyToClipboard(options?: UseCopyToClipboardOptions): UseCopyToClipboardReturn;
+//# sourceMappingURL=use-copy-to-clipboard.d.ts.map

package/dist/core/hooks/use-copy-to-clipboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-copy-to-clipboard.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/use-copy-to-clipboard.ts"],"names":[],"mappings":"AAYA;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;AAErD;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,yBAAyB;IACzB,KAAK,EAAE,SAAS,CAAC;IACjB,uCAAuC;IACvC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,6BAA6B;IAC7B,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACzC,0BAA0B;IAC1B,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,uDAAuD;IACvD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kCAAkC;IAClC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,6BAA6B;IAC7B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CAClC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,yBAA8B,GAAG,wBAAwB,CAiFpG"}

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

@@ -0,0 +1,105 @@
+/**
+ * Countdown state.
+ */
+export interface CountdownState {
+    /** Remaining time in seconds */
+    seconds: number;
+    /** Whether countdown is running */
+    isRunning: boolean;
+    /** Whether countdown has finished */
+    isFinished: boolean;
+}
+/**
+ * Countdown controls.
+ */
+export interface CountdownControls {
+    /** Start or resume the countdown */
+    start: () => void;
+    /** Pause the countdown */
+    pause: () => void;
+    /** Reset to initial duration */
+    reset: () => void;
+    /** Set a new duration and reset */
+    setDuration: (seconds: number) => void;
+}
+/**
+ * Return type for useCountdown.
+ */
+export interface UseCountdownReturn extends CountdownState, CountdownControls {
+    /** Formatted time string (MM:SS or HH:MM:SS) */
+    formatted: string;
+    /** Time parts for custom formatting */
+    parts: {
+        hours: number;
+        minutes: number;
+        seconds: number;
+    };
+}
+/**
+ * Options for useCountdown.
+ */
+export interface UseCountdownOptions {
+    /** Initial duration in seconds */
+    duration: number;
+    /** Auto-start countdown (default: false) */
+    autoStart?: boolean;
+    /** Callback when countdown finishes */
+    onComplete?: () => void;
+    /** Callback on each tick */
+    onTick?: (remaining: number) => void;
+    /** Tick interval in ms (default: 1000) */
+    interval?: number;
+}
+/**
+ * useCountdown - Countdown timer hook.
+ *
+ * @example
+ * ```tsx
+ * function OTPTimer() {
+ *   const { formatted, isFinished, reset } = useCountdown({
+ *     duration: 60,
+ *     autoStart: true,
+ *     onComplete: () => console.log('Timer finished!'),
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       {isFinished ? (
+ *         <Button onClick={reset}>Resend OTP</Button>
+ *       ) : (
+ *         <Typography>Resend in {formatted}</Typography>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function QuizTimer() {
+ *   const countdown = useCountdown({
+ *     duration: 300, // 5 minutes
+ *     onTick: (remaining) => {
+ *       if (remaining === 60) {
+ *         showWarning('1 minute remaining!');
+ *       }
+ *     },
+ *     onComplete: () => submitQuiz(),
+ *   });
+ *
+ *   return (
+ *     <Box>
+ *       <Typography variant="h4">{countdown.formatted}</Typography>
+ *       <Button onClick={countdown.start}>Start</Button>
+ *       <Button onClick={countdown.pause}>Pause</Button>
+ *       <Button onClick={countdown.reset}>Reset</Button>
+ *     </Box>
+ *   );
+ * }
+ * ```
+ *
+ * @param options - Countdown options
+ * @returns Countdown state and controls
+ */
+export declare function useCountdown(options: UseCountdownOptions): UseCountdownReturn;
+//# sourceMappingURL=use-countdown.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-countdown.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/use-countdown.ts"],"names":[],"mappings":"AAYA;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,gCAAgC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,mCAAmC;IACnC,SAAS,EAAE,OAAO,CAAC;IACnB,qCAAqC;IACrC,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,oCAAoC;IACpC,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,0BAA0B;IAC1B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,gCAAgC;IAChC,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,mCAAmC;IACnC,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc,EAAE,iBAAiB;IAC3E,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,uCAAuC;IACvC,KAAK,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,uCAAuC;IACvC,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,4BAA4B;IAC5B,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAyBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,kBAAkB,CA8H7E"}

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

@@ -0,0 +1,64 @@
+/**
+ * Hook for debouncing a value.
+ *
+ * @param value - Value to debounce
+ * @param delay - Debounce delay in milliseconds (default: 500)
+ * @returns Debounced value
+ *
+ * @example
+ * ```tsx
+ * function SearchInput() {
+ *   const [query, setQuery] = useState('');
+ *   const debouncedQuery = useDebounce(query, 300);
+ *
+ *   useEffect(() => {
+ *     if (debouncedQuery) {
+ *       search(debouncedQuery);
+ *     }
+ *   }, [debouncedQuery]);
+ *
+ *   return (
+ *     <TextField
+ *       value={query}
+ *       onChange={(e) => setQuery(e.target.value)}
+ *       placeholder="Search..."
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export declare function useDebounce<T>(value: T, delay?: number): T;
+/**
+ * Hook for debouncing a callback function.
+ *
+ * @param callback - Function to debounce
+ * @param delay - Debounce delay in milliseconds (default: 500)
+ * @returns Debounced callback and cancel function
+ *
+ * @example
+ * ```tsx
+ * function AutoSave() {
+ *   const [content, setContent] = useState('');
+ *
+ *   const { debouncedCallback: save, cancel } = useDebounceCallback(
+ *     async (text: string) => {
+ *       await api.saveDocument(text);
+ *     },
+ *     1000
+ *   );
+ *
+ *   const handleChange = (e: React.ChangeEvent<HTMLTextAreaElement>) => {
+ *     setContent(e.target.value);
+ *     save(e.target.value);
+ *   };
+ *
+ *   return <textarea value={content} onChange={handleChange} />;
+ * }
+ * ```
+ */
+export declare function useDebounceCallback<T extends (...args: never[]) => unknown>(callback: T, delay?: number): {
+    debouncedCallback: (...args: Parameters<T>) => void;
+    cancel: () => void;
+    flush: () => void;
+};
+//# sourceMappingURL=use-debounce.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-debounce.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/use-debounce.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,SAAM,GAAG,CAAC,CAcvD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,EACzE,QAAQ,EAAE,CAAC,EACX,KAAK,SAAM,GACV;IACD,iBAAiB,EAAE,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IACpD,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAqDA"}

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"}