@c15t/react 2.2.0 → 3.0.0-alpha.0

package/dist-types/module-hooks/network-blocker.d.ts

@@ -0,0 +1,9 @@
+import type { BlockedRequestInfo, NetworkBlockerHandle, NetworkBlockerRule } from '@c15t/core/modules/network-blocker';
+export interface UseNetworkBlockerOptions {
+    rules: NetworkBlockerRule[];
+    enabled?: boolean;
+    logBlockedRequests?: boolean;
+    onRequestBlocked?: (info: BlockedRequestInfo) => void;
+}
+export declare const useNetworkBlocker: (options: UseNetworkBlockerOptions) => NetworkBlockerHandle;
+export type { BlockedRequestInfo, NetworkBlockerHandle, NetworkBlockerRule };

package/dist-types/module-hooks/persistence.d.ts

@@ -0,0 +1,4 @@
+import type { PersistenceHandle, PersistenceOptions } from '@c15t/core/modules/persistence';
+export type UsePersistenceOptions = Omit<PersistenceOptions, 'kernel'>;
+export declare const usePersistence: (options?: UsePersistenceOptions) => PersistenceHandle;
+export type { PersistenceHandle, PersistenceOptions };

package/dist-types/module-hooks/script-loader.d.ts

@@ -0,0 +1,6 @@
+import type { Script, ScriptLoaderDebugEvent, ScriptLoaderHandle } from '@c15t/core/modules/script-loader';
+export interface UseScriptLoaderOptions {
+    onDebug?: (event: ScriptLoaderDebugEvent) => void;
+}
+export declare const useScriptLoader: (scripts: Script[], options?: UseScriptLoaderOptions) => ScriptLoaderHandle;
+export type { Script, ScriptLoaderDebugEvent, ScriptLoaderHandle };

package/dist-types/module-hooks/shared.d.ts

@@ -0,0 +1,2 @@
+import type { ConsentKernel } from '@c15t/core';
+export declare const useRequiredKernel: () => ConsentKernel;

package/dist-types/module-hooks.d.ts

@@ -0,0 +1,4 @@
+export { type IframeBlockerHandle, type UseIframeBlockerOptions, useIframeBlocker, } from './module-hooks/iframe-blocker';
+export { type BlockedRequestInfo, type NetworkBlockerHandle, type NetworkBlockerRule, type UseNetworkBlockerOptions, useNetworkBlocker, } from './module-hooks/network-blocker';
+export { type PersistenceHandle, type PersistenceOptions, type UsePersistenceOptions, usePersistence, } from './module-hooks/persistence';
+export { type Script, type ScriptLoaderDebugEvent, type ScriptLoaderHandle, type UseScriptLoaderOptions, useScriptLoader, } from './module-hooks/script-loader';

package/dist-types/panel-link.d.ts

@@ -0,0 +1 @@
+export * from './components/panel-link';

package/dist-types/panel-trigger.d.ts

@@ -0,0 +1 @@
+export * from './components/panel-trigger';

package/dist-types/panel.d.ts

@@ -0,0 +1 @@
+export * from './components/panel';

package/dist-types/preferences.d.ts

@@ -0,0 +1 @@
+export * from './components/preferences';

package/dist-types/prompt.d.ts

@@ -0,0 +1 @@
+export * from './components/prompt';

package/dist-types/provider.d.ts

@@ -0,0 +1,144 @@
+import type { AllConsentNames, ConsentPresentation, Callbacks, I18nConfig, KernelConfig, KernelOverrides, KernelUser, LegalLinks, ProviderTransportFactory, StorageConfig, User } from '@c15t/core';
+import type { Script } from '@c15t/core/modules/script-loader';
+import type { ConsentRuntime } from '@c15t/core/runtime';
+import type { ReactNode } from 'react';
+import type { UseNetworkBlockerOptions, UsePersistenceOptions, UseScriptLoaderOptions } from './module-hooks';
+import type { ReactUIOptions } from './types/manager';
+import type { ReactComponentSlots } from './types/slots';
+/** Events emitted by the mounted provider without snapshot-derived consent aliases. */
+export type ConsentProviderCallbacks = Pick<Callbacks, 'onChoiceRecorded' | 'onPermissionsChanged' | 'onError'>;
+/** Prepared policy and records; legacy consent projections are not provider inputs. */
+export type ConsentProviderPrefetch = Omit<KernelConfig, 'initialDraft' | 'transport'>;
+export interface ConsentProviderOptions extends Pick<ReactUIOptions, 'colorScheme' | 'disableAnimation' | 'noStyle' | 'scrollLock' | 'theme' | 'trapFocus'> {
+    enabled?: boolean;
+    presentation?: ConsentPresentation;
+    /**
+     * Content Security Policy nonce applied to DOM nodes c15t injects.
+     *
+     * @remarks
+     * Set this when your CSP uses a nonce-based policy instead of
+     * `'unsafe-inline'`. The provider forwards it to the injected theme
+     * `<style>` element and to every `<script>` element created by the
+     * script loader. A per-script `nonce` still takes precedence.
+     */
+    nonce?: string;
+    /**
+     * Transport factory the provider builds its kernel with. Required.
+     *
+     * Pass `hosted()` to talk to a c15t backend, `offline()` to resolve
+     * policies locally with no network, or `custom()` to supply your own
+     * kernel transport. This is an initial-only
+     * option: remount the provider to change it.
+     *
+     * @example
+     * ```tsx
+     * import { ConsentProvider, hosted, offline } from '@c15t/react';
+     *
+     * <ConsentProvider options={{ mode: hosted({ url: '/api/c15t' }) }}>
+     *   {children}
+     * </ConsentProvider>
+     *
+     * <ConsentProvider options={{ mode: offline() }}>{children}</ConsentProvider>
+     * ```
+     */
+    mode: ProviderTransportFactory;
+    storageConfig?: StorageConfig;
+    user?: User | KernelUser;
+    overrides?: KernelOverrides;
+    /**
+     * Server-resolved kernel configuration, usually from a framework server
+     * helper such as `resolveConsent()`.
+     *
+     * Pass the resolved `KernelConfig` and the provider builds its kernel
+     * from it synchronously: a config carrying a policy renders the banner
+     * on first paint.
+     *
+     * Pass the pending `Promise<KernelConfig>` instead and the provider
+     * mounts at once with a provisional policy, so `children` render (and
+     * the static shell can prerender) while the consent data streams in.
+     * Consent surfaces stay hidden until the promise resolves; its first
+     * `init()` then applies the resolved config in place of the transport's
+     * network init. A config that resolves without a policy (persisted
+     * consents, geo, language only) is applied to the kernel and the
+     * transport init runs as usual; a rejected promise is logged outside
+     * production and falls through to the transport init. Initial-only:
+     * remount the provider to change it.
+     *
+     * @example
+     * ```tsx
+     * // app/layout.tsx — stays synchronous, so the shell prerenders.
+     * const config = resolveConsent({ backendURL });
+     * return (
+     *   <ConsentProvider options={{ mode: hosted({ url }), prefetch: config }}>
+     *     {children}
+     *   </ConsentProvider>
+     * );
+     * ```
+     */
+    prefetch?: ConsentProviderPrefetch | Promise<ConsentProviderPrefetch>;
+    callbacks?: ConsentProviderCallbacks;
+    scripts?: Script[];
+    scriptLoader?: UseScriptLoaderOptions;
+    networkBlocker?: UseNetworkBlockerOptions | false;
+    persistence?: boolean | UsePersistenceOptions;
+    i18n?: Partial<I18nConfig>;
+    consentCategories?: AllConsentNames[];
+    /** Per-component slot attribute overrides (shared contract with @c15t/vue). */
+    components?: ReactComponentSlots;
+    legalLinks?: LegalLinks;
+    /**
+     * Adapter package name reported by `window.c15t`.
+     * @internal
+     */
+    __debugPkg?: string;
+}
+/**
+ * Options accepted when an external runtime supplies the kernel.
+ *
+ * `mode` belongs to whoever created the runtime, so it is optional here.
+ * Everything the component tree still owns — theme, slots, legal links —
+ * is unchanged.
+ */
+export type ExternalRuntimeProviderOptions = Omit<ConsentProviderOptions, 'mode'> & {
+    mode?: ConsentProviderOptions['mode'];
+};
+/** The provider builds and owns its own kernel. */
+export interface OwnedRuntimeProviderProps {
+    options: ConsentProviderOptions;
+    children: ReactNode;
+    runtime?: undefined;
+}
+export interface ExternalRuntimeProviderProps {
+    options?: ExternalRuntimeProviderOptions;
+    children: ReactNode;
+    runtime: ConsentRuntime;
+}
+export type ConsentProviderProps = OwnedRuntimeProviderProps | ExternalRuntimeProviderProps;
+/**
+ * v3 ConsentProvider.
+ *
+ * Retains the enabled kernel while disabled mode uses a separate permissive
+ * kernel, so toggling enabled preserves recorded choices. Provides the active
+ * kernel via context and wires the curated v2-like options surface to v3
+ * modules. It does not mirror the
+ * snapshot into React state; selector hooks still subscribe directly to
+ * the kernel through `useSyncExternalStore`.
+ *
+ * Pass `runtime` to render a runtime someone else created. The provider
+ * then borrows its kernel and mounts none of the side-effecting modules —
+ * no second `init()`, no second persistence handle, no second `window.c15t`
+ * — and does not dispose it on unmount.
+ *
+ * @example
+ * ```tsx
+ * import { createConsentRuntime } from '@c15t/core/runtime';
+ *
+ * const runtime = createConsentRuntime({ mode: hosted({ url: '/api/c15t' }) });
+ * runtime.start();
+ *
+ * <ConsentProvider runtime={runtime} options={{ theme }}>
+ *   <ConsentDialog />
+ * </ConsentProvider>
+ * ```
+ */
+export declare const ConsentProvider: (props: ConsentProviderProps) => import("react").JSX.Element;

package/dist-types/server/fetch-ssr-data.d.ts

@@ -1,4 +1,4 @@
-import type { SSRInitialData } from 'c15t';
+import type { SSRInitialData } from '@c15t/core';
 import type { FetchSSRDataOptions } from './types';
 /**
  * Fetches initial consent data on the server for SSR hydration.
@@ -39,4 +39,4 @@ import type { FetchSSRDataOptions } from './types';
  *
  * @public
  */
-export declare function fetchSSRData(options: FetchSSRDataOptions): Promise<SSRInitialData | undefined>;
+export declare const fetchSSRData: (options: FetchSSRDataOptions) => Promise<SSRInitialData | undefined>;

package/dist-types/server/headers.d.ts

@@ -1,5 +1,5 @@
-declare const FORWARDED_HEADERS: readonly ["cf-ipcountry", "x-vercel-ip-country", "x-amz-cf-ipcountry", "x-country-code", "x-vercel-ip-country-region", "x-region-code", "x-c15t-version", "accept-language", "user-agent", "x-forwarded-host", "x-forwarded-for", "sec-gpc", "purpose", "sec-purpose", "next-router-prefetch", "x-middleware-prefetch"];
-type ForwardedHeader = (typeof FORWARDED_HEADERS)[number] | 'x-c15t-country' | 'x-c15t-region';
+declare const FORWARDED_HEADERS: readonly ["x-c15t-country", "cf-ipcountry", "x-vercel-ip-country", "x-amz-cf-ipcountry", "x-country-code", "x-country", "x-c15t-region", "cf-region-code", "x-vercel-ip-country-region", "x-region-code", "accept-language", "x-c15t-gpc", "sec-gpc", "x-c15t-version", "user-agent", "x-forwarded-host", "x-forwarded-for", "purpose", "sec-purpose", "next-router-prefetch", "x-middleware-prefetch"];
+type ForwardedHeader = (typeof FORWARDED_HEADERS)[number];
 type RelevantHeaders = Partial<Record<ForwardedHeader, string>>;
 /**
  * Extracts relevant headers for consent management from the request headers.
@@ -28,5 +28,5 @@ type RelevantHeaders = Partial<Record<ForwardedHeader, string>>;
  *
  * @public
  */
-export declare function extractRelevantHeaders(headersList: Headers): RelevantHeaders;
+export declare const extractRelevantHeaders: (headersList: Headers) => RelevantHeaders;
 export {};

package/dist-types/server/init-cache-key.d.ts

@@ -1,4 +1,4 @@
-import type { Overrides } from 'c15t';
+import type { Overrides } from '@c15t/core';
 /**
  * Creates a stable cache key for SSR init responses.
  *
@@ -14,8 +14,8 @@ import type { Overrides } from 'c15t';
  *
  * @public
  */
-export declare function createSSRInitCacheKey({ normalizedURL, headers, overrides, }: {
+export declare const createSSRInitCacheKey: ({ normalizedURL, headers, overrides, }: {
     normalizedURL: string;
     headers: Headers;
     overrides?: Overrides;
-}): string;
+}) => string;

package/dist-types/server/normalize-url.d.ts

@@ -16,7 +16,7 @@
  *
  * @public
  */
-export declare function validateBackendURL(backendURL: string): {
+export declare const validateBackendURL: (backendURL: string) => {
     isAbsolute: boolean;
     normalizedURL: string;
 };
@@ -48,4 +48,4 @@ export declare function validateBackendURL(backendURL: string): {
  *
  * @public
  */
-export declare function normalizeBackendURL(backendURL: string, headersList: Headers): string | null;
+export declare const normalizeBackendURL: (backendURL: string, headersList: Headers) => string | null;

package/dist-types/server/types.d.ts

@@ -1,4 +1,4 @@
-import type { Overrides, SSRInitialData } from 'c15t';
+import type { Overrides, SSRInitialData } from '@c15t/core';
 /**
  * Base options for SSR data fetching, shared across framework integrations.
  *

package/dist-types/theme-provider.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from 'react';
+import type { ThemeContextValue } from './context/theme-context';
+import type { V3UIConfigValue } from './ui-config-context';
+interface V3ThemeProviderProps {
+    themeConfig: ThemeContextValue;
+    uiConfig: V3UIConfigValue;
+    children: ReactNode;
+}
+export declare const V3ThemeProvider: ({ themeConfig, uiConfig, children, }: V3ThemeProviderProps) => import("react").JSX.Element;
+export {};

package/dist-types/transports/offline.d.ts

@@ -0,0 +1,18 @@
+import type { ProviderTransportFactory } from '@c15t/core';
+import type { PolicyRule } from '@c15t/schema/types';
+/** Policy rules evaluated locally when initialization runs. */
+export interface OfflineModeOptions {
+    /**
+     * Rules to resolve locally. Omit them to use `recommendedPolicyRules()`:
+     * strict opt-in for Europe, the UK, Quebec and unknown locations, opt-out
+     * for the US states with a privacy law, and `none` everywhere else.
+     * Passing rules replaces that pack entirely.
+     */
+    policyRules?: PolicyRule[];
+}
+/**
+ * Resolve local rules outside render and hydration.
+ * @param options - Explicit policy rules; absence resolves the recommended pack.
+ * @returns A provider transport with no network requests.
+ */
+export declare const offline: (options?: OfflineModeOptions) => ProviderTransportFactory;

package/dist-types/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './manager';
+export * from './slots';
+export * from './theme';

package/dist-types/types/manager.d.ts

@@ -0,0 +1,15 @@
+import type { UIOptions } from '@c15t/ui/theme';
+import type { ReactComponentSlots } from './slots';
+/**
+ * React-specific UI configuration options.
+ *
+ * @remarks
+ * Extends the framework-agnostic {@link UIOptions} with per-component slot
+ * overrides. `ConsentProvider` picks its theme-related options from here.
+ *
+ * @public
+ */
+export interface ReactUIOptions extends UIOptions {
+    /** Per-component slot attribute overrides (shared contract with @c15t/vue). */
+    components?: ReactComponentSlots;
+}

package/dist-types/types/slots.d.ts

@@ -0,0 +1,5 @@
+import type { ConsentComponentSlots } from '@c15t/schema/config';
+import type { HTMLAttributes } from 'react';
+/** Framework-native attribute bag bound to a themable slot. */
+export type ReactSlotProps = HTMLAttributes<HTMLElement> & Record<`data-${string}`, string | number | boolean | undefined>;
+export type ReactComponentSlots = ConsentComponentSlots<ReactSlotProps>;

package/dist-types/types/theme/index.d.ts

@@ -1,2 +1 @@
-export * from './style-keys';
 export * from './style-types';

package/dist-types/types/theme/style-types.d.ts

@@ -1,7 +1,6 @@
 import type { ClassNameStyle as BaseClassNameStyle, Theme as BaseTheme } from '@c15t/ui/theme';
 import type { CSSProperties } from 'react';
-import type { AllThemeKeys } from './style-keys';
-export type { ColorTokens, ComponentSlots, CSSVariables, MotionTokens, RadiusTokens, ShadowTokens, SlotStyle, SpacingTokens, TypographyTokens, } from '@c15t/ui/theme';
+export type { ColorTokens, CSSVariables, MotionTokens, RadiusTokens, ShadowTokens, SpacingTokens, TypographyTokens, } from '@c15t/ui/theme';
 /**
  * Represents CSS properties with optional CSS variables.
  * @public
@@ -24,10 +23,7 @@ export type ThemeValue<VariableMap = Record<string, string | number>> = string |
  * Extends styling options with a reference to a global theme key.
  * @public
  */
-export interface ExtendThemeKeys<VariableMap = Record<string, string | number>> extends ClassNameStyle<VariableMap> {
-    /** Optional key to reference a specific part of the global theme. */
-    themeKey?: AllThemeKeys;
-}
+export type ExtendThemeKeys<VariableMap = Record<string, string | number>> = ClassNameStyle<VariableMap>;
 /**
  * Complete theme configuration for c15t consent components (v2).
  * @public
@@ -35,11 +31,9 @@ export interface ExtendThemeKeys<VariableMap = Record<string, string | number>>
 export interface Theme extends Omit<BaseTheme, 'slots'> {
     /** Semantic button styling for consent actions. */
     consentActions?: BaseTheme['consentActions'];
-    /** Component-specific style overrides. */
-    slots?: BaseTheme['slots'];
 }
 /**
  * Helper function to define a theme with full TypeScript autocompletion and validation.
  * @public
  */
-export declare function defineTheme<ThemeType extends Theme>(theme: ThemeType): ThemeType;
+export declare const defineTheme: <ThemeType extends Theme>(theme: ThemeType) => ThemeType;

package/dist-types/ui-config-context.d.ts

@@ -0,0 +1,9 @@
+import type { LegalLinks, ConsentPresentation } from '@c15t/core';
+import type { ReactComponentSlots } from './types/slots';
+export interface V3UIConfigValue {
+    components?: ReactComponentSlots;
+    presentation?: ConsentPresentation;
+    legalLinks?: LegalLinks;
+}
+export declare const V3UIConfigContext: import("react").Context<V3UIConfigValue>;
+export declare const useUIConfig: () => V3UIConfigValue;

package/dist-types/ui-save.d.ts

@@ -0,0 +1,5 @@
+import type { ConsentKernel, SaveResult } from '@c15t/core';
+/** Explicit navigation supersedes a pending UI action, even to the same dialog. */
+export declare const invalidateConsentUIAction: (kernel: ConsentKernel) => void;
+/** Keep an open preferences dialog available until its own save succeeds. */
+export declare const saveConsentUI: (kernel: ConsentKernel, save: () => Promise<SaveResult>, canClose: () => boolean) => Promise<SaveResult>;

package/dist-types/utils/cn.d.ts

@@ -3,4 +3,4 @@ export type { ClassValue };
 /**
  * Utilizes framework-agnostic `cn` from @c15t/ui.
  */
-export declare function cnExt(...classes: ClassValue[]): string;
+export declare const cnExt: (...classes: ClassValue[]) => string;

package/dist-types/utils/default-translation-config.d.ts

@@ -0,0 +1,6 @@
+export declare const defaultTranslationConfig: {
+    defaultLanguage: string;
+    translations: {
+        en: import("@c15t/translations").CompleteTranslations;
+    };
+};

package/dist-types/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cn';
+export * from './default-translation-config';
+export * from './merge-styles';
+export * from './theme-utils';

package/dist-types/utils/merge-slot-props.d.ts

@@ -0,0 +1,14 @@
+import type { ConsentComponentSlotKey } from '@c15t/schema/config';
+import type { ClassValue } from '@c15t/ui/utils';
+import type { ReactComponentSlots, ReactSlotProps } from '../types/slots';
+import type { CSSPropertiesWithVars } from '../types/theme';
+type MergeSlotPropsInput = ReactSlotProps & {
+    baseClassName?: ClassValue;
+    noStyle?: boolean;
+};
+export declare const getSlotProps: (components: ReactComponentSlots | undefined, slotKey: ConsentComponentSlotKey | undefined) => ReactSlotProps | undefined;
+export type MergedSlotProps = Omit<ReactSlotProps, 'style'> & {
+    style?: CSSPropertiesWithVars;
+};
+export declare const mergeSlotProps: (slotProps: ReactSlotProps | undefined, { baseClassName, className, noStyle, style, ...ownProps }: MergeSlotPropsInput) => MergedSlotProps;
+export {};

package/dist-types/utils/merge-styles.d.ts

@@ -8,4 +8,4 @@ import type { ClassNameStyle, ThemeValue } from '../types/theme';
  *
  * @returns The merged styles object
  */
-export declare function mergeStyles(style1: ThemeValue, style2?: ThemeValue): ClassNameStyle;
+export declare const mergeStyles: (style1: ThemeValue, style2?: ThemeValue) => ClassNameStyle;

package/dist-types/utils/theme-utils.d.ts

@@ -11,8 +11,8 @@ export declare const defaultTheme: Required<Omit<Theme, 'slots'>>;
 /**
  * Maps theme tokens to CSS variables.
  */
-export declare function themeToVars(theme: Theme, isDark?: boolean): ThemeCSSVariables;
+export declare const themeToVars: (theme: Theme, isDark?: boolean) => ThemeCSSVariables;
 /**
  * Generates a CSS string for the theme variables.
  */
-export declare function generateThemeCSS(theme: Theme): string;
+export declare const generateThemeCSS: (theme: Theme) => string;

package/dist-types/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.2.0";
+export declare const version = "3.0.0-alpha.0";