@c15t/react 0.0.1-rc.10

package/dist/context/consent-manager-context.cjs

@@ -0,0 +1,38 @@
+'use client';
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ConsentStateContext: ()=>ConsentStateContext
+});
+const external_react_namespaceObject = require("react");
+const ConsentStateContext = external_react_namespaceObject.createContext(void 0);
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});

package/dist/context/consent-manager-context.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import type { ConsentManagerContextValue } from '../types/consent-manager';
+/**
+ * React context for sharing consent management state.
+ *
+ * @remarks
+ * This context provides access to both the current consent state and
+ * the methods to modify it throughout the application.
+ *
+ * @internal
+ */
+export declare const ConsentStateContext: React.Context<ConsentManagerContextValue | undefined>;
+//# sourceMappingURL=consent-manager-context.d.ts.map

package/dist/context/consent-manager-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent-manager-context.d.ts","sourceRoot":"","sources":["../../src/context/consent-manager-context.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AAE3E;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,uDAEpB,CAAC"}

package/dist/context/consent-manager-context.js

@@ -0,0 +1,4 @@
+'use client';
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+const ConsentStateContext = __WEBPACK_EXTERNAL_MODULE_react__.createContext(void 0);
+export { ConsentStateContext };

package/dist/context/theme-context.cjs

@@ -0,0 +1,40 @@
+'use client';
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    LocalThemeContext: ()=>LocalThemeContext,
+    GlobalThemeContext: ()=>GlobalThemeContext
+});
+const external_react_namespaceObject = require("react");
+const GlobalThemeContext = (0, external_react_namespaceObject.createContext)(null);
+const LocalThemeContext = (0, external_react_namespaceObject.createContext)(null);
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});

package/dist/context/theme-context.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Configuration value type for the ThemeContext.
+ *
+ * @remarks
+ * Provides type-safe theme customization options for components.
+ * Supports generic theme types for different component variants.
+ * Includes animation and style control features.
+ *
+ * @typeParam Theme - The theme configuration type for the component
+ *
+ * @example
+ * ```tsx
+ * type MyTheme = {
+ *   colors: {
+ *     primary: string;
+ *     secondary: string;
+ *   };
+ * };
+ *
+ * const value: ThemeContextValue<MyTheme> = {
+ *   theme: {
+ *     colors: {
+ *       primary: '#007bff',
+ *       secondary: '#6c757d'
+ *     }
+ *   },
+ *   noStyle: false,
+ *   disableAnimation: false
+ * };
+ * ```
+ *
+ * @public
+ */
+export type ThemeContextValue<Theme = unknown> = {
+    /**
+     * Theme configuration object for styling components
+     * @remarks Partial to allow incremental theme overrides
+     * @default undefined
+     */
+    theme?: Partial<Theme>;
+    /**
+     * Disables all animations when true
+     * @remarks Useful for reduced motion preferences
+     * @default false
+     */
+    disableAnimation?: boolean;
+    /**
+     * Removes default styles when true
+     * @remarks Enables fully custom styling
+     * @default false
+     */
+    noStyle?: boolean;
+    /**
+     * Locks the scroll when true & hides the overlay when disabled
+     * @remarks Useful for preventing scroll when a modal is open
+     * @default false
+     */
+    scrollLock?: boolean;
+    /**
+     * Traps keyboard focus within a dialog when true
+     * @remarks Enhances accessibility for modal dialogs
+     * @default true
+     */
+    trapFocus?: boolean;
+};
+/**
+ * Context for providing theme values to components.
+ *
+ * @remarks
+ * Combines consent management state with theme configuration.
+ * Must be provided by a parent Theme.Root component.
+ * Supports TypeScript generic themes for type safety.
+ *
+ * @example
+ * ```tsx
+ * <ThemeContext.Provider value={{ theme: myTheme, noStyle: false }}>
+ *   <App />
+ * </ThemeContext.Provider>
+ * ```
+ *
+ * @public
+ */
+export declare const GlobalThemeContext: import("react").Context<ThemeContextValue<unknown> | null>;
+/**
+ * Context for providing theme values to components.
+ *
+ * @remarks
+ * Combines consent management state with theme configuration.
+ * Must be provided by a parent Theme.Root component.
+ * Supports TypeScript generic themes for type safety.
+ *
+ * @example
+ * ```tsx
+ * <ThemeContext.Provider value={{ theme: myTheme, noStyle: false }}>
+ *   <App />
+ * </ThemeContext.Provider>
+ * ```
+ *
+ * @public
+ */
+export declare const LocalThemeContext: import("react").Context<ThemeContextValue<unknown> | null>;
+//# sourceMappingURL=theme-context.d.ts.map

package/dist/context/theme-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-context.d.ts","sourceRoot":"","sources":["../../src/context/theme-context.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,MAAM,iBAAiB,CAAC,KAAK,GAAG,OAAO,IAAI;IAChD;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IAEvB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB,4DACwB,CAAC;AAExD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iBAAiB,4DACyB,CAAC"}

package/dist/context/theme-context.js

@@ -0,0 +1,5 @@
+'use client';
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+const GlobalThemeContext = (0, __WEBPACK_EXTERNAL_MODULE_react__.createContext)(null);
+const LocalThemeContext = (0, __WEBPACK_EXTERNAL_MODULE_react__.createContext)(null);
+export { GlobalThemeContext, LocalThemeContext };

package/dist/hooks/index.cjs

@@ -0,0 +1,94 @@
+"use strict";
+var __webpack_modules__ = {
+    "./use-consent-manager": function(module) {
+        module.exports = require("./use-consent-manager.cjs");
+    },
+    "./use-focus-trap": function(module) {
+        module.exports = require("./use-focus-trap.cjs");
+    },
+    "./use-theme": function(module) {
+        module.exports = require("./use-theme.cjs");
+    },
+    "./use-translations": function(module) {
+        module.exports = require("./use-translations.cjs");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = function(module) {
+        var getter = module && module.__esModule ? function() {
+            return module['default'];
+        } : function() {
+            return module;
+        };
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _use_consent_manager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./use-consent-manager");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _use_consent_manager__WEBPACK_IMPORTED_MODULE_0__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _use_consent_manager__WEBPACK_IMPORTED_MODULE_0__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _use_focus_trap__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./use-focus-trap");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _use_focus_trap__WEBPACK_IMPORTED_MODULE_1__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _use_focus_trap__WEBPACK_IMPORTED_MODULE_1__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _use_theme__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./use-theme");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _use_theme__WEBPACK_IMPORTED_MODULE_2__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _use_theme__WEBPACK_IMPORTED_MODULE_2__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _use_translations__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./use-translations");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _use_translations__WEBPACK_IMPORTED_MODULE_3__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _use_translations__WEBPACK_IMPORTED_MODULE_3__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+})();
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});

package/dist/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './use-consent-manager';
+export * from './use-focus-trap';
+export * from './use-theme';
+export * from './use-translations';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC"}

package/dist/hooks/index.js

@@ -0,0 +1,4 @@
+export * from "./use-consent-manager.js";
+export * from "./use-focus-trap.js";
+export * from "./use-theme.js";
+export * from "./use-translations.js";

package/dist/hooks/use-consent-manager.cjs

@@ -0,0 +1,45 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useConsentManager: ()=>useConsentManager
+});
+const external_react_namespaceObject = require("react");
+const consent_manager_context_cjs_namespaceObject = require("../context/consent-manager-context.cjs");
+function useConsentManager() {
+    const context = (0, external_react_namespaceObject.useContext)(consent_manager_context_cjs_namespaceObject.ConsentStateContext);
+    if (void 0 === context) throw new Error('useConsentManager must be used within a ConsentManagerProvider');
+    return {
+        ...context.state,
+        ...context.store.getState()
+    };
+}
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});

package/dist/hooks/use-consent-manager.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Hook for accessing and managing consent state.
+ *
+ * @remarks
+ * This hook provides access to the complete consent management API, including:
+ * - Current consent state (what consents are given/required)
+ * - Methods to update consents
+ * - Compliance settings and region detection
+ * - State persistence and retrieval
+ *
+ * The hook must be used within a ConsentManagerProvider component.
+ *
+ * @throws {Error}
+ * Throws if used outside of a ConsentManagerProvider context.
+ *
+ * @returns Combined state and methods for consent management
+ * @public
+ */
+export declare function useConsentManager(): {
+    consents: import("c15t").ConsentState;
+    consentInfo: {
+        time: number;
+        type: "all" | "custom" | "necessary";
+    } | null;
+    showPopup: boolean;
+    isLoadingConsentInfo: boolean;
+    gdprTypes: import("c15t").AllConsentNames[];
+    isPrivacyDialogOpen: boolean;
+    complianceSettings: Record<import("c15t").ComplianceRegion, import("c15t").ComplianceSettings>;
+    callbacks: import("c15t").Callbacks;
+    detectedCountry: string | null;
+    locationInfo: import("c15t").LocationInfo | null;
+    jurisdictionInfo: import("c15t").JurisdictionInfo | null;
+    privacySettings: import("c15t").PrivacySettings;
+    translationConfig: import("c15t").TranslationConfig;
+    setTranslationConfig: (config: import("c15t").TranslationConfig) => void;
+    includeNonDisplayedConsents: boolean;
+    consentTypes: import("c15t").ConsentType[];
+    setConsent: (name: import("c15t").AllConsentNames, value: boolean) => void;
+    setShowPopup: (show: boolean, force?: boolean) => void;
+    setIsPrivacyDialogOpen: (isOpen: boolean) => void;
+    saveConsents: (type: "all" | "custom" | "necessary") => void;
+    resetConsents: () => void;
+    setGdprTypes: (types: import("c15t").AllConsentNames[]) => void;
+    setComplianceSetting: (region: import("c15t").ComplianceRegion, settings: Partial<import("c15t").ComplianceSettings>) => void;
+    resetComplianceSettings: () => void;
+    setCallback: (name: keyof import("c15t").Callbacks, callback: import("c15t").CallbackFunction | undefined) => void;
+    setDetectedCountry: (country: string) => void;
+    setLocationInfo: (location: import("c15t").LocationInfo | null) => void;
+    setJurisdictionInfo: (jurisdiction: import("c15t").JurisdictionInfo | null) => void;
+    fetchConsentBannerInfo: (url?: string) => Promise<import("c15t").ConsentBannerResponse | undefined>;
+    getDisplayedConsents: () => typeof import("c15t").consentTypes;
+    hasConsented: () => boolean;
+    clearAllData: () => void;
+    updateConsentMode: () => void;
+    setPrivacySettings: (settings: Partial<import("c15t").PrivacySettings>) => void;
+    getEffectiveConsents: () => import("c15t").ConsentState;
+    hasConsentFor: (consentType: import("c15t").AllConsentNames) => boolean;
+    setIncludeNonDisplayedConsents: (include: boolean) => void;
+};
+//# sourceMappingURL=use-consent-manager.d.ts.map

package/dist/hooks/use-consent-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-consent-manager.d.ts","sourceRoot":"","sources":["../../src/hooks/use-consent-manager.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB;;;;;;;;;;;;;;;;;;;;;uCAc21E,CAAC;;;;;;;;;;;gCAA+kE,CAAC;;;;;;;;;EAD58I"}

package/dist/hooks/use-consent-manager.js

@@ -0,0 +1,11 @@
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE__context_consent_manager_context_js_ee8f06d2__ from "../context/consent-manager-context.js";
+function useConsentManager() {
+    const context = (0, __WEBPACK_EXTERNAL_MODULE_react__.useContext)(__WEBPACK_EXTERNAL_MODULE__context_consent_manager_context_js_ee8f06d2__.ConsentStateContext);
+    if (void 0 === context) throw new Error('useConsentManager must be used within a ConsentManagerProvider');
+    return {
+        ...context.state,
+        ...context.store.getState()
+    };
+}
+export { useConsentManager };

package/dist/hooks/use-focus-trap.cjs

@@ -0,0 +1,76 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useFocusTrap: ()=>useFocusTrap
+});
+const external_react_namespaceObject = require("react");
+function useFocusTrap(shouldTrap, containerRef) {
+    const previousFocusRef = (0, external_react_namespaceObject.useRef)(null);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (!shouldTrap || !containerRef || !containerRef.current) return;
+        previousFocusRef.current = document.activeElement;
+        const focusableElements = getFocusableElements(containerRef.current);
+        if (focusableElements.length > 0) setTimeout(()=>{
+            focusableElements[0]?.focus();
+        }, 0);
+        else if (-1 !== containerRef.current.tabIndex) try {
+            containerRef.current.focus();
+        } catch (e) {}
+        const handleKeyDown = (e)=>{
+            if ('Tab' !== e.key || !containerRef.current) return;
+            const focusableElements = getFocusableElements(containerRef.current);
+            if (0 === focusableElements.length) return;
+            const firstElement = focusableElements[0];
+            const lastElement = focusableElements.at(-1);
+            if (e.shiftKey && document.activeElement === firstElement) {
+                e.preventDefault();
+                lastElement?.focus();
+            } else if (!e.shiftKey && document.activeElement === lastElement) {
+                e.preventDefault();
+                firstElement?.focus();
+            }
+        };
+        document.addEventListener('keydown', handleKeyDown);
+        return ()=>{
+            document.removeEventListener('keydown', handleKeyDown);
+            if (previousFocusRef.current && 'focus' in previousFocusRef.current) setTimeout(()=>previousFocusRef.current?.focus(), 0);
+        };
+    }, [
+        shouldTrap,
+        containerRef
+    ]);
+}
+function getFocusableElements(container) {
+    const selector = 'a[href]:not([disabled]),button:not([disabled]),textarea:not([disabled]),input:not([disabled]),select:not([disabled]),[contenteditable],[tabindex]:not([tabindex="-1"])';
+    return Array.from(container.querySelectorAll(selector)).filter((el)=>el.offsetWidth > 0 && el.offsetHeight > 0);
+}
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});

package/dist/hooks/use-focus-trap.d.ts

@@ -0,0 +1,15 @@
+import { type RefObject } from 'react';
+/**
+ * Hook that manages focus trapping within a container.
+ *
+ * @remarks
+ * This hook ensures keyboard navigation stays within the container
+ * while it's active, improving accessibility for modal dialogs.
+ *
+ * @param shouldTrap - Boolean indicating whether focus should be trapped
+ * @param containerRef - Reference to the container element
+ *
+ * @public
+ */
+export declare function useFocusTrap(shouldTrap: boolean, containerRef: RefObject<HTMLElement> | null): void;
+//# sourceMappingURL=use-focus-trap.d.ts.map

package/dist/hooks/use-focus-trap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-focus-trap.d.ts","sourceRoot":"","sources":["../../src/hooks/use-focus-trap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAqB,MAAM,OAAO,CAAC;AAE1D;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAC3B,UAAU,EAAE,OAAO,EACnB,YAAY,EAAE,SAAS,CAAC,WAAW,CAAC,GAAG,IAAI,GACzC,IAAI,CAiEN"}

package/dist/hooks/use-focus-trap.js

@@ -0,0 +1,42 @@
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+function useFocusTrap(shouldTrap, containerRef) {
+    const previousFocusRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(null);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (!shouldTrap || !containerRef || !containerRef.current) return;
+        previousFocusRef.current = document.activeElement;
+        const focusableElements = getFocusableElements(containerRef.current);
+        if (focusableElements.length > 0) setTimeout(()=>{
+            focusableElements[0]?.focus();
+        }, 0);
+        else if (-1 !== containerRef.current.tabIndex) try {
+            containerRef.current.focus();
+        } catch (e) {}
+        const handleKeyDown = (e)=>{
+            if ('Tab' !== e.key || !containerRef.current) return;
+            const focusableElements = getFocusableElements(containerRef.current);
+            if (0 === focusableElements.length) return;
+            const firstElement = focusableElements[0];
+            const lastElement = focusableElements.at(-1);
+            if (e.shiftKey && document.activeElement === firstElement) {
+                e.preventDefault();
+                lastElement?.focus();
+            } else if (!e.shiftKey && document.activeElement === lastElement) {
+                e.preventDefault();
+                firstElement?.focus();
+            }
+        };
+        document.addEventListener('keydown', handleKeyDown);
+        return ()=>{
+            document.removeEventListener('keydown', handleKeyDown);
+            if (previousFocusRef.current && 'focus' in previousFocusRef.current) setTimeout(()=>previousFocusRef.current?.focus(), 0);
+        };
+    }, [
+        shouldTrap,
+        containerRef
+    ]);
+}
+function getFocusableElements(container) {
+    const selector = 'a[href]:not([disabled]),button:not([disabled]),textarea:not([disabled]),input:not([disabled]),select:not([disabled]),[contenteditable],[tabindex]:not([tabindex="-1"])';
+    return Array.from(container.querySelectorAll(selector)).filter((el)=>el.offsetWidth > 0 && el.offsetHeight > 0);
+}
+export { useFocusTrap };

package/dist/hooks/use-scroll-lock.cjs

@@ -0,0 +1,55 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useScrollLock: ()=>useScrollLock
+});
+const external_react_namespaceObject = require("react");
+function useScrollLock(shouldLock) {
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (shouldLock) {
+            const originalStyles = {
+                overflow: document.body.style.overflow,
+                paddingRight: document.body.style.paddingRight
+            };
+            const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+            document.body.style.overflow = 'hidden';
+            if (scrollbarWidth > 0) document.body.style.paddingRight = `${scrollbarWidth}px`;
+            return ()=>{
+                document.body.style.overflow = originalStyles.overflow;
+                document.body.style.paddingRight = originalStyles.paddingRight;
+            };
+        }
+    }, [
+        shouldLock
+    ]);
+}
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});