@omnitron-dev/prism 0.2.0 → 0.3.1

package/dist/hooks/use-mutation.d.ts

@@ -0,0 +1,141 @@
+/**
+ * State for a mutation.
+ */
+export interface MutationState<TData, TError> {
+    /** Mutation result data */
+    data: TData | undefined;
+    /** Error from mutation */
+    error: TError | undefined;
+    /** Whether mutation is currently executing */
+    isLoading: boolean;
+    /** Whether mutation has succeeded at least once */
+    isSuccess: boolean;
+    /** Whether mutation has failed */
+    isError: boolean;
+    /** Whether mutation is idle (never called or reset) */
+    isIdle: boolean;
+    /** Current status */
+    status: 'idle' | 'loading' | 'success' | 'error';
+}
+/**
+ * Options for useMutation hook.
+ */
+export interface UseMutationOptions<TData, TError, TVariables> {
+    /** Called when mutation starts */
+    onMutate?: (variables: TVariables) => void | Promise<void>;
+    /** Called on successful mutation */
+    onSuccess?: (data: TData, variables: TVariables) => void | Promise<void>;
+    /** Called on mutation error */
+    onError?: (error: TError, variables: TVariables) => void | Promise<void>;
+    /** Called after mutation settles (success or error) */
+    onSettled?: (data: TData | undefined, error: TError | undefined, variables: TVariables) => void | Promise<void>;
+    /** Retry count on failure */
+    retry?: number | boolean;
+    /** Delay between retries in ms */
+    retryDelay?: number | ((attempt: number) => number);
+}
+/**
+ * Return type for useMutation hook.
+ */
+export interface UseMutationReturn<TData, TError, TVariables> {
+    /** Current mutation state */
+    data: TData | undefined;
+    error: TError | undefined;
+    isLoading: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    isIdle: boolean;
+    status: MutationState<TData, TError>['status'];
+    /** Execute the mutation */
+    mutate: (variables: TVariables, options?: {
+        onSuccess?: (data: TData) => void;
+        onError?: (error: TError) => void;
+        onSettled?: (data: TData | undefined, error: TError | undefined) => void;
+    }) => void;
+    /** Execute the mutation and return a promise */
+    mutateAsync: (variables: TVariables) => Promise<TData>;
+    /** Reset mutation state */
+    reset: () => void;
+}
+/**
+ * Hook for handling async mutations with loading/error states.
+ *
+ * @param mutationFn - Async function to execute
+ * @param options - Configuration options
+ * @returns Mutation state and control methods
+ *
+ * @example
+ * ```tsx
+ * function CreateUserForm() {
+ *   const createUser = useMutation(
+ *     async (data: { name: string; email: string }) => {
+ *       const response = await fetch('/api/users', {
+ *         method: 'POST',
+ *         body: JSON.stringify(data),
+ *       });
+ *       if (!response.ok) throw new Error('Failed to create user');
+ *       return response.json();
+ *     },
+ *     {
+ *       onSuccess: (user) => {
+ *         console.log('User created:', user);
+ *       },
+ *       onError: (error) => {
+ *         console.error('Failed:', error);
+ *       },
+ *     }
+ *   );
+ *
+ *   const handleSubmit = (e: FormEvent) => {
+ *     e.preventDefault();
+ *     createUser.mutate({ name: 'John', email: 'john@example.com' });
+ *   };
+ *
+ *   return (
+ *     <form onSubmit={handleSubmit}>
+ *       <button type="submit" disabled={createUser.isLoading}>
+ *         {createUser.isLoading ? 'Creating...' : 'Create User'}
+ *       </button>
+ *       {createUser.isError && <div>Error: {String(createUser.error)}</div>}
+ *       {createUser.isSuccess && <div>User created!</div>}
+ *     </form>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With async/await
+ * async function handleCreate() {
+ *   try {
+ *     const user = await createUser.mutateAsync({ name: 'Jane' });
+ *     navigate(`/users/${user.id}`);
+ *   } catch (error) {
+ *     // Error already captured in state
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With retry
+ * const uploadFile = useMutation(
+ *   async (file: File) => {
+ *     const formData = new FormData();
+ *     formData.append('file', file);
+ *     const response = await fetch('/api/upload', {
+ *       method: 'POST',
+ *       body: formData,
+ *     });
+ *     if (!response.ok) throw new Error('Upload failed');
+ *     return response.json();
+ *   },
+ *   {
+ *     retry: 3,
+ *     retryDelay: (attempt) => attempt * 1000,
+ *   }
+ * );
+ * ```
+ */
+export declare function useMutation<TData = unknown, TError = Error, TVariables = void>(mutationFn: (variables: TVariables) => Promise<TData>, options?: UseMutationOptions<TData, TError, TVariables>): UseMutationReturn<TData, TError, TVariables>;
+//# sourceMappingURL=use-mutation.d.ts.map

package/dist/hooks/use-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-mutation.ts"],"names":[],"mappings":"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"}

package/dist/hooks/use-online-status.d.ts

@@ -0,0 +1,56 @@
+export interface UseOnlineStatusReturn {
+    /** Whether the browser is online */
+    isOnline: boolean;
+    /** Whether the browser is offline */
+    isOffline: boolean;
+    /** Time when status last changed (timestamp) */
+    lastChanged: number | null;
+}
+/**
+ * useOnlineStatus - Track browser online/offline status.
+ *
+ * Uses navigator.onLine and online/offline events to track network status.
+ * SSR-safe with server-side assumption of online status.
+ *
+ * @example
+ * ```tsx
+ * function ConnectionIndicator() {
+ *   const { isOnline, isOffline } = useOnlineStatus();
+ *
+ *   if (isOffline) {
+ *     return (
+ *       <Alert severity="warning">
+ *         You are offline. Changes will sync when you reconnect.
+ *       </Alert>
+ *     );
+ *   }
+ *
+ *   return null;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With timestamp tracking
+ * function NetworkStatus() {
+ *   const { isOnline, lastChanged } = useOnlineStatus();
+ *
+ *   return (
+ *     <Box>
+ *       <Typography>
+ *         Status: {isOnline ? 'Online' : 'Offline'}
+ *       </Typography>
+ *       {lastChanged && (
+ *         <Typography variant="caption">
+ *           Last changed: {new Date(lastChanged).toLocaleTimeString()}
+ *         </Typography>
+ *       )}
+ *     </Box>
+ *   );
+ * }
+ * ```
+ *
+ * @returns Online status and metadata
+ */
+export declare function useOnlineStatus(): UseOnlineStatusReturn;
+//# sourceMappingURL=use-online-status.d.ts.map

package/dist/hooks/use-online-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-online-status.d.ts","sourceRoot":"","sources":["../../src/hooks/use-online-status.ts"],"names":[],"mappings":"AAgBA,MAAM,WAAW,qBAAqB;IACpC,oCAAoC;IACpC,QAAQ,EAAE,OAAO,CAAC;IAClB,qCAAqC;IACrC,SAAS,EAAE,OAAO,CAAC;IACnB,gDAAgD;IAChD,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AA4BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,eAAe,IAAI,qBAAqB,CAsBvD"}

package/dist/hooks/use-password-visibility.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Return type for usePasswordVisibility hook.
+ */
+export interface UsePasswordVisibilityReturn {
+    /** Whether password is visible (text) or hidden (password) */
+    visible: boolean;
+    /** Toggle visibility */
+    toggle: () => void;
+    /** Show password */
+    show: () => void;
+    /** Hide password */
+    hide: () => void;
+    /** Input type based on visibility ('text' | 'password') */
+    type: 'text' | 'password';
+}
+/**
+ * Options for usePasswordVisibility hook.
+ */
+export interface UsePasswordVisibilityOptions {
+    /** Initial visibility state (default: false) */
+    initialVisible?: boolean;
+}
+/**
+ * usePasswordVisibility - Manage password field visibility toggle.
+ *
+ * Returns state and handlers for password visibility toggle,
+ * commonly used with InputAdornment in MUI TextField.
+ *
+ * @example
+ * ```tsx
+ * function LoginForm() {
+ *   const password = usePasswordVisibility();
+ *
+ *   return (
+ *     <TextField
+ *       type={password.type}
+ *       slotProps={{
+ *         input: {
+ *           endAdornment: (
+ *             <InputAdornment position="end">
+ *               <IconButton onClick={password.toggle}>
+ *                 {password.visible ? <VisibilityOff /> : <Visibility />}
+ *               </IconButton>
+ *             </InputAdornment>
+ *           ),
+ *         },
+ *       }}
+ *     />
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With confirm password field. MUI v9 routes slot props through
+ * // the `slotProps` API rather than the legacy `InputProps` /
+ * // `InputLabelProps` / `FormHelperTextProps` family.
+ * function RegisterForm() {
+ *   const password = usePasswordVisibility();
+ *   const confirmPassword = usePasswordVisibility();
+ *
+ *   return (
+ *     <Box>
+ *       <TextField
+ *         label="Password"
+ *         type={password.type}
+ *         slotProps={{ input: { endAdornment: <PasswordToggle {...password} /> } }}
+ *       />
+ *       <TextField
+ *         label="Confirm Password"
+ *         type={confirmPassword.type}
+ *         slotProps={{ input: { endAdornment: <PasswordToggle {...confirmPassword} /> } }}
+ *       />
+ *     </Box>
+ *   );
+ * }
+ * ```
+ *
+ * @param options - Hook options
+ * @returns Visibility state, toggle handlers, and input type
+ */
+export declare function usePasswordVisibility(options?: UsePasswordVisibilityOptions): UsePasswordVisibilityReturn;
+//# sourceMappingURL=use-password-visibility.d.ts.map

package/dist/hooks/use-password-visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-password-visibility.d.ts","sourceRoot":"","sources":["../../src/hooks/use-password-visibility.ts"],"names":[],"mappings":"AAiBA;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,8DAA8D;IAC9D,OAAO,EAAE,OAAO,CAAC;IACjB,wBAAwB;IACxB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,oBAAoB;IACpB,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,oBAAoB;IACpB,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,2DAA2D;IAC3D,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C,gDAAgD;IAChD,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,4BAAiC,GAAG,2BAA2B,CA4B7G"}

package/dist/hooks/use-popover-hover.d.ts

@@ -0,0 +1,78 @@
+/**
+ * usePopoverHover Hook
+ *
+ * Manages hover-based popover state with proper enter/leave handling.
+ * Different from click-based popovers - opens on mouse enter, closes on leave.
+ *
+ * @module @omnitron-dev/prism/hooks
+ */
+import { type RefObject, type Dispatch, type SetStateAction } from 'react';
+/**
+ * Return type for usePopoverHover hook.
+ */
+export interface UsePopoverHoverReturn<T extends HTMLElement = HTMLElement> {
+    /** Whether the popover is open */
+    open: boolean;
+    /** The element the popover is anchored to (for MUI Popover) */
+    anchorEl: T | null;
+    /** Handler for mouse enter - opens the popover */
+    onOpen: () => void;
+    /** Handler for mouse leave - closes the popover */
+    onClose: () => void;
+    /** Ref to attach to the trigger element */
+    elementRef: RefObject<T | null>;
+    /** Manual control of open state */
+    setOpen: Dispatch<SetStateAction<boolean>>;
+}
+/**
+ * usePopoverHover - Hook for hover-based popover management.
+ *
+ * This hook is SSR-safe. It doesn't access browser APIs directly.
+ * During SSR, elementRef.current is null and open defaults to false,
+ * so anchorEl will always be null on the server.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * const { open, anchorEl, onOpen, onClose, elementRef } = usePopoverHover<HTMLButtonElement>();
+ *
+ * return (
+ *   <>
+ *     <Button
+ *       ref={elementRef}
+ *       onMouseEnter={onOpen}
+ *       onMouseLeave={onClose}
+ *     >
+ *       Hover me
+ *     </Button>
+ *     <Popover
+ *       open={open}
+ *       anchorEl={anchorEl}
+ *       onClose={onClose}
+ *       anchorOrigin={{ vertical: 'bottom', horizontal: 'left' }}
+ *     >
+ *       <Typography sx={{ p: 2 }}>Popover content</Typography>
+ *     </Popover>
+ *   </>
+ * );
+ *
+ * // With existing ref
+ * const myRef = useRef<HTMLDivElement>(null);
+ * const { open, onOpen, onClose } = usePopoverHover(myRef);
+ *
+ * // With delay (using inline)
+ * const { open, anchorEl, elementRef, setOpen } = usePopoverHover();
+ * const timeoutRef = useRef<NodeJS.Timeout>();
+ *
+ * const handleOpen = () => {
+ *   clearTimeout(timeoutRef.current);
+ *   setOpen(true);
+ * };
+ *
+ * const handleClose = () => {
+ *   timeoutRef.current = setTimeout(() => setOpen(false), 200);
+ * };
+ * ```
+ */
+export declare function usePopoverHover<T extends HTMLElement = HTMLElement>(inputRef?: RefObject<T | null>): UsePopoverHoverReturn<T>;
+//# sourceMappingURL=use-popover-hover.d.ts.map

package/dist/hooks/use-popover-hover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-popover-hover.d.ts","sourceRoot":"","sources":["../../src/hooks/use-popover-hover.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH,OAAO,EAAiC,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAE,MAAM,OAAO,CAAC;AAE1G;;GAEG;AACH,MAAM,WAAW,qBAAqB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW;IACxE,kCAAkC;IAClC,IAAI,EAAE,OAAO,CAAC;IACd,+DAA+D;IAC/D,QAAQ,EAAE,CAAC,GAAG,IAAI,CAAC;IACnB,kDAAkD;IAClD,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,mDAAmD;IACnD,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,2CAA2C;IAC3C,UAAU,EAAE,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAChC,mCAAmC;IACnC,OAAO,EAAE,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;CAC5C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EACjE,QAAQ,CAAC,EAAE,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,GAC7B,qBAAqB,CAAC,CAAC,CAAC,CAyB1B"}

package/dist/hooks/use-scroll-offset-top.d.ts

@@ -0,0 +1,69 @@
+/**
+ * useScrollOffsetTop Hook
+ *
+ * Manages offset top state based on scroll position.
+ * Can track against window or a specific element's offset.
+ *
+ * This hook is SSR-safe - scroll tracking only runs on the client.
+ *
+ * Ported from minimal-shared for Prism design system.
+ *
+ * @module hooks/use-scroll-offset-top
+ */
+import type { RefObject } from 'react';
+/**
+ * Return type for useScrollOffsetTop hook.
+ */
+export type UseScrollOffsetTopReturn<T extends HTMLElement = HTMLElement> = {
+    /** Whether the scroll position is past the offset threshold */
+    offsetTop: boolean;
+    /** Ref to attach to element for tracking its offset (optional) */
+    elementRef: RefObject<T | null>;
+};
+/**
+ * Custom hook to manage the offset top state based on scroll position.
+ *
+ * Can be used in two ways:
+ * 1. Track against a fixed pixel value (window scroll)
+ * 2. Track against an element's offset (using returned ref)
+ *
+ * @param defaultValue - The offset value at which the state changes (default: 0)
+ *
+ * @returns An object containing offsetTop boolean and elementRef
+ *
+ * @example
+ * ```tsx
+ * // Track window scroll against fixed value
+ * function StickyHeader() {
+ *   const { offsetTop } = useScrollOffsetTop(80);
+ *
+ *   return (
+ *     <AppBar position={offsetTop ? 'fixed' : 'static'}>
+ *       <Toolbar>Header</Toolbar>
+ *     </AppBar>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Track scroll against element offset
+ * function HeaderWithBanner() {
+ *   const { offsetTop, elementRef } = useScrollOffsetTop<HTMLDivElement>();
+ *
+ *   return (
+ *     <>
+ *       <div ref={elementRef}>Banner Content</div>
+ *       <AppBar
+ *         position={offsetTop ? 'fixed' : 'static'}
+ *         sx={{ top: offsetTop ? 0 : 'auto' }}
+ *       >
+ *         <Toolbar>Header</Toolbar>
+ *       </AppBar>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export declare function useScrollOffsetTop<T extends HTMLElement = HTMLElement>(defaultValue?: number): UseScrollOffsetTopReturn<T>;
+//# sourceMappingURL=use-scroll-offset-top.d.ts.map

package/dist/hooks/use-scroll-offset-top.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-scroll-offset-top.d.ts","sourceRoot":"","sources":["../../src/hooks/use-scroll-offset-top.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAOvC;;GAEG;AACH,MAAM,MAAM,wBAAwB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,IAAI;IAC1E,+DAA+D;IAC/D,SAAS,EAAE,OAAO,CAAC;IACnB,kEAAkE;IAClE,UAAU,EAAE,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;CACjC,CAAC;AAMF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EACpE,YAAY,GAAE,MAAU,GACvB,wBAAwB,CAAC,CAAC,CAAC,CA2C7B"}

package/dist/hooks/use-scroll-position.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Scroll position data.
+ */
+export interface ScrollPosition {
+    /** Scroll position from top */
+    x: number;
+    /** Scroll position from left */
+    y: number;
+    /** Scroll direction (1 = down/right, -1 = up/left, 0 = initial) */
+    directionX: -1 | 0 | 1;
+    directionY: -1 | 0 | 1;
+    /** Whether scrolled past threshold */
+    isScrolled: boolean;
+    /** Whether at the top */
+    isAtTop: boolean;
+    /** Whether at the bottom */
+    isAtBottom: boolean;
+}
+/**
+ * Options for useScrollPosition hook.
+ */
+export interface UseScrollPositionOptions {
+    /** Element to track (default: window) */
+    element?: HTMLElement | null;
+    /** Throttle delay in ms (default: 100) */
+    throttle?: number;
+    /** Threshold to consider "scrolled" (default: 0) */
+    threshold?: number;
+    /** Offset from bottom to consider "at bottom" (default: 10) */
+    bottomOffset?: number;
+}
+/**
+ * useScrollPosition - Hook for tracking scroll position.
+ *
+ * @example
+ * ```tsx
+ * // Track window scroll
+ * const { y, isScrolled, directionY } = useScrollPosition();
+ *
+ * // Show header shadow when scrolled
+ * <Header className={isScrolled ? 'shadow' : ''} />
+ *
+ * // Hide header on scroll down, show on scroll up
+ * const showHeader = directionY !== 1 || y < 50;
+ *
+ * // Track specific element
+ * const containerRef = useRef<HTMLDivElement>(null);
+ * const { isAtBottom } = useScrollPosition({ element: containerRef.current });
+ *
+ * // Load more when near bottom
+ * useEffect(() => {
+ *   if (isAtBottom) loadMore();
+ * }, [isAtBottom]);
+ * ```
+ */
+export declare function useScrollPosition(options?: UseScrollPositionOptions): ScrollPosition;
+/**
+ * useScrollToTop - Hook for scrolling to top functionality.
+ *
+ * @example
+ * ```tsx
+ * const { scrollToTop, showButton } = useScrollToTop({ threshold: 300 });
+ *
+ * {showButton && (
+ *   <Fab onClick={scrollToTop}>
+ *     <ArrowUpIcon />
+ *   </Fab>
+ * )}
+ * ```
+ */
+export declare function useScrollToTop(options?: {
+    threshold?: number;
+}): {
+    scrollToTop: () => void;
+    showButton: boolean;
+};
+/**
+ * useScrollLock - Hook for locking body scroll.
+ *
+ * @example
+ * ```tsx
+ * const { lock, unlock, isLocked } = useScrollLock();
+ *
+ * // Lock when modal opens
+ * useEffect(() => {
+ *   if (isOpen) lock();
+ *   else unlock();
+ * }, [isOpen]);
+ * ```
+ */
+export declare function useScrollLock(): {
+    lock: () => void;
+    unlock: () => void;
+    isLocked: boolean;
+};
+//# sourceMappingURL=use-scroll-position.d.ts.map

package/dist/hooks/use-scroll-position.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-scroll-position.d.ts","sourceRoot":"","sources":["../../src/hooks/use-scroll-position.ts"],"names":[],"mappings":"AAYA;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,+BAA+B;IAC/B,CAAC,EAAE,MAAM,CAAC;IACV,gCAAgC;IAChC,CAAC,EAAE,MAAM,CAAC;IACV,mEAAmE;IACnE,UAAU,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACvB,UAAU,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACvB,sCAAsC;IACtC,UAAU,EAAE,OAAO,CAAC;IACpB,yBAAyB;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,4BAA4B;IAC5B,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,yCAAyC;IACzC,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAC7B,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,wBAA6B,GAAG,cAAc,CAoFxF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG;IACpE,WAAW,EAAE,MAAM,IAAI,CAAC;IACxB,UAAU,EAAE,OAAO,CAAC;CACrB,CAYA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,IAAI;IAC/B,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAwCA"}

package/dist/hooks/use-session-storage.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Return type for useSessionStorage hook.
+ */
+export interface UseSessionStorageReturn<T> {
+    /** Current state value */
+    state: T;
+    /** Update state and sessionStorage */
+    setState: (value: T | ((prev: T) => T)) => void;
+    /** Remove item from sessionStorage and reset to default */
+    remove: () => void;
+    /** Check if sessionStorage has the key */
+    hasValue: boolean;
+}
+/**
+ * Options for useSessionStorage hook.
+ */
+export interface UseSessionStorageOptions<T> {
+    /** Serializer function (default: JSON.stringify) */
+    serializer?: (value: T) => string;
+    /** Deserializer function (default: JSON.parse) */
+    deserializer?: (value: string) => T;
+}
+/**
+ * Hook for persisting state in sessionStorage.
+ *
+ * @param key - Storage key
+ * @param defaultValue - Default value when key is not found
+ * @param options - Configuration options
+ * @returns State value and control methods
+ *
+ * @example
+ * ```tsx
+ * function SearchFilters() {
+ *   const { state: filters, setState: setFilters, remove } = useSessionStorage(
+ *     'search-filters',
+ *     { query: '', category: 'all' }
+ *   );
+ *
+ *   return (
+ *     <>
+ *       <input
+ *         value={filters.query}
+ *         onChange={(e) => setFilters({ ...filters, query: e.target.value })}
+ *       />
+ *       <button onClick={remove}>Clear Filters</button>
+ *     </>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With functional updates
+ * function Counter() {
+ *   const { state: count, setState: setCount } = useSessionStorage('counter', 0);
+ *
+ *   return (
+ *     <button onClick={() => setCount((prev) => prev + 1)}>
+ *       Count: {count}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useSessionStorage<T>(key: string, defaultValue: T, options?: UseSessionStorageOptions<T>): UseSessionStorageReturn<T>;
+//# sourceMappingURL=use-session-storage.d.ts.map

package/dist/hooks/use-session-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-session-storage.d.ts","sourceRoot":"","sources":["../../src/hooks/use-session-storage.ts"],"names":[],"mappings":"AAaA;;GAEG;AACH,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACxC,0BAA0B;IAC1B,KAAK,EAAE,CAAC,CAAC;IACT,sCAAsC;IACtC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,IAAI,CAAC;IAChD,2DAA2D;IAC3D,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,0CAA0C;IAC1C,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB,CAAC,CAAC;IACzC,oDAAoD;IACpD,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;IAClC,kDAAkD;IAClD,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,CAAC,CAAC;CACrC;AAsBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,CAAC,EACf,OAAO,GAAE,wBAAwB,CAAC,CAAC,CAAM,GACxC,uBAAuB,CAAC,CAAC,CAAC,CA2G5B"}