@breadstone/mosaik-elements-react 0.0.205 → 0.0.209

package/Cdk/Overlays/Dialog/useDialog.d.ts

@@ -0,0 +1,66 @@
+import { type IDialogOptions } from '@breadstone/mosaik-elements-foundation';
+/**
+ * Represents the return type of the `useDialog` hook.
+ *
+ * @public
+ */
+export interface IUseDialogReturn {
+    /**
+     * Opens a dialog with the specified wrapper component.
+     *
+     * @template T - Type of the wrapper component extending HTMLElement.
+     * @template TData - Type of data provided to the wrapper component.
+     * @template TResult - Expected return type of the resolved dialog result.
+     * @param dialogId - Unique identifier for the dialog.
+     * @param wrapperClass - Constructor for the wrapper component.
+     * @param data - Optional data to pass to the wrapper.
+     * @param options - Optional dialog configuration.
+     * @returns Promise resolving to the dialog result.
+     */
+    open<T extends HTMLElement, TData, TResult>(dialogId: string, wrapperClass: new (args?: TData) => T, data?: TData, options?: IDialogOptions): Promise<TResult>;
+    /**
+     * Closes a dialog by its identifier.
+     *
+     * @template TResult - Type of the result to return.
+     * @param dialogId - The identifier of the dialog to close.
+     * @param result - Optional result to pass to the dialog opener.
+     * @returns Promise that resolves when the dialog is closed.
+     */
+    close<TResult>(dialogId: string, result?: TResult): Promise<void>;
+}
+/**
+ * React hook for managing dialogs using the foundation DialogService singleton.
+ *
+ * @remarks
+ * This hook provides a React-idiomatic interface to the foundation DialogService.
+ * The service should be configured at application startup using `DialogService.configure()`.
+ *
+ * @example
+ * ```tsx
+ * // In your app setup
+ * DialogService.configure({
+ *     behaviors: [withDialogStackBehavior({ baseWidth: '80%' })],
+ *     closeOnNavigation: true
+ * });
+ *
+ * // In your component
+ * function MyComponent() {
+ *     const dialog = useDialog();
+ *
+ *     const handleOpen = async () => {
+ *         const result = await dialog.open('myDialog', MyDialogWrapper, {
+ *             header: 'Confirm Action',
+ *             closeable: true
+ *         });
+ *         console.log('Dialog result:', result);
+ *     };
+ *
+ *     return <button onClick={handleOpen}>Open Dialog</button>;
+ * }
+ * ```
+ *
+ * @public
+ * @returns An object containing dialog management functions.
+ */
+export declare function useDialog(): IUseDialogReturn;
+//# sourceMappingURL=useDialog.d.ts.map

package/Cdk/Overlays/Dialog/useDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDialog.d.ts","sourceRoot":"","sources":["../../../../src/Cdk/Overlays/Dialog/useDialog.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAI5F;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAE7B;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,CAAC,SAAS,WAAW,EAAE,KAAK,EAAE,OAAO,EACtC,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,KAAK,IAAI,CAAC,EAAE,KAAK,KAAK,CAAC,EACrC,IAAI,CAAC,EAAE,KAAK,EACZ,OAAO,CAAC,EAAE,cAAc,GACzB,OAAO,CAAC,OAAO,CAAC,CAAC;IAEpB;;;;;;;OAOG;IACH,KAAK,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAErE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,SAAS,IAAI,gBAAgB,CA4B5C"}

package/Cdk/Overlays/Dialog/useDialog.js

@@ -0,0 +1,55 @@
+// #region Imports
+import { useCallback, useMemo } from 'react';
+import { DialogService } from '@breadstone/mosaik-elements-foundation';
+/**
+ * React hook for managing dialogs using the foundation DialogService singleton.
+ *
+ * @remarks
+ * This hook provides a React-idiomatic interface to the foundation DialogService.
+ * The service should be configured at application startup using `DialogService.configure()`.
+ *
+ * @example
+ * ```tsx
+ * // In your app setup
+ * DialogService.configure({
+ *     behaviors: [withDialogStackBehavior({ baseWidth: '80%' })],
+ *     closeOnNavigation: true
+ * });
+ *
+ * // In your component
+ * function MyComponent() {
+ *     const dialog = useDialog();
+ *
+ *     const handleOpen = async () => {
+ *         const result = await dialog.open('myDialog', MyDialogWrapper, {
+ *             header: 'Confirm Action',
+ *             closeable: true
+ *         });
+ *         console.log('Dialog result:', result);
+ *     };
+ *
+ *     return <button onClick={handleOpen}>Open Dialog</button>;
+ * }
+ * ```
+ *
+ * @public
+ * @returns An object containing dialog management functions.
+ */
+export function useDialog() {
+    // #region Methods
+    const open = useCallback((dialogId, wrapperClass, data, options) => {
+        if (data !== undefined) {
+            return DialogService.instance.open(dialogId, wrapperClass, data, options);
+        }
+        return DialogService.instance.open(dialogId, wrapperClass, options);
+    }, []);
+    const close = useCallback((dialogId, result) => DialogService.instance.close(dialogId, result), []);
+    // #endregion
+    // #region Properties
+    return useMemo(() => ({
+        open,
+        close
+    }), [open, close]);
+    // #endregion
+}
+//# sourceMappingURL=useDialog.js.map

package/Cdk/Overlays/Dialog/useDialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDialog.js","sourceRoot":"","sources":["../../../../src/Cdk/Overlays/Dialog/useDialog.ts"],"names":[],"mappings":"AAAA,kBAAkB;AAElB,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAuB,MAAM,wCAAwC,CAAC;AA0C5F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,UAAU,SAAS;IACrB,kBAAkB;IAElB,MAAM,IAAI,GAAG,WAAW,CAAC,CACrB,QAAgB,EAChB,YAAqC,EACrC,IAAY,EACZ,OAAwB,EACR,EAAE;QAClB,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACrB,OAAO,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAoB,QAAQ,EAAE,YAAsC,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;QAC3H,CAAC;QAED,OAAO,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAa,QAAQ,EAAE,YAA2B,EAAE,OAAO,CAAC,CAAC;IACnG,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,MAAM,KAAK,GAAG,WAAW,CAAC,CAAU,QAAgB,EAAE,MAAgB,EAAiB,EAAE,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC;IAE9I,aAAa;IAEb,qBAAqB;IAErB,OAAO,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;QAClB,IAAI;QACJ,KAAK;KACR,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;IAEnB,aAAa;AACjB,CAAC"}

package/Cdk/Overlays/Drawer/DrawerContext.d.ts

@@ -0,0 +1,63 @@
+import { type ReactNode } from 'react';
+import { type IUseDrawerReturn } from './useDrawer';
+/**
+ * Props for the DrawerProvider component.
+ *
+ * @public
+ */
+export interface IDrawerProviderProps {
+    /**
+     * Child components that will have access to the drawer context.
+     */
+    children: ReactNode;
+}
+/**
+ * Provider component that makes drawer functionality available to all child components.
+ *
+ * @remarks
+ * Place this provider at the root of your application or at a level where all
+ * components that need drawer access are descendants.
+ *
+ * @example
+ * ```tsx
+ * // In your app root
+ * function App() {
+ *     return (
+ *         <DrawerProvider>
+ *             <YourAppContent />
+ *         </DrawerProvider>
+ *     );
+ * }
+ * ```
+ *
+ * @public
+ * @param props - The provider props.
+ * @returns The provider component wrapping children.
+ */
+export declare function DrawerProvider({ children }: IDrawerProviderProps): ReactNode;
+/**
+ * Hook to access the drawer context.
+ *
+ * @remarks
+ * This hook must be used within a DrawerProvider. If you don't need the provider pattern,
+ * use `useDrawer` directly instead.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *     const drawer = useDrawerContext();
+ *
+ *     return (
+ *         <button onClick={() => drawer.open('myDrawer', MyWrapper)}>
+ *             Open
+ *         </button>
+ *     );
+ * }
+ * ```
+ *
+ * @public
+ * @returns The drawer context value.
+ * @throws Error if used outside of a DrawerProvider.
+ */
+export declare function useDrawerContext(): IUseDrawerReturn;
+//# sourceMappingURL=DrawerContext.d.ts.map

package/Cdk/Overlays/Drawer/DrawerContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DrawerContext.d.ts","sourceRoot":"","sources":["../../../../src/Cdk/Overlays/Drawer/DrawerContext.tsx"],"names":[],"mappings":"AAEA,OAAc,EAA6B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACzE,OAAO,EAAE,KAAK,gBAAgB,EAAa,MAAM,aAAa,CAAC;AAW/D;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IAEjC;;OAEG;IACH,QAAQ,EAAE,SAAS,CAAC;CAEvB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,EAAE,QAAQ,EAAE,EAAE,oBAAoB,GAAG,SAAS,CAQ5E;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,IAAI,gBAAgB,CAQnD"}

package/Cdk/Overlays/Drawer/DrawerContext.js

@@ -0,0 +1,69 @@
+// #region Imports
+import React, { createContext, useContext } from 'react';
+import { useDrawer } from './useDrawer';
+// #endregion
+/**
+ * Context for providing drawer functionality throughout the React component tree.
+ *
+ * @internal
+ */
+const DrawerContext = createContext(null);
+/**
+ * Provider component that makes drawer functionality available to all child components.
+ *
+ * @remarks
+ * Place this provider at the root of your application or at a level where all
+ * components that need drawer access are descendants.
+ *
+ * @example
+ * ```tsx
+ * // In your app root
+ * function App() {
+ *     return (
+ *         <DrawerProvider>
+ *             <YourAppContent />
+ *         </DrawerProvider>
+ *     );
+ * }
+ * ```
+ *
+ * @public
+ * @param props - The provider props.
+ * @returns The provider component wrapping children.
+ */
+export function DrawerProvider({ children }) {
+    const drawer = useDrawer();
+    return (React.createElement(DrawerContext.Provider, { value: drawer }, children));
+}
+/**
+ * Hook to access the drawer context.
+ *
+ * @remarks
+ * This hook must be used within a DrawerProvider. If you don't need the provider pattern,
+ * use `useDrawer` directly instead.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *     const drawer = useDrawerContext();
+ *
+ *     return (
+ *         <button onClick={() => drawer.open('myDrawer', MyWrapper)}>
+ *             Open
+ *         </button>
+ *     );
+ * }
+ * ```
+ *
+ * @public
+ * @returns The drawer context value.
+ * @throws Error if used outside of a DrawerProvider.
+ */
+export function useDrawerContext() {
+    const context = useContext(DrawerContext);
+    if (!context) {
+        throw new Error('useDrawerContext must be used within a DrawerProvider');
+    }
+    return context;
+}
+//# sourceMappingURL=DrawerContext.js.map

package/Cdk/Overlays/Drawer/DrawerContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DrawerContext.js","sourceRoot":"","sources":["../../../../src/Cdk/Overlays/Drawer/DrawerContext.tsx"],"names":[],"mappings":"AAAA,kBAAkB;AAElB,OAAO,KAAK,EAAE,EAAE,aAAa,EAAE,UAAU,EAAkB,MAAM,OAAO,CAAC;AACzE,OAAO,EAAyB,SAAS,EAAE,MAAM,aAAa,CAAC;AAE/D,aAAa;AAEb;;;;GAIG;AACH,MAAM,aAAa,GAAG,aAAa,CAA0B,IAAI,CAAC,CAAC;AAgBnE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,cAAc,CAAC,EAAE,QAAQ,EAAwB;IAC7D,MAAM,MAAM,GAAG,SAAS,EAAE,CAAC;IAE3B,OAAO,CACH,oBAAC,aAAa,CAAC,QAAQ,IAAC,KAAK,EAAE,MAAM,IAChC,QAAQ,CACY,CAC5B,CAAC;AACN,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,gBAAgB;IAC5B,MAAM,OAAO,GAAG,UAAU,CAAC,aAAa,CAAC,CAAC;IAE1C,IAAI,CAAC,OAAO,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;IAC7E,CAAC;IAED,OAAO,OAAO,CAAC;AACnB,CAAC"}

package/Cdk/Overlays/Drawer/Index.d.ts

@@ -0,0 +1,3 @@
+export { useDrawer, type IUseDrawerReturn } from './useDrawer';
+export { DrawerProvider, useDrawerContext, type IDrawerProviderProps } from './DrawerContext';
+//# sourceMappingURL=Index.d.ts.map

package/Cdk/Overlays/Drawer/Index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Index.d.ts","sourceRoot":"","sources":["../../../../src/Cdk/Overlays/Drawer/Index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC"}

package/Cdk/Overlays/Drawer/Index.js

@@ -0,0 +1,5 @@
+// #region Exports
+export { useDrawer } from './useDrawer';
+export { DrawerProvider, useDrawerContext } from './DrawerContext';
+// #endregion
+//# sourceMappingURL=Index.js.map

package/Cdk/Overlays/Drawer/Index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Index.js","sourceRoot":"","sources":["../../../../src/Cdk/Overlays/Drawer/Index.ts"],"names":[],"mappings":"AAAA,kBAAkB;AAElB,OAAO,EAAE,SAAS,EAAyB,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAA6B,MAAM,iBAAiB,CAAC;AAE9F,aAAa"}

package/Cdk/Overlays/Drawer/useDrawer.d.ts

@@ -0,0 +1,66 @@
+import { type IDrawerOptions } from '@breadstone/mosaik-elements-foundation';
+/**
+ * Represents the return type of the `useDrawer` hook.
+ *
+ * @public
+ */
+export interface IUseDrawerReturn {
+    /**
+     * Opens a drawer with the specified wrapper component.
+     *
+     * @template T - Type of the wrapper component extending HTMLElement.
+     * @template TData - Type of data provided to the wrapper component.
+     * @template TResult - Expected return type of the resolved drawer result.
+     * @param drawerId - Unique identifier for the drawer.
+     * @param wrapperClass - Constructor for the wrapper component.
+     * @param options - Optional drawer configuration.
+     * @param data - Optional data to pass to the wrapper.
+     * @returns Promise resolving to the drawer result.
+     */
+    open<T extends HTMLElement, TData, TResult>(drawerId: string, wrapperClass: new (args?: TData) => T, options?: IDrawerOptions, data?: TData): Promise<TResult>;
+    /**
+     * Closes a drawer by its identifier.
+     *
+     * @template TResult - Type of the result to return.
+     * @param drawerId - The identifier of the drawer to close.
+     * @param result - Optional result to pass to the drawer opener.
+     * @returns Promise that resolves when the drawer is closed.
+     */
+    close<TResult>(drawerId: string, result?: TResult): Promise<void>;
+}
+/**
+ * React hook for managing drawers using the foundation DrawerService singleton.
+ *
+ * @remarks
+ * This hook provides a React-idiomatic interface to the foundation DrawerService.
+ * The service should be configured at application startup using `DrawerService.configure()`.
+ *
+ * @example
+ * ```tsx
+ * // In your app setup
+ * DrawerService.configure({
+ *     behaviors: [withDrawerStackBehavior({ baseWidth: '400px' })],
+ *     closeOnNavigation: true
+ * });
+ *
+ * // In your component
+ * function MyComponent() {
+ *     const drawer = useDrawer();
+ *
+ *     const handleOpen = async () => {
+ *         const result = await drawer.open('myDrawer', MyDrawerWrapper, {
+ *             position: 'right',
+ *             width: '400px'
+ *         });
+ *         console.log('Drawer result:', result);
+ *     };
+ *
+ *     return <button onClick={handleOpen}>Open Drawer</button>;
+ * }
+ * ```
+ *
+ * @public
+ * @returns An object containing drawer management functions.
+ */
+export declare function useDrawer(): IUseDrawerReturn;
+//# sourceMappingURL=useDrawer.d.ts.map

package/Cdk/Overlays/Drawer/useDrawer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDrawer.d.ts","sourceRoot":"","sources":["../../../../src/Cdk/Overlays/Drawer/useDrawer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAI5F;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAE7B;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,CAAC,SAAS,WAAW,EAAE,KAAK,EAAE,OAAO,EACtC,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,KAAK,IAAI,CAAC,EAAE,KAAK,KAAK,CAAC,EACrC,OAAO,CAAC,EAAE,cAAc,EACxB,IAAI,CAAC,EAAE,KAAK,GACb,OAAO,CAAC,OAAO,CAAC,CAAC;IAEpB;;;;;;;OAOG;IACH,KAAK,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAErE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,SAAS,IAAI,gBAAgB,CAsB5C"}

package/Cdk/Overlays/Drawer/useDrawer.js

@@ -0,0 +1,50 @@
+// #region Imports
+import { useCallback, useMemo } from 'react';
+import { DrawerService } from '@breadstone/mosaik-elements-foundation';
+/**
+ * React hook for managing drawers using the foundation DrawerService singleton.
+ *
+ * @remarks
+ * This hook provides a React-idiomatic interface to the foundation DrawerService.
+ * The service should be configured at application startup using `DrawerService.configure()`.
+ *
+ * @example
+ * ```tsx
+ * // In your app setup
+ * DrawerService.configure({
+ *     behaviors: [withDrawerStackBehavior({ baseWidth: '400px' })],
+ *     closeOnNavigation: true
+ * });
+ *
+ * // In your component
+ * function MyComponent() {
+ *     const drawer = useDrawer();
+ *
+ *     const handleOpen = async () => {
+ *         const result = await drawer.open('myDrawer', MyDrawerWrapper, {
+ *             position: 'right',
+ *             width: '400px'
+ *         });
+ *         console.log('Drawer result:', result);
+ *     };
+ *
+ *     return <button onClick={handleOpen}>Open Drawer</button>;
+ * }
+ * ```
+ *
+ * @public
+ * @returns An object containing drawer management functions.
+ */
+export function useDrawer() {
+    // #region Methods
+    const open = useCallback((drawerId, wrapperClass, options, data) => DrawerService.instance.open(drawerId, wrapperClass, options, data), []);
+    const close = useCallback((drawerId, result) => DrawerService.instance.close(drawerId, result), []);
+    // #endregion
+    // #region Properties
+    return useMemo(() => ({
+        open,
+        close
+    }), [open, close]);
+    // #endregion
+}
+//# sourceMappingURL=useDrawer.js.map

package/Cdk/Overlays/Drawer/useDrawer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDrawer.js","sourceRoot":"","sources":["../../../../src/Cdk/Overlays/Drawer/useDrawer.ts"],"names":[],"mappings":"AAAA,kBAAkB;AAElB,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAuB,MAAM,wCAAwC,CAAC;AA0C5F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,UAAU,SAAS;IACrB,kBAAkB;IAElB,MAAM,IAAI,GAAG,WAAW,CAAC,CACrB,QAAgB,EAChB,YAAqC,EACrC,OAAwB,EACxB,IAAY,EACI,EAAE,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAoB,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;IAElH,MAAM,KAAK,GAAG,WAAW,CAAC,CAAU,QAAgB,EAAE,MAAgB,EAAiB,EAAE,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC;IAE9I,aAAa;IAEb,qBAAqB;IAErB,OAAO,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;QAClB,IAAI;QACJ,KAAK;KACR,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;IAEnB,aAAa;AACjB,CAAC"}

package/Cdk/Overlays/Index.d.ts

@@ -0,0 +1,6 @@
+export * from './Sheet/Index';
+export * from './Dialog/Index';
+export * from './Drawer/Index';
+export * from './MessageBox/Index';
+export * from './Toast/Index';
+//# sourceMappingURL=Index.d.ts.map

package/Cdk/Overlays/Index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Index.d.ts","sourceRoot":"","sources":["../../../src/Cdk/Overlays/Index.ts"],"names":[],"mappings":"AAEA,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC"}

package/Cdk/Overlays/Index.js

@@ -0,0 +1,8 @@
+// #region Exports
+export * from './Sheet/Index';
+export * from './Dialog/Index';
+export * from './Drawer/Index';
+export * from './MessageBox/Index';
+export * from './Toast/Index';
+// #endregion
+//# sourceMappingURL=Index.js.map

package/Cdk/Overlays/Index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Index.js","sourceRoot":"","sources":["../../../src/Cdk/Overlays/Index.ts"],"names":[],"mappings":"AAAA,kBAAkB;AAElB,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAE9B,aAAa"}

package/Cdk/Overlays/MessageBox/Index.d.ts

@@ -0,0 +1,3 @@
+export { useMessageBox, type IUseMessageBoxReturn } from './useMessageBox';
+export { MessageBoxProvider, useMessageBoxContext, type IMessageBoxProviderProps } from './MessageBoxContext';
+//# sourceMappingURL=Index.d.ts.map

package/Cdk/Overlays/MessageBox/Index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Index.d.ts","sourceRoot":"","sources":["../../../../src/Cdk/Overlays/MessageBox/Index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,KAAK,wBAAwB,EAAE,MAAM,qBAAqB,CAAC"}

package/Cdk/Overlays/MessageBox/Index.js

@@ -0,0 +1,5 @@
+// #region Exports
+export { useMessageBox } from './useMessageBox';
+export { MessageBoxProvider, useMessageBoxContext } from './MessageBoxContext';
+// #endregion
+//# sourceMappingURL=Index.js.map

package/Cdk/Overlays/MessageBox/Index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Index.js","sourceRoot":"","sources":["../../../../src/Cdk/Overlays/MessageBox/Index.ts"],"names":[],"mappings":"AAAA,kBAAkB;AAElB,OAAO,EAAE,aAAa,EAA6B,MAAM,iBAAiB,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAiC,MAAM,qBAAqB,CAAC;AAE9G,aAAa"}

package/Cdk/Overlays/MessageBox/MessageBoxContext.d.ts

@@ -0,0 +1,63 @@
+import { type ReactNode } from 'react';
+import { type IUseMessageBoxReturn } from './useMessageBox';
+/**
+ * Props for the MessageBoxProvider component.
+ *
+ * @public
+ */
+export interface IMessageBoxProviderProps {
+    /**
+     * Child components that will have access to the message box context.
+     */
+    children: ReactNode;
+}
+/**
+ * Provider component that makes message box functionality available to all child components.
+ *
+ * @remarks
+ * Place this provider at the root of your application or at a level where all
+ * components that need message box access are descendants.
+ *
+ * @example
+ * ```tsx
+ * // In your app root
+ * function App() {
+ *     return (
+ *         <MessageBoxProvider>
+ *             <YourAppContent />
+ *         </MessageBoxProvider>
+ *     );
+ * }
+ * ```
+ *
+ * @public
+ * @param props - The provider props.
+ * @returns The provider component wrapping children.
+ */
+export declare function MessageBoxProvider({ children }: IMessageBoxProviderProps): ReactNode;
+/**
+ * Hook to access the message box context.
+ *
+ * @remarks
+ * This hook must be used within a MessageBoxProvider. If you don't need the provider pattern,
+ * use `useMessageBox` directly instead.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *     const messageBox = useMessageBoxContext();
+ *
+ *     return (
+ *         <button onClick={() => messageBox.open({ header: 'Info', content: 'Hello!' })}>
+ *             Show Message
+ *         </button>
+ *     );
+ * }
+ * ```
+ *
+ * @public
+ * @returns The message box context value.
+ * @throws Error if used outside of a MessageBoxProvider.
+ */
+export declare function useMessageBoxContext(): IUseMessageBoxReturn;
+//# sourceMappingURL=MessageBoxContext.d.ts.map

package/Cdk/Overlays/MessageBox/MessageBoxContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageBoxContext.d.ts","sourceRoot":"","sources":["../../../../src/Cdk/Overlays/MessageBox/MessageBoxContext.tsx"],"names":[],"mappings":"AAEA,OAAc,EAA6B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACzE,OAAO,EAAE,KAAK,oBAAoB,EAAiB,MAAM,iBAAiB,CAAC;AAW3E;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IAErC;;OAEG;IACH,QAAQ,EAAE,SAAS,CAAC;CAEvB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,QAAQ,EAAE,EAAE,wBAAwB,GAAG,SAAS,CAQpF;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,oBAAoB,IAAI,oBAAoB,CAQ3D"}

package/Cdk/Overlays/MessageBox/MessageBoxContext.js

@@ -0,0 +1,69 @@
+// #region Imports
+import React, { createContext, useContext } from 'react';
+import { useMessageBox } from './useMessageBox';
+// #endregion
+/**
+ * Context for providing message box functionality throughout the React component tree.
+ *
+ * @internal
+ */
+const MessageBoxContext = createContext(null);
+/**
+ * Provider component that makes message box functionality available to all child components.
+ *
+ * @remarks
+ * Place this provider at the root of your application or at a level where all
+ * components that need message box access are descendants.
+ *
+ * @example
+ * ```tsx
+ * // In your app root
+ * function App() {
+ *     return (
+ *         <MessageBoxProvider>
+ *             <YourAppContent />
+ *         </MessageBoxProvider>
+ *     );
+ * }
+ * ```
+ *
+ * @public
+ * @param props - The provider props.
+ * @returns The provider component wrapping children.
+ */
+export function MessageBoxProvider({ children }) {
+    const messageBox = useMessageBox();
+    return (React.createElement(MessageBoxContext.Provider, { value: messageBox }, children));
+}
+/**
+ * Hook to access the message box context.
+ *
+ * @remarks
+ * This hook must be used within a MessageBoxProvider. If you don't need the provider pattern,
+ * use `useMessageBox` directly instead.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *     const messageBox = useMessageBoxContext();
+ *
+ *     return (
+ *         <button onClick={() => messageBox.open({ header: 'Info', content: 'Hello!' })}>
+ *             Show Message
+ *         </button>
+ *     );
+ * }
+ * ```
+ *
+ * @public
+ * @returns The message box context value.
+ * @throws Error if used outside of a MessageBoxProvider.
+ */
+export function useMessageBoxContext() {
+    const context = useContext(MessageBoxContext);
+    if (!context) {
+        throw new Error('useMessageBoxContext must be used within a MessageBoxProvider');
+    }
+    return context;
+}
+//# sourceMappingURL=MessageBoxContext.js.map

package/Cdk/Overlays/MessageBox/MessageBoxContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageBoxContext.js","sourceRoot":"","sources":["../../../../src/Cdk/Overlays/MessageBox/MessageBoxContext.tsx"],"names":[],"mappings":"AAAA,kBAAkB;AAElB,OAAO,KAAK,EAAE,EAAE,aAAa,EAAE,UAAU,EAAkB,MAAM,OAAO,CAAC;AACzE,OAAO,EAA6B,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAE3E,aAAa;AAEb;;;;GAIG;AACH,MAAM,iBAAiB,GAAG,aAAa,CAA8B,IAAI,CAAC,CAAC;AAgB3E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,kBAAkB,CAAC,EAAE,QAAQ,EAA4B;IACrE,MAAM,UAAU,GAAG,aAAa,EAAE,CAAC;IAEnC,OAAO,CACH,oBAAC,iBAAiB,CAAC,QAAQ,IAAC,KAAK,EAAE,UAAU,IACxC,QAAQ,CACgB,CAChC,CAAC;AACN,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,oBAAoB;IAChC,MAAM,OAAO,GAAG,UAAU,CAAC,iBAAiB,CAAC,CAAC;IAE9C,IAAI,CAAC,OAAO,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;IACrF,CAAC;IAED,OAAO,OAAO,CAAC;AACnB,CAAC"}

package/Cdk/Overlays/MessageBox/useMessageBox.d.ts

@@ -0,0 +1,62 @@
+import { type IMessageBoxOptions, type MessageBoxResult } from '@breadstone/mosaik-elements-foundation';
+/**
+ * Represents the return type of the `useMessageBox` hook.
+ *
+ * @public
+ */
+export interface IUseMessageBoxReturn {
+    /**
+     * Opens a message box with the specified options.
+     *
+     * @param options - Message box configuration options.
+     * @returns Promise resolving to the MessageBoxResult.
+     */
+    open(options?: Partial<IMessageBoxOptions>): Promise<MessageBoxResult>;
+    /**
+     * Closes a message box by its identifier.
+     *
+     * @param messageBoxId - The identifier of the message box to close.
+     * @returns Promise that resolves when the message box is closed.
+     */
+    close(messageBoxId: string): Promise<void>;
+}
+/**
+ * React hook for managing message boxes using the foundation MessageBoxService singleton.
+ *
+ * @remarks
+ * This hook provides a React-idiomatic interface to the foundation MessageBoxService.
+ * The service should be configured at application startup using `MessageBoxService.configure()`.
+ *
+ * @example
+ * ```tsx
+ * // In your app setup
+ * MessageBoxService.configure({
+ *     closeOnNavigation: true,
+ *     behaviors: []
+ * });
+ *
+ * // In your component
+ * function MyComponent() {
+ *     const messageBox = useMessageBox();
+ *
+ *     const handleConfirm = async () => {
+ *         const result = await messageBox.open({
+ *             header: 'Confirm Delete',
+ *             content: 'Are you sure you want to delete this item?',
+ *             buttons: MessageBoxButtons.YesNo
+ *         });
+ *
+ *         if (result === MessageBoxResult.Yes) {
+ *             // User confirmed
+ *         }
+ *     };
+ *
+ *     return <button onClick={handleConfirm}>Delete Item</button>;
+ * }
+ * ```
+ *
+ * @public
+ * @returns An object containing message box management functions.
+ */
+export declare function useMessageBox(): IUseMessageBoxReturn;
+//# sourceMappingURL=useMessageBox.d.ts.map