@c15t/react 0.0.1-rc.3

package/dist/common/components/consent-manager-provider.cjs

@@ -0,0 +1,93 @@
+'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__, {
+    ConsentManagerProvider: ()=>ConsentManagerProvider
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_c15t_namespaceObject = require("c15t");
+const external_react_namespaceObject = require("react");
+const consent_manager_context_cjs_namespaceObject = require("../context/consent-manager-context.cjs");
+const translations_cjs_namespaceObject = require("../utils/translations.cjs");
+function ConsentManagerProvider({ children, initialGdprTypes, initialComplianceSettings, namespace = 'KoroflowStore', noStyle = false, translationConfig, trackingBlockerConfig }) {
+    const preparedTranslationConfig = (0, external_react_namespaceObject.useMemo)(()=>{
+        const mergedConfig = (0, translations_cjs_namespaceObject.mergeTranslationConfigs)(external_c15t_namespaceObject.defaultTranslationConfig, translationConfig);
+        const defaultLanguage = (0, translations_cjs_namespaceObject.detectBrowserLanguage)(mergedConfig.translations, mergedConfig.defaultLanguage, mergedConfig.disableAutoLanguageSwitch);
+        return {
+            ...mergedConfig,
+            defaultLanguage
+        };
+    }, [
+        translationConfig
+    ]);
+    const store = (0, external_react_namespaceObject.useMemo)(()=>{
+        const store = (0, external_c15t_namespaceObject.createConsentManagerStore)(namespace, {
+            trackingBlockerConfig
+        });
+        store.getState().setTranslationConfig(preparedTranslationConfig);
+        return store;
+    }, [
+        namespace,
+        preparedTranslationConfig,
+        trackingBlockerConfig
+    ]);
+    const [state, setState] = (0, external_react_namespaceObject.useState)(store.getState());
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        const { setGdprTypes, setComplianceSetting, setDetectedCountry } = store.getState();
+        if (initialGdprTypes) setGdprTypes(initialGdprTypes);
+        if (initialComplianceSettings) for (const [region, settings] of Object.entries(initialComplianceSettings))setComplianceSetting(region, settings);
+        const country = document.querySelector('meta[name="user-country"]')?.getAttribute('content') || 'US';
+        setDetectedCountry(country);
+        const unsubscribe = store.subscribe((newState)=>{
+            setState(newState);
+        });
+        return ()=>{
+            unsubscribe();
+        };
+    }, [
+        store,
+        initialGdprTypes,
+        initialComplianceSettings
+    ]);
+    const contextValue = (0, external_react_namespaceObject.useMemo)(()=>({
+            state,
+            store
+        }), [
+        state,
+        store
+    ]);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(consent_manager_context_cjs_namespaceObject.ConsentStateContext.Provider, {
+        value: contextValue,
+        children: children
+    });
+}
+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/common/components/consent-manager-provider.d.ts

@@ -0,0 +1,16 @@
+import type { ConsentManagerProviderProps } from '../types/consent-manager';
+/**
+ * Provider component for consent management functionality.
+ *
+ * @remarks
+ * This component initializes and manages the consent management system, including:
+ * - Setting up the consent store with initial configuration
+ * - Detecting user's region for compliance
+ * - Managing consent state updates
+ * - Providing access to consent management throughout the app
+ * - Injecting default styles (unless noStyle is true)
+ *
+ * @public
+ */
+export declare function ConsentManagerProvider({ children, initialGdprTypes, initialComplianceSettings, namespace, noStyle, translationConfig, trackingBlockerConfig, }: ConsentManagerProviderProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=consent-manager-provider.d.ts.map

package/dist/common/components/consent-manager-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent-manager-provider.d.ts","sourceRoot":"","sources":["../../../src/common/components/consent-manager-provider.tsx"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAM5E;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,EACtC,QAAQ,EACR,gBAAgB,EAChB,yBAAyB,EACzB,SAA2B,EAC3B,OAAe,EACf,iBAAiB,EACjB,qBAAqB,GACrB,EAAE,2BAA2B,2CA6E7B"}

package/dist/common/components/consent-manager-provider.js

@@ -0,0 +1,59 @@
+'use client';
+import * as __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__ from "react/jsx-runtime";
+import * as __WEBPACK_EXTERNAL_MODULE_c15t__ from "c15t";
+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";
+import * as __WEBPACK_EXTERNAL_MODULE__utils_translations_js_c2629c1f__ from "../utils/translations.js";
+function ConsentManagerProvider({ children, initialGdprTypes, initialComplianceSettings, namespace = 'KoroflowStore', noStyle = false, translationConfig, trackingBlockerConfig }) {
+    const preparedTranslationConfig = (0, __WEBPACK_EXTERNAL_MODULE_react__.useMemo)(()=>{
+        const mergedConfig = (0, __WEBPACK_EXTERNAL_MODULE__utils_translations_js_c2629c1f__.mergeTranslationConfigs)(__WEBPACK_EXTERNAL_MODULE_c15t__.defaultTranslationConfig, translationConfig);
+        const defaultLanguage = (0, __WEBPACK_EXTERNAL_MODULE__utils_translations_js_c2629c1f__.detectBrowserLanguage)(mergedConfig.translations, mergedConfig.defaultLanguage, mergedConfig.disableAutoLanguageSwitch);
+        return {
+            ...mergedConfig,
+            defaultLanguage
+        };
+    }, [
+        translationConfig
+    ]);
+    const store = (0, __WEBPACK_EXTERNAL_MODULE_react__.useMemo)(()=>{
+        const store = (0, __WEBPACK_EXTERNAL_MODULE_c15t__.createConsentManagerStore)(namespace, {
+            trackingBlockerConfig
+        });
+        store.getState().setTranslationConfig(preparedTranslationConfig);
+        return store;
+    }, [
+        namespace,
+        preparedTranslationConfig,
+        trackingBlockerConfig
+    ]);
+    const [state, setState] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(store.getState());
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        const { setGdprTypes, setComplianceSetting, setDetectedCountry } = store.getState();
+        if (initialGdprTypes) setGdprTypes(initialGdprTypes);
+        if (initialComplianceSettings) for (const [region, settings] of Object.entries(initialComplianceSettings))setComplianceSetting(region, settings);
+        const country = document.querySelector('meta[name="user-country"]')?.getAttribute('content') || 'US';
+        setDetectedCountry(country);
+        const unsubscribe = store.subscribe((newState)=>{
+            setState(newState);
+        });
+        return ()=>{
+            unsubscribe();
+        };
+    }, [
+        store,
+        initialGdprTypes,
+        initialComplianceSettings
+    ]);
+    const contextValue = (0, __WEBPACK_EXTERNAL_MODULE_react__.useMemo)(()=>({
+            state,
+            store
+        }), [
+        state,
+        store
+    ]);
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(__WEBPACK_EXTERNAL_MODULE__context_consent_manager_context_js_ee8f06d2__.ConsentStateContext.Provider, {
+        value: contextValue,
+        children: children
+    });
+}
+export { ConsentManagerProvider };

package/dist/common/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/common/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/common/context/consent-manager-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent-manager-context.d.ts","sourceRoot":"","sources":["../../../src/common/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/common/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/common/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/common/hooks/use-consent-manager.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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(): any;
+//# sourceMappingURL=use-consent-manager.d.ts.map

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

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

package/dist/common/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/common/index.cjs

@@ -0,0 +1,42 @@
+"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__, {
+    consentTypes: ()=>external_c15t_namespaceObject.consentTypes,
+    ConsentManagerProvider: ()=>consent_manager_provider_cjs_namespaceObject.ConsentManagerProvider,
+    useConsentManager: ()=>use_consent_manager_cjs_namespaceObject.useConsentManager,
+    useTranslations: ()=>use_translations_cjs_namespaceObject.useTranslations
+});
+const consent_manager_provider_cjs_namespaceObject = require("./components/consent-manager-provider.cjs");
+const use_consent_manager_cjs_namespaceObject = require("./hooks/use-consent-manager.cjs");
+const use_translations_cjs_namespaceObject = require("./store/use-translations.cjs");
+const external_c15t_namespaceObject = require("c15t");
+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/common/index.d.ts

@@ -0,0 +1,7 @@
+export { ConsentManagerProvider } from './components/consent-manager-provider';
+export { useConsentManager } from './hooks/use-consent-manager';
+export type { ConsentManagerProviderProps } from './types/consent-manager';
+export { useTranslations } from './store/use-translations';
+export { consentTypes } from 'c15t';
+export type { CallbackFunction, Callbacks, AllConsentNames, ConsentType, ConsentState, ComplianceRegion, ComplianceSettings, PrivacySettings, HasConsentedProps, } from 'c15t';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/common/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAChE,YAAY,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAG3D,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AACpC,YAAY,EACX,gBAAgB,EAChB,SAAS,EACT,eAAe,EACf,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,iBAAiB,GACjB,MAAM,MAAM,CAAC"}

package/dist/common/index.js

@@ -0,0 +1,9 @@
+import * as __WEBPACK_EXTERNAL_MODULE__components_consent_manager_provider_js_f0dc1a38__ from "./components/consent-manager-provider.js";
+import * as __WEBPACK_EXTERNAL_MODULE__hooks_use_consent_manager_js_2b895421__ from "./hooks/use-consent-manager.js";
+import * as __WEBPACK_EXTERNAL_MODULE__store_use_translations_js_f5c44c99__ from "./store/use-translations.js";
+import * as __WEBPACK_EXTERNAL_MODULE_c15t__ from "c15t";
+var __webpack_exports__ConsentManagerProvider = __WEBPACK_EXTERNAL_MODULE__components_consent_manager_provider_js_f0dc1a38__.ConsentManagerProvider;
+var __webpack_exports__consentTypes = __WEBPACK_EXTERNAL_MODULE_c15t__.consentTypes;
+var __webpack_exports__useConsentManager = __WEBPACK_EXTERNAL_MODULE__hooks_use_consent_manager_js_2b895421__.useConsentManager;
+var __webpack_exports__useTranslations = __WEBPACK_EXTERNAL_MODULE__store_use_translations_js_f5c44c99__.useTranslations;
+export { __webpack_exports__ConsentManagerProvider as ConsentManagerProvider, __webpack_exports__consentTypes as consentTypes, __webpack_exports__useConsentManager as useConsentManager, __webpack_exports__useTranslations as useTranslations };

package/dist/common/store/use-consent-manager.cjs

@@ -0,0 +1,47 @@
+'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__, {
+    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');
+    const storeState = context.store.getState();
+    return {
+        ...context.state,
+        ...storeState
+    };
+}
+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/common/store/use-consent-manager.d.ts

@@ -0,0 +1,136 @@
+import type { PrivacyConsentState, createConsentManagerStore } from 'c15t';
+/**
+ * A custom React hook that provides access to the privacy consent state and management methods.
+ *
+ * @remarks
+ * This hook serves as the primary interface for interacting with the consent management system.
+ * It provides access to:
+ * - Current consent states for different types (analytics, marketing, etc.)
+ * - Methods to update and save consent preferences
+ * - Compliance settings and region detection
+ * - State persistence and retrieval
+ *
+ * The hook combines both the static state and dynamic methods from the consent manager store,
+ * providing a unified API for consent management.
+ *
+ * Available methods include:
+ * - `hasConsent(type: AllConsentNames)`: Check if a specific consent type is granted
+ * - `setGdprTypes(types: AllConsentNames[])`: Update allowed GDPR consent types
+ * - `saveConsents(type: 'all' | 'custom' | 'necessary')`: Save current consent preferences
+ * - `getConsentedTypes()`: Get array of currently consented types
+ * - `setComplianceSetting(region, settings)`: Update compliance settings for a region
+ *
+ * State properties include:
+ * - `isConsentRequired`: Whether consent is required in the current region
+ * - `detectedCountry`: The detected country code for the user
+ * - `complianceSettings`: Region-specific compliance configuration
+ * - `consents`: Current state of all consent types
+ *
+ * @throws {Error}
+ * Throws if used outside of a {@link ConsentManagerProvider} context with the message
+ * "useConsentManager must be used within a ConsentManagerProvider"
+ *
+ * @returns {PrivacyConsentState & ReturnType<typeof createConsentManagerStore>["getState"]}
+ * Returns a combined object containing:
+ * - All properties from {@link PrivacyConsentState}
+ * - All methods from the consent manager store
+ *
+ * @example
+ * Basic consent checking:
+ * ```tsx
+ * function AnalyticsFeature() {
+ *   const { hasConsent, isConsentRequired } = useConsentManager();
+ *
+ *   // Check if analytics consent is required and granted
+ *   if (isConsentRequired && !hasConsent('analytics')) {
+ *     return <p>Please accept analytics cookies to use this feature.</p>;
+ *   }
+ *
+ *   return <div>Analytics Feature Content</div>;
+ * }
+ * ```
+ *
+ * @example
+ * Managing consent preferences with Do Not Track support:
+ * ```tsx
+ * function ConsentControls() {
+ *   const {
+ *     setGdprTypes,
+ *     saveConsents,
+ *     getConsentedTypes,
+ *     honorDoNotTrack
+ *   } = useConsentManager();
+ *
+ *   const handleAcceptAll = () => {
+ *     // Set all available consent types
+ *     setGdprTypes(['necessary', 'functional', 'analytics', 'marketing']);
+ *     // Save preferences with 'all' type
+ *     saveConsents('all');
+ *   };
+ *
+ *   const handleCustomize = () => {
+ *     // Get current consents and add analytics
+ *     const currentConsents = getConsentedTypes();
+ *     setGdprTypes([...currentConsents, 'analytics']);
+ *     // Save as custom preferences
+ *     saveConsents('custom');
+ *   };
+ *
+ *   // Respect Do Not Track setting
+ *   if (honorDoNotTrack && window.navigator.doNotTrack === "1") {
+ *     return <p>Respecting Do Not Track preference</p>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleAcceptAll}>Accept All</button>
+ *       <button onClick={handleCustomize}>Customize</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * Checking compliance requirements and region-specific settings:
+ * ```tsx
+ * function CookieBanner() {
+ *   const {
+ *     isConsentRequired,
+ *     detectedCountry,
+ *     complianceSettings,
+ *     setComplianceSetting
+ *   } = useConsentManager();
+ *
+ *   useEffect(() => {
+ *     // Update settings for a specific region
+ *     setComplianceSetting('EU', {
+ *       requireConsent: true,
+ *       showBanner: true,
+ *       honorDoNotTrack: true
+ *     });
+ *   }, []);
+ *
+ *   if (!isConsentRequired) return null;
+ *
+ *   const settings = complianceSettings[detectedCountry];
+ *
+ *   return (
+ *     <div>
+ *       <h2>Cookie Preferences</h2>
+ *       <p>Your current region: {detectedCountry}</p>
+ *       {settings.showBanner && (
+ *         <ConsentControls />
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @see {@link ConsentManagerProvider} For the provider component that makes this hook available
+ * @see {@link PrivacyConsentState} For the complete state interface
+ * @see {@link AllConsentNames} For available consent type names
+ *
+ * @public
+ */
+export declare function useConsentManager(): PrivacyConsentState & ReturnType<typeof createConsentManagerStore>['getState'];
+//# sourceMappingURL=use-consent-manager.d.ts.map

package/dist/common/store/use-consent-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-consent-manager.d.ts","sourceRoot":"","sources":["../../../src/common/store/use-consent-manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,yBAAyB,EAAE,MAAM,MAAM,CAAC;AAI3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoIG;AACH,wBAAgB,iBAAiB,IAAI,mBAAmB,GACvD,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,UAAU,CAAC,CAgBxD"}

package/dist/common/store/use-consent-manager.js

@@ -0,0 +1,13 @@
+'use client';
+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');
+    const storeState = context.store.getState();
+    return {
+        ...context.state,
+        ...storeState
+    };
+}
+export { useConsentManager };

package/dist/common/store/use-translations.cjs

@@ -0,0 +1,58 @@
+'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__, {
+    useTranslations: ()=>useTranslations
+});
+const external_c15t_namespaceObject = require("c15t");
+const external_react_namespaceObject = require("react");
+const external_use_consent_manager_cjs_namespaceObject = require("./use-consent-manager.cjs");
+function useTranslations() {
+    const { translationConfig } = (0, external_use_consent_manager_cjs_namespaceObject.useConsentManager)();
+    return (0, external_react_namespaceObject.useMemo)(()=>{
+        const { translations = {}, defaultLanguage = 'en' } = translationConfig;
+        const selectedTranslations = translations[defaultLanguage];
+        if (isTranslations(selectedTranslations)) return selectedTranslations;
+        const englishTranslations = translations.en;
+        if (isTranslations(englishTranslations)) return englishTranslations;
+        return external_c15t_namespaceObject.defaultTranslationConfig.translations.en;
+    }, [
+        translationConfig
+    ]);
+}
+function isTranslations(value) {
+    if (!value || 'object' != typeof value) return false;
+    const obj = value;
+    const hasRequiredKeys = 'cookieBanner' in obj && 'consentManagerDialog' in obj && 'consentManagerWidget' in obj && 'consentTypes' in obj;
+    return hasRequiredKeys;
+}
+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
+});