@arkyn/components 3.0.1-beta.143 → 3.0.1-beta.144

package/dist/hooks/useAutomation.d.ts

@@ -1,44 +1,36 @@
 /**
- * Executes UI automations based on a form response payload.
+ * useAutomation — runs UI side-effects (close modals, scroll, toast) in response to a server action payload.
  *
- * Current behaviors:
- * - Closes all open modals when `closeModal` is `true`.
- * - Scrolls to a target element when `cause.data.scrollTo` is provided.
- * - Shows a toast according to response `name`, `message`, and `cause.fieldErrors`.
+ * Pass the raw response from a form submission. On every change the hook:
+ * 1. Closes all open modals if `closeModal` is `true`.
+ * 2. Smooth-scrolls to a named element if `cause.data.scrollTo` is set.
+ * 3. Shows a toast based on `name` (matched against `successResponses`/`badResponses`) and `message`.
+ *    When `cause.fieldErrors` is present, the first field error takes priority in the toast.
+ *    The message `"Unprocessable entity"` is intentionally suppressed.
  *
- * Toast rules:
- * - Success responses (`successResponses`) show a success toast with `message`.
- * - Bad responses (`badResponses`) show a danger toast.
- * - When `cause.fieldErrors` exists, the first field error message has priority.
- * - The message `"Unprocessable entity"` is intentionally ignored.
- *
- * @param {any} formResponseData Response payload used to trigger automations.
- * @param {boolean} [formResponseData.closeModal] Closes all modals when `true`.
- * @param {string} [formResponseData.message] Message used in toast notifications.
- * @param {string} [formResponseData.name] Response identifier used to classify success/error.
- * @param {Object} [formResponseData.cause] Additional payload metadata.
- * @param {Object} [formResponseData.cause.data] Additional response data.
- * @param {string} [formResponseData.cause.data.scrollTo] Scroll target name for `react-scroll`.
- * @param {Record<string, string>} [formResponseData.cause.fieldErrors] Field-level error messages.
+ * @param formResponseData - Raw server response payload.
+ * @param formResponseData.closeModal - Closes all open modals when `true`.
+ * @param formResponseData.name - Response identifier matched against success/bad response lists.
+ * @param formResponseData.message - Text shown in the toast notification.
+ * @param formResponseData.cause.data.scrollTo - Element name to scroll to via `react-scroll`.
+ * @param formResponseData.cause.fieldErrors - Field-level errors; the first value is shown in the toast.
  *
  * @example
  * ```tsx
- * useAutomation({
- *   closeModal: true,
- *   name: "created",
- *   message: "Saved successfully"
- * });
+ * // After a successful create action
+ * useAutomation({ closeModal: true, name: "created", message: "Saved successfully" });
  * ```
  *
  * @example
  * ```tsx
+ * // Validation error with field-level feedback and scroll
  * useAutomation({
  *   name: "validation_error",
  *   message: "Invalid payload",
  *   cause: {
  *     data: { scrollTo: "email" },
- *     fieldErrors: { email: "E-mail is required" }
- *   }
+ *     fieldErrors: { email: "E-mail is required" },
+ *   },
  * });
  * ```
  */

package/dist/hooks/useAutomation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAutomation.d.ts","sourceRoot":"","sources":["../../src/hooks/useAutomation.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,iBAAS,aAAa,CAAC,gBAAgB,EAAE,GAAG,QA+B3C;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"useAutomation.d.ts","sourceRoot":"","sources":["../../src/hooks/useAutomation.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,iBAAS,aAAa,CAAC,gBAAgB,EAAE,GAAG,QA+B3C;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/hooks/useAutomation.js

@@ -5,46 +5,38 @@ import { useToast } from "./useToast";
 import { badResponses } from "../templates/badResponses";
 import { successResponses } from "../templates/successResponses";
 /**
- * Executes UI automations based on a form response payload.
+ * useAutomation — runs UI side-effects (close modals, scroll, toast) in response to a server action payload.
  *
- * Current behaviors:
- * - Closes all open modals when `closeModal` is `true`.
- * - Scrolls to a target element when `cause.data.scrollTo` is provided.
- * - Shows a toast according to response `name`, `message`, and `cause.fieldErrors`.
+ * Pass the raw response from a form submission. On every change the hook:
+ * 1. Closes all open modals if `closeModal` is `true`.
+ * 2. Smooth-scrolls to a named element if `cause.data.scrollTo` is set.
+ * 3. Shows a toast based on `name` (matched against `successResponses`/`badResponses`) and `message`.
+ *    When `cause.fieldErrors` is present, the first field error takes priority in the toast.
+ *    The message `"Unprocessable entity"` is intentionally suppressed.
  *
- * Toast rules:
- * - Success responses (`successResponses`) show a success toast with `message`.
- * - Bad responses (`badResponses`) show a danger toast.
- * - When `cause.fieldErrors` exists, the first field error message has priority.
- * - The message `"Unprocessable entity"` is intentionally ignored.
- *
- * @param {any} formResponseData Response payload used to trigger automations.
- * @param {boolean} [formResponseData.closeModal] Closes all modals when `true`.
- * @param {string} [formResponseData.message] Message used in toast notifications.
- * @param {string} [formResponseData.name] Response identifier used to classify success/error.
- * @param {Object} [formResponseData.cause] Additional payload metadata.
- * @param {Object} [formResponseData.cause.data] Additional response data.
- * @param {string} [formResponseData.cause.data.scrollTo] Scroll target name for `react-scroll`.
- * @param {Record<string, string>} [formResponseData.cause.fieldErrors] Field-level error messages.
+ * @param formResponseData - Raw server response payload.
+ * @param formResponseData.closeModal - Closes all open modals when `true`.
+ * @param formResponseData.name - Response identifier matched against success/bad response lists.
+ * @param formResponseData.message - Text shown in the toast notification.
+ * @param formResponseData.cause.data.scrollTo - Element name to scroll to via `react-scroll`.
+ * @param formResponseData.cause.fieldErrors - Field-level errors; the first value is shown in the toast.
  *
  * @example
  * ```tsx
- * useAutomation({
- *   closeModal: true,
- *   name: "created",
- *   message: "Saved successfully"
- * });
+ * // After a successful create action
+ * useAutomation({ closeModal: true, name: "created", message: "Saved successfully" });
  * ```
  *
  * @example
  * ```tsx
+ * // Validation error with field-level feedback and scroll
  * useAutomation({
  *   name: "validation_error",
  *   message: "Invalid payload",
  *   cause: {
  *     data: { scrollTo: "email" },
- *     fieldErrors: { email: "E-mail is required" }
- *   }
+ *     fieldErrors: { email: "E-mail is required" },
+ *   },
  * });
  * ```
  */

package/dist/hooks/useDrawer.d.ts

@@ -1,78 +1,33 @@
 import { DrawerContextProps } from "../providers/drawerProvider";
 type OpenDrawerProps<T = any> = (data?: T) => void;
 /**
- * useDrawer hook - provides access to drawer context for managing drawer state and data
+ * useDrawer — accesses the nearest `DrawerProvider` context.
  *
- * @param key - Optional drawer identifier key. When provided, returns functions for a specific drawer
+ * Two call signatures:
+ * - **Without `key`** — returns the raw context object (manage any drawer by name).
+ * - **With `key`** — returns a scoped object bound to one named drawer.
  *
- * @returns When called without key: Complete drawer context with all drawer management functions
- * @returns When called with key: Object containing drawer-specific functions:
- * - `drawerIsOpen`: Boolean indicating if the specific drawer is open
- * - `drawerData`: Data associated with the specific drawer
- * - `openDrawer`: Function to open the specific drawer with optional data
- * - `closeDrawer`: Function to close the specific drawer
+ * @param key - Drawer identifier registered in `DrawerProvider`.
  *
- * @example
- * ```tsx
- * // Basic usage - access to full drawer context
- * function DrawerManager() {
- *   const drawerContext = useDrawer();
- *
- *   return (
- *     <div>
- *       <button onClick={() => drawerContext.openDrawer('navigation', { section: 'main' })}>
- *         Open Navigation
- *       </button>
- *       <button onClick={() => drawerContext.openDrawer('filters', { category: 'electronics' })}>
- *         Open Filters
- *       </button>
- *     </div>
- *   );
- * }
+ * @returns Without key: full `DrawerContextProps`. With key: `{ drawerIsOpen, drawerData, openDrawer, closeDrawer }`.
  *
- * // Usage with specific drawer key
- * function NavigationDrawer() {
- *   const { drawerIsOpen, drawerData, openDrawer, closeDrawer } = useDrawer('navigation');
+ * @throws If called outside a `DrawerProvider`.
  *
- *   return (
- *     <Drawer isOpen={drawerIsOpen} onClose={closeDrawer} position="left">
- *       <h2>Navigation</h2>
- *       <p>Current section: {drawerData?.section}</p>
- *       <button onClick={closeDrawer}>Close</button>
- *     </Drawer>
- *   );
- * }
- *
- * // Usage with typed data
- * interface FilterData {
- *   category: string;
- *   priceRange: [number, number];
- *   brands: string[];
- * }
+ * @example
+ * ```tsx
+ * // Scoped to one drawer — the most common pattern
+ * const { drawerIsOpen, drawerData, openDrawer, closeDrawer } = useDrawer<{ section: string }>('navigation');
  *
- * function FilterDrawer() {
- *   const { drawerIsOpen, drawerData, closeDrawer } = useDrawer<FilterData>('filters');
+ * openDrawer({ section: 'products' });
+ * ```
  *
- *   return (
- *     <Drawer isOpen={drawerIsOpen} onClose={closeDrawer} position="right">
- *       <h2>Filters</h2>
- *       <p>Category: {drawerData?.category}</p>
- *       <p>Price: ${drawerData?.priceRange?.[0]} - ${drawerData?.priceRange?.[1]}</p>
- *       <p>Brands: {drawerData?.brands?.join(', ')}</p>
- *     </Drawer>
- *   );
- * }
+ * @example
+ * ```tsx
+ * // Full context — useful when triggering multiple different drawers from one place
+ * const { openDrawer } = useDrawer();
  *
- * // Usage with DrawerProvider
- * function App() {
- *   return (
- *     <DrawerProvider>
- *       <NavigationDrawer />
- *       <FilterDrawer />
- *       <DrawerManager />
- *     </DrawerProvider>
- *   );
- * }
+ * openDrawer('navigation', { section: 'main' });
+ * openDrawer('filters', { category: 'electronics' });
  * ```
  */
 declare function useDrawer<T = any>(): DrawerContextProps<T>;

package/dist/hooks/useDrawer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDrawer.d.ts","sourceRoot":"","sources":["../../src/hooks/useDrawer.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEhF,KAAK,eAAe,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AAEH,iBAAS,SAAS,CAAC,CAAC,GAAG,GAAG,KAAK,kBAAkB,CAAC,CAAC,CAAC,CAAC;AACrD,iBAAS,SAAS,CAAC,CAAC,GAAG,GAAG,EACxB,GAAG,EAAE,MAAM,GACV;IACD,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,CAAC,CAAC;IACd,UAAU,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC;IAC/B,WAAW,EAAE,MAAM,IAAI,CAAC;CACzB,CAAC;AA6BF,OAAO,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"useDrawer.d.ts","sourceRoot":"","sources":["../../src/hooks/useDrawer.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEhF,KAAK,eAAe,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,iBAAS,SAAS,CAAC,CAAC,GAAG,GAAG,KAAK,kBAAkB,CAAC,CAAC,CAAC,CAAC;AACrD,iBAAS,SAAS,CAAC,CAAC,GAAG,GAAG,EACxB,GAAG,EAAE,MAAM,GACV;IACD,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,CAAC,CAAC;IACd,UAAU,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC;IAC/B,WAAW,EAAE,MAAM,IAAI,CAAC;CACzB,CAAC;AA6BF,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/hooks/useForm.d.ts

@@ -1,45 +1,28 @@
 /**
- * useForm hook - provides access to form context data including field errors
+ * useForm — reads the nearest `FormProvider` context to access field-level validation errors.
  *
- * @returns Form context object containing:
- * - `fieldErrors`: Object with field validation errors indexed by field name
+ * All form inputs (`Input`, `Select`, `Checkbox`, etc.) call this hook internally,
+ * so you rarely need it directly. Use it when you want to read errors outside of
+ * an input component, or build a custom input.
+ *
+ * @returns Form context containing:
+ * - `fieldErrors` — `Record<string, string>` mapping field names to error messages.
  *
  * @example
  * ```tsx
- * // Basic usage in a component
- * function MyComponent() {
- *   const { fieldErrors } = useForm();
- *
- *   return (
- *     <Input
- *       name="email"
- *       errorMessage={fieldErrors?.email}
- *     />
- *   );
- * }
- *
- * // Usage with FormProvider
+ * // Wrapping a form with FormProvider
  * function App() {
- *   const errors = { email: "Invalid email format" };
- *
  *   return (
- *     <FormProvider fieldErrors={errors}>
+ *     <FormProvider fieldErrors={{ email: "Invalid email" }}>
  *       <MyForm />
  *     </FormProvider>
  *   );
  * }
  *
- * // Checking for specific field errors
- * function FormField() {
+ * // Reading errors manually
+ * function CustomField() {
  *   const { fieldErrors } = useForm();
- *   const hasError = !!fieldErrors?.username;
- *
- *   return (
- *     <div>
- *       <Input name="username" />
- *       {hasError && <span>Error: {fieldErrors.username}</span>}
- *     </div>
- *   );
+ *   return <span>{fieldErrors?.username}</span>;
  * }
  * ```
  */

package/dist/hooks/useForm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useForm.d.ts","sourceRoot":"","sources":["../../src/hooks/useForm.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,iBAAS,OAAO;;;;EAGf;AAED,OAAO,EAAE,OAAO,EAAE,CAAC"}
+{"version":3,"file":"useForm.d.ts","sourceRoot":"","sources":["../../src/hooks/useForm.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,iBAAS,OAAO;;;;EAGf;AAED,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/dist/hooks/useForm.js

@@ -1,47 +1,30 @@
 import { useContext } from "react";
 import { formContext } from "../providers/formProvider";
 /**
- * useForm hook - provides access to form context data including field errors
+ * useForm — reads the nearest `FormProvider` context to access field-level validation errors.
  *
- * @returns Form context object containing:
- * - `fieldErrors`: Object with field validation errors indexed by field name
+ * All form inputs (`Input`, `Select`, `Checkbox`, etc.) call this hook internally,
+ * so you rarely need it directly. Use it when you want to read errors outside of
+ * an input component, or build a custom input.
+ *
+ * @returns Form context containing:
+ * - `fieldErrors` — `Record<string, string>` mapping field names to error messages.
  *
  * @example
  * ```tsx
- * // Basic usage in a component
- * function MyComponent() {
- *   const { fieldErrors } = useForm();
- *
- *   return (
- *     <Input
- *       name="email"
- *       errorMessage={fieldErrors?.email}
- *     />
- *   );
- * }
- *
- * // Usage with FormProvider
+ * // Wrapping a form with FormProvider
  * function App() {
- *   const errors = { email: "Invalid email format" };
- *
  *   return (
- *     <FormProvider fieldErrors={errors}>
+ *     <FormProvider fieldErrors={{ email: "Invalid email" }}>
  *       <MyForm />
  *     </FormProvider>
  *   );
  * }
  *
- * // Checking for specific field errors
- * function FormField() {
+ * // Reading errors manually
+ * function CustomField() {
  *   const { fieldErrors } = useForm();
- *   const hasError = !!fieldErrors?.username;
- *
- *   return (
- *     <div>
- *       <Input name="username" />
- *       {hasError && <span>Error: {fieldErrors.username}</span>}
- *     </div>
- *   );
+ *   return <span>{fieldErrors?.username}</span>;
  * }
  * ```
  */

package/dist/hooks/useHydrated.d.ts

@@ -1,73 +1,18 @@
 /**
- * useHydrated hook - detects if the component is hydrated on the client side
+ * useHydrated — returns `true` once the component has hydrated on the client, `false` during SSR.
  *
- * This hook is useful for preventing hydration mismatches when rendering different content
- * on server and client sides. It returns false during SSR and true after hydration.
+ * Built on `useSyncExternalStore` so it is safe with React 18 concurrent rendering.
+ * Use this when you need to defer client-only rendering (e.g. browser APIs, `window`, `navigator`)
+ * without causing a hydration mismatch. For most cases, prefer the `ClientOnly` component.
  *
- * @returns Boolean indicating if the component is hydrated
- * - `true`: Component is hydrated on the client side
- * - `false`: Component is being rendered on the server side or before hydration
+ * @returns `true` on the client after hydration; `false` on the server.
  *
  * @example
  * ```tsx
- * // Basic usage to prevent hydration mismatches
- * function ClientOnlyComponent() {
+ * function Map() {
  *   const isHydrated = useHydrated();
- *
- *   if (!isHydrated) {
- *     return <div>Loading...</div>;
- *   }
- *
- *   return (
- *     <div>
- *       <p>This content is only rendered on the client</p>
- *       <p>Current time: {new Date().toLocaleString()}</p>
- *     </div>
- *   );
- * }
- *
- * // Conditional rendering based on hydration state
- * function ResponsiveComponent() {
- *   const isHydrated = useHydrated();
- *
- *   return (
- *     <div>
- *       <h1>My App</h1>
- *       {isHydrated ? (
- *         <InteractiveWidget />
- *       ) : (
- *         <StaticPlaceholder />
- *       )}
- *     </div>
- *   );
- * }
- *
- * // Using with client-only features
- * function LocationComponent() {
- *   const isHydrated = useHydrated();
- *   const [location, setLocation] = useState(null);
- *
- *   useEffect(() => {
- *     if (isHydrated && navigator.geolocation) {
- *       navigator.geolocation.getCurrentPosition((pos) => {
- *         setLocation(pos.coords);
- *       });
- *     }
- *   }, [isHydrated]);
- *
- *   if (!isHydrated) {
- *     return <div>Preparing location services...</div>;
- *   }
- *
- *   return (
- *     <div>
- *       {location ? (
- *         <p>Your location: {location.latitude}, {location.longitude}</p>
- *       ) : (
- *         <p>Getting your location...</p>
- *       )}
- *     </div>
- *   );
+ *   if (!isHydrated) return <Skeleton />;
+ *   return <MapView accessToken={token} coordinates={coords} />;
  * }
  * ```
  */

package/dist/hooks/useHydrated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useHydrated.d.ts","sourceRoot":"","sources":["../../src/hooks/useHydrated.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AAEH,iBAAS,WAAW,YAMnB;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"useHydrated.d.ts","sourceRoot":"","sources":["../../src/hooks/useHydrated.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iBAAS,WAAW,YAMnB;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/hooks/useHydrated.js

@@ -3,75 +3,20 @@ function subscribe() {
     return () => { };
 }
 /**
- * useHydrated hook - detects if the component is hydrated on the client side
+ * useHydrated — returns `true` once the component has hydrated on the client, `false` during SSR.
  *
- * This hook is useful for preventing hydration mismatches when rendering different content
- * on server and client sides. It returns false during SSR and true after hydration.
+ * Built on `useSyncExternalStore` so it is safe with React 18 concurrent rendering.
+ * Use this when you need to defer client-only rendering (e.g. browser APIs, `window`, `navigator`)
+ * without causing a hydration mismatch. For most cases, prefer the `ClientOnly` component.
  *
- * @returns Boolean indicating if the component is hydrated
- * - `true`: Component is hydrated on the client side
- * - `false`: Component is being rendered on the server side or before hydration
+ * @returns `true` on the client after hydration; `false` on the server.
  *
  * @example
  * ```tsx
- * // Basic usage to prevent hydration mismatches
- * function ClientOnlyComponent() {
+ * function Map() {
  *   const isHydrated = useHydrated();
- *
- *   if (!isHydrated) {
- *     return <div>Loading...</div>;
- *   }
- *
- *   return (
- *     <div>
- *       <p>This content is only rendered on the client</p>
- *       <p>Current time: {new Date().toLocaleString()}</p>
- *     </div>
- *   );
- * }
- *
- * // Conditional rendering based on hydration state
- * function ResponsiveComponent() {
- *   const isHydrated = useHydrated();
- *
- *   return (
- *     <div>
- *       <h1>My App</h1>
- *       {isHydrated ? (
- *         <InteractiveWidget />
- *       ) : (
- *         <StaticPlaceholder />
- *       )}
- *     </div>
- *   );
- * }
- *
- * // Using with client-only features
- * function LocationComponent() {
- *   const isHydrated = useHydrated();
- *   const [location, setLocation] = useState(null);
- *
- *   useEffect(() => {
- *     if (isHydrated && navigator.geolocation) {
- *       navigator.geolocation.getCurrentPosition((pos) => {
- *         setLocation(pos.coords);
- *       });
- *     }
- *   }, [isHydrated]);
- *
- *   if (!isHydrated) {
- *     return <div>Preparing location services...</div>;
- *   }
- *
- *   return (
- *     <div>
- *       {location ? (
- *         <p>Your location: {location.latitude}, {location.longitude}</p>
- *       ) : (
- *         <p>Getting your location...</p>
- *       )}
- *     </div>
- *   );
+ *   if (!isHydrated) return <Skeleton />;
+ *   return <MapView accessToken={token} coordinates={coords} />;
  * }
  * ```
  */

package/dist/hooks/useModal.d.ts

@@ -1,73 +1,33 @@
 import { ModalContextProps } from "../providers/modalProvider";
 type OpenModalProps<T = any> = (data?: T) => void;
 /**
- * useModal hook - provides access to modal context for managing modal state and data
+ * useModal — accesses the nearest `ModalProvider` context.
  *
- * @param key - Optional modal identifier key. When provided, returns functions for a specific modal
+ * Two call signatures:
+ * - **Without `key`** — returns the raw context object (manage any modal by name).
+ * - **With `key`** — returns a scoped object bound to one named modal.
  *
- * @returns When called without key: Complete modal context with all modal management functions
- * @returns When called with key: Object containing modal-specific functions:
- * - `modalIsOpen`: Boolean indicating if the specific modal is open
- * - `modalData`: Data associated with the specific modal
- * - `openModal`: Function to open the specific modal with optional data
- * - `closeModal`: Function to close the specific modal
+ * @param key - Modal identifier registered in `ModalProvider`.
  *
- * @example
- * ```tsx
- * // Basic usage - access to full modal context
- * function ModalManager() {
- *   const modalContext = useModal();
- *
- *   return (
- *     <div>
- *       <button onClick={() => modalContext.openModal('user-details', { id: 1 })}>
- *         Open User Modal
- *       </button>
- *     </div>
- *   );
- * }
+ * @returns Without key: full `ModalContextProps`. With key: `{ modalIsOpen, modalData, openModal, closeModal }`.
  *
- * // Usage with specific modal key
- * function UserModal() {
- *   const { modalIsOpen, modalData, openModal, closeModal } = useModal('user-details');
+ * @throws If called outside a `ModalProvider`.
  *
- *   return (
- *     <Modal isOpen={modalIsOpen} onClose={closeModal}>
- *       <h2>User Details</h2>
- *       <p>User ID: {modalData?.id}</p>
- *       <button onClick={closeModal}>Close</button>
- *     </Modal>
- *   );
- * }
- *
- * // Usage with typed data
- * interface UserData {
- *   id: number;
- *   name: string;
- *   email: string;
- * }
+ * @example
+ * ```tsx
+ * // Scoped to one modal — the most common pattern
+ * const { modalIsOpen, modalData, openModal, closeModal } = useModal<{ id: number }>('confirm-delete');
  *
- * function UserProfileModal() {
- *   const { modalIsOpen, modalData, closeModal } = useModal<UserData>('user-profile');
+ * openModal({ id: user.id });
+ * ```
  *
- *   return (
- *     <Modal isOpen={modalIsOpen} onClose={closeModal}>
- *       <h2>{modalData?.name}</h2>
- *       <p>Email: {modalData?.email}</p>
- *     </Modal>
- *   );
- * }
+ * @example
+ * ```tsx
+ * // Full context — useful when triggering multiple different modals from one place
+ * const { openModal } = useModal();
  *
- * // Usage with ModalProvider
- * function App() {
- *   return (
- *     <ModalProvider>
- *       <UserModal />
- *       <UserProfileModal />
- *       <ModalManager />
- *     </ModalProvider>
- *   );
- * }
+ * openModal('confirm-delete', { id: user.id });
+ * openModal('user-details', { id: user.id });
  * ```
  */
 declare function useModal<T = any>(): ModalContextProps<T>;

package/dist/hooks/useModal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useModal.d.ts","sourceRoot":"","sources":["../../src/hooks/useModal.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAE7E,KAAK,cAAc,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AAEH,iBAAS,QAAQ,CAAC,CAAC,GAAG,GAAG,KAAK,iBAAiB,CAAC,CAAC,CAAC,CAAC;AACnD,iBAAS,QAAQ,CAAC,CAAC,GAAG,GAAG,EACvB,GAAG,EAAE,MAAM,GACV;IACD,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,CAAC,CAAC;IACb,SAAS,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IAC7B,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB,CAAC;AA6BF,OAAO,EAAE,QAAQ,EAAE,CAAC"}
+{"version":3,"file":"useModal.d.ts","sourceRoot":"","sources":["../../src/hooks/useModal.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAE7E,KAAK,cAAc,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,iBAAS,QAAQ,CAAC,CAAC,GAAG,GAAG,KAAK,iBAAiB,CAAC,CAAC,CAAC,CAAC;AACnD,iBAAS,QAAQ,CAAC,CAAC,GAAG,GAAG,EACvB,GAAG,EAAE,MAAM,GACV;IACD,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,CAAC,CAAC;IACb,SAAS,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IAC7B,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB,CAAC;AA6BF,OAAO,EAAE,QAAQ,EAAE,CAAC"}