@c15t/react 0.0.1-rc.3

package/dist/primitives/button.d.ts

@@ -0,0 +1,207 @@
+import type { VariantProps } from 'tailwind-variants';
+import type { ConsentButtonProps } from './button.types';
+/**
+ * Button component that allows users to reject non-essential cookies.
+ *
+ * @remarks
+ * When clicked, this button saves only necessary cookie consents and closes the banner.
+ *
+ * @example
+ * ```tsx
+ * <CookieBannerRejectButton>
+ *   Reject All Cookies
+ * </CookieBannerRejectButton>
+ * ```
+ *
+ * @public
+ */
+export declare const ConsentButton: import("react").ForwardRefExoticComponent<ConsentButtonProps & VariantProps<import("tailwind-variants").TVReturnType<{
+    variant: {
+        primary: {};
+        neutral: {};
+    };
+    mode: {
+        filled: {};
+        stroke: {};
+        lighter: {};
+        ghost: {};
+    };
+    size: {
+        medium: {
+            root: string;
+        };
+        small: {
+            root: string;
+        };
+        xsmall: {
+            root: string;
+        };
+        xxsmall: {
+            root: string;
+        };
+    };
+}, {
+    root: string[];
+    icon: string[];
+}, undefined, import("tailwind-variants/dist/config").TVConfig<{
+    variant: {
+        primary: {};
+        neutral: {};
+    };
+    mode: {
+        filled: {};
+        stroke: {};
+        lighter: {};
+        ghost: {};
+    };
+    size: {
+        medium: {
+            root: string;
+        };
+        small: {
+            root: string;
+        };
+        xsmall: {
+            root: string;
+        };
+        xxsmall: {
+            root: string;
+        };
+    };
+}, {
+    variant: {
+        primary: {};
+        neutral: {};
+    };
+    mode: {
+        filled: {};
+        stroke: {};
+        lighter: {};
+        ghost: {};
+    };
+    size: {
+        medium: {
+            root: string;
+        };
+        small: {
+            root: string;
+        };
+        xsmall: {
+            root: string;
+        };
+        xxsmall: {
+            root: string;
+        };
+    };
+}>, {
+    variant: {
+        primary: {};
+        neutral: {};
+    };
+    mode: {
+        filled: {};
+        stroke: {};
+        lighter: {};
+        ghost: {};
+    };
+    size: {
+        medium: {
+            root: string;
+        };
+        small: {
+            root: string;
+        };
+        xsmall: {
+            root: string;
+        };
+        xxsmall: {
+            root: string;
+        };
+    };
+}, {
+    root: string[];
+    icon: string[];
+}, import("tailwind-variants").TVReturnType<{
+    variant: {
+        primary: {};
+        neutral: {};
+    };
+    mode: {
+        filled: {};
+        stroke: {};
+        lighter: {};
+        ghost: {};
+    };
+    size: {
+        medium: {
+            root: string;
+        };
+        small: {
+            root: string;
+        };
+        xsmall: {
+            root: string;
+        };
+        xxsmall: {
+            root: string;
+        };
+    };
+}, {
+    root: string[];
+    icon: string[];
+}, undefined, import("tailwind-variants/dist/config").TVConfig<{
+    variant: {
+        primary: {};
+        neutral: {};
+    };
+    mode: {
+        filled: {};
+        stroke: {};
+        lighter: {};
+        ghost: {};
+    };
+    size: {
+        medium: {
+            root: string;
+        };
+        small: {
+            root: string;
+        };
+        xsmall: {
+            root: string;
+        };
+        xxsmall: {
+            root: string;
+        };
+    };
+}, {
+    variant: {
+        primary: {};
+        neutral: {};
+    };
+    mode: {
+        filled: {};
+        stroke: {};
+        lighter: {};
+        ghost: {};
+    };
+    size: {
+        medium: {
+            root: string;
+        };
+        small: {
+            root: string;
+        };
+        xsmall: {
+            root: string;
+        };
+        xxsmall: {
+            root: string;
+        };
+    };
+}>, unknown, unknown, undefined>>> & {
+    action: "accept-consent" | "reject-consent" | "custom-consent" | "open-consent-dialog";
+    closeCustomizeDialog?: boolean;
+    closeCookieBanner?: boolean;
+} & import("react").RefAttributes<HTMLButtonElement>>;
+//# sourceMappingURL=button.d.ts.map

package/dist/primitives/button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"button.d.ts","sourceRoot":"","sources":["../../src/primitives/button.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,KAAK,EAAwB,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAE/E;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAKpB,gBAAgB,GAChB,gBAAgB,GAChB,gBAAgB,GAChB,qBAAqB;2BACD,OAAO;wBACV,OAAO;qDAqF7B,CAAC"}

package/dist/primitives/button.js

@@ -0,0 +1,59 @@
+import * as __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__ from "react/jsx-runtime";
+import * as __WEBPACK_EXTERNAL_MODULE__radix_ui_react_slot_85c2da36__ from "@radix-ui/react-slot";
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE__ui_components_button_js_471e9fd6__ from "../ui/components/button.js";
+import * as __WEBPACK_EXTERNAL_MODULE__theme_index_js_46d040bc__ from "../theme/index.js";
+const ConsentButton = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react__.forwardRef)(({ asChild, className: forwardedClassName, style, noStyle, action, themeKey, baseClassName, variant = 'neutral', mode = 'stroke', size = 'small', onClick: forwardedOnClick, closeCookieBanner = false, closeCustomizeDialog = false, ...props }, ref)=>{
+    const { saveConsents, setShowPopup, setIsPrivacyDialogOpen, noStyle: contextNoStyle } = (0, __WEBPACK_EXTERNAL_MODULE__theme_index_js_46d040bc__.useThemeContext)();
+    const buttonStyle = (0, __WEBPACK_EXTERNAL_MODULE__theme_index_js_46d040bc__.useStyles)(themeKey ?? 'button', {
+        baseClassName: [
+            !(contextNoStyle || noStyle) && __WEBPACK_EXTERNAL_MODULE__ui_components_button_js_471e9fd6__.buttonVariants({
+                variant,
+                mode,
+                size
+            }).root()
+        ],
+        style,
+        className: forwardedClassName,
+        noStyle: noStyle
+    });
+    const buttonClick = (0, __WEBPACK_EXTERNAL_MODULE_react__.useCallback)(()=>{
+        switch(action){
+            case 'accept-consent':
+                saveConsents('all');
+                break;
+            case 'reject-consent':
+                saveConsents('necessary');
+                break;
+            case 'custom-consent':
+                saveConsents('custom');
+                break;
+            case 'open-consent-dialog':
+                setIsPrivacyDialogOpen(true);
+                setShowPopup(false);
+                break;
+            default:
+                break;
+        }
+        if (closeCookieBanner) setShowPopup(false);
+        if (closeCustomizeDialog) setIsPrivacyDialogOpen(false);
+        if (forwardedOnClick) forwardedOnClick();
+    }, [
+        closeCookieBanner,
+        closeCustomizeDialog,
+        forwardedOnClick,
+        saveConsents,
+        setIsPrivacyDialogOpen,
+        setShowPopup,
+        action
+    ]);
+    const Comp = asChild ? __WEBPACK_EXTERNAL_MODULE__radix_ui_react_slot_85c2da36__.Slot : 'button';
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Comp, {
+        ref: ref,
+        ...buttonStyle,
+        onClick: buttonClick,
+        ...props
+    });
+});
+ConsentButton.displayName = 'ConsentButton';
+export { ConsentButton };

package/dist/primitives/button.types.cjs

@@ -0,0 +1,19 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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 __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/primitives/button.types.d.ts

@@ -0,0 +1,34 @@
+import type { ComponentRef, HTMLAttributes } from 'react';
+import type { ExtendThemeKeys, ThemeValue } from '../theme';
+import type { ButtonSharedProps } from '../ui/components/button';
+export type ConsentButtonElement = ComponentRef<'button'>;
+/**
+ * Props for CookieBanner button components.
+ *
+ * @public
+ */
+export interface ConsentButtonProps extends HTMLAttributes<HTMLButtonElement>, ExtendThemeKeys {
+    /**
+     * @remarks
+     * When true, the button will not apply any styles.
+     */
+    noStyle?: boolean;
+    /**
+     * @remarks
+     * When true, the button will render its children directly without wrapping them in a button element.
+     * This enables better composition with custom button implementations.
+     */
+    asChild?: boolean;
+    /**
+     * @remarks
+     * Allows for custom click handling.
+     */
+    onClick?: () => void;
+}
+export interface ConsentButtonStyles {
+    /** @remarks Styles for the root container element */
+    acceptButton?: ThemeValue & ButtonSharedProps;
+    rejectButton?: ThemeValue & ButtonSharedProps;
+    customizeButton?: ThemeValue & ButtonSharedProps;
+}
+//# sourceMappingURL=button.types.d.ts.map

package/dist/primitives/button.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"button.types.d.ts","sourceRoot":"","sources":["../../src/primitives/button.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,MAAM,MAAM,oBAAoB,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC;AAE1D;;;;GAIG;AACH,MAAM,WAAW,kBAChB,SAAQ,cAAc,CAAC,iBAAiB,CAAC,EACxC,eAAe;IAChB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,MAAM,WAAW,mBAAmB;IACnC,qDAAqD;IACrD,YAAY,CAAC,EAAE,UAAU,GAAG,iBAAiB,CAAC;IAC9C,YAAY,CAAC,EAAE,UAAU,GAAG,iBAAiB,CAAC;IAC9C,eAAe,CAAC,EAAE,UAAU,GAAG,iBAAiB,CAAC;CACjD"}

package/dist/theme/context.cjs

@@ -0,0 +1,44 @@
+'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__, {
+    useThemeContext: ()=>useThemeContext,
+    ThemeContext: ()=>ThemeContext
+});
+const external_react_namespaceObject = require("react");
+const ThemeContext = /*#__PURE__*/ (0, external_react_namespaceObject.createContext)(null);
+const useThemeContext = ()=>{
+    const context = (0, external_react_namespaceObject.useContext)(ThemeContext);
+    if (!context) throw new Error('Theme components must be used within Theme.Root');
+    return context;
+};
+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/theme/context.d.ts

@@ -0,0 +1,96 @@
+/**
+ * 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
+     */
+    theme?: Partial<Theme>;
+    /**
+     * Disables all animations when true
+     * @remarks Useful for reduced motion preferences
+     */
+    disableAnimation?: boolean;
+    /**
+     * Removes default styles when true
+     * @remarks Enables fully custom styling
+     */
+    noStyle?: 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 ThemeContext: import("react").Context<any>;
+/**
+ * Hook to access the current theme context.
+ *
+ * @remarks
+ * Provides type-safe access to theme values and consent management state.
+ * Throws an error if used outside of a Theme.Root component.
+ * Supports TypeScript inference for theme types.
+ *
+ * @throws {Error} When used outside of a Theme.Root component
+ *
+ * @example
+ * ```tsx
+ * const MyComponent = () => {
+ *   const { theme, noStyle, disableAnimation } = useThemeContext();
+ *
+ *   return (
+ *     <div className={theme?.myClass}>
+ *       {!disableAnimation && <AnimatedContent />}
+ *     </div>
+ *   );
+ * };
+ * ```
+ *
+ * @returns The current theme context value
+ * @public
+ */
+export declare const useThemeContext: () => any;
+//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/theme/context.tsx"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,MAAM,iBAAiB,CAAC,KAAK,GAAG,OAAO,IAAI;IAChD;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IAEvB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,YAAY,8BAElB,CAAC;AAER;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,eAAe,WAM3B,CAAC"}

package/dist/theme/context.js

@@ -0,0 +1,9 @@
+'use client';
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+const ThemeContext = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react__.createContext)(null);
+const useThemeContext = ()=>{
+    const context = (0, __WEBPACK_EXTERNAL_MODULE_react__.useContext)(ThemeContext);
+    if (!context) throw new Error('Theme components must be used within Theme.Root');
+    return context;
+};
+export { ThemeContext, useThemeContext };

package/dist/theme/index.cjs

@@ -0,0 +1,39 @@
+"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__, {
+    useStyles: ()=>external_use_style_cjs_namespaceObject.useStyles,
+    useThemeContext: ()=>external_context_cjs_namespaceObject.useThemeContext,
+    ThemeContext: ()=>external_context_cjs_namespaceObject.ThemeContext
+});
+const external_context_cjs_namespaceObject = require("./context.cjs");
+const external_use_style_cjs_namespaceObject = require("./use-style.cjs");
+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/theme/index.d.ts

@@ -0,0 +1,6 @@
+export { useThemeContext, ThemeContext } from './context';
+export type { ThemeContextValue } from './context';
+export type { AllThemeKeys } from './types/style-keys';
+export type { ClassNameStyle, ThemeValue, ExtendThemeKeys, } from './types/style-types';
+export { useStyles } from './use-style';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/theme/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC1D,YAAY,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AACnD,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,YAAY,EACX,cAAc,EACd,UAAU,EACV,eAAe,GACf,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}

package/dist/theme/index.js

@@ -0,0 +1,6 @@
+import * as __WEBPACK_EXTERNAL_MODULE__context_js_80e2871f__ from "./context.js";
+import * as __WEBPACK_EXTERNAL_MODULE__use_style_js_4cf67f88__ from "./use-style.js";
+var __webpack_exports__ThemeContext = __WEBPACK_EXTERNAL_MODULE__context_js_80e2871f__.ThemeContext;
+var __webpack_exports__useStyles = __WEBPACK_EXTERNAL_MODULE__use_style_js_4cf67f88__.useStyles;
+var __webpack_exports__useThemeContext = __WEBPACK_EXTERNAL_MODULE__context_js_80e2871f__.useThemeContext;
+export { __webpack_exports__ThemeContext as ThemeContext, __webpack_exports__useStyles as useStyles, __webpack_exports__useThemeContext as useThemeContext };

package/dist/theme/style-keys.cjs

@@ -0,0 +1,39 @@
+"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__, {
+    getNestedValue: ()=>getNestedValue
+});
+const getNestedValue = (obj, key)=>{
+    const [root, ...path] = key.split('.');
+    return path.reduce((acc, part)=>acc?.[part], obj[root]);
+};
+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/theme/style-keys.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @packageDocumentation
+ * Provides utilities for type-safe theme key management and value access.
+ * Implements nested key type generation and value retrieval for theming system.
+ */
+import type { ConsentManagerDialogTheme } from '../consent-manager-dialog/theme';
+import type { ConsentManagerWidgetTheme } from '../consent-manager-widget/theme';
+import type { CookieBannerTheme } from '../cookie-banner';
+/**
+ * Utility type that generates dot-notation string keys for nested objects.
+ *
+ * @remarks
+ * Creates union type of all possible nested paths in an object type using dot notation.
+ * Useful for type-safe theme key access in deeply nested theme objects.
+ *
+ * @typeParam T - The object type to generate nested keys for
+ *
+ * @example
+ * ```typescript
+ * type Theme = {
+ *   colors: {
+ *     primary: string;
+ *     secondary: string;
+ *   };
+ * };
+ *
+ * type Keys = NestedKeys<Theme>; // "colors.primary" | "colors.secondary"
+ * ```
+ *
+ * @public
+ */
+export type NestedKeys<T> = {
+    [P in keyof T]: T[P] extends object ? `${string & P}.${NestedKeys<T[P]>}` : string & P;
+}[keyof T];
+/**
+ * Union type of all valid style keys for the theming system.
+ *
+ * @remarks
+ * Combines consent manager and cookie banner theme keys into a single type.
+ * Ensures type safety when accessing theme values across different components.
+ *
+ * @example
+ * ```typescript
+ * const key: StyleKeys = "cookieBanner.root";
+ * const key2: StyleKeys = "consentManager.footer.accept-button";
+ * ```
+ *
+ * @public
+ */
+export type StyleKeys = `consentManager.${keyof ConsentManagerWidgetTheme}` | `consentManagerDialog.${keyof ConsentManagerDialogTheme}` | `cookieBanner.${keyof CookieBannerTheme}`;
+/**
+ * Safely retrieves a nested value from an object using a dot-notation key.
+ *
+ * @remarks
+ * Provides type-safe access to nested theme values.
+ * Handles undefined values gracefully through optional chaining.
+ *
+ * @typeParam K - The specific StyleKeys type to retrieve
+ * @param obj - The source object to retrieve the value from
+ * @param key - The dot-notation path to the desired value
+ *
+ * @example
+ * ```typescript
+ * const theme = {
+ *   cookieBanner: {
+ *     root: { backgroundColor: 'white' }
+ *   }
+ * };
+ *
+ * const value = getNestedValue(theme, 'cookieBanner.root');
+ * ```
+ *
+ * @returns The value at the specified path or undefined if not found
+ * @public
+ */
+export declare const getNestedValue: <K extends StyleKeys>(obj: Record<string, unknown>, key: K) => unknown;
+//# sourceMappingURL=style-keys.d.ts.map

package/dist/theme/style-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"style-keys.d.ts","sourceRoot":"","sources":["../../src/theme/style-keys.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;KAC1B,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAChC,GAAG,MAAM,GAAG,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GACnC,MAAM,GAAG,CAAC;CACb,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,SAAS,GAClB,kBAAkB,MAAM,yBAAyB,EAAE,GACnD,wBAAwB,MAAM,yBAAyB,EAAE,GACzD,gBAAgB,MAAM,iBAAiB,EAAE,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,SAAS,OAC5C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,OACvB,CAAC,KACJ,OAMF,CAAC"}

package/dist/theme/style-keys.js

@@ -0,0 +1,5 @@
+const getNestedValue = (obj, key)=>{
+    const [root, ...path] = key.split('.');
+    return path.reduce((acc, part)=>acc?.[part], obj[root]);
+};
+export { getNestedValue };