@c15t/react 3.0.0-alpha.1 → 3.0.0-alpha.3

package/dist-types/components/shared/ui/button/index.d.ts

@@ -1,2 +1,2 @@
-export * from './button';
-export * from './button.types';
+export * from './button.js';
+export * from './button.types.js';

package/dist-types/components/shared/ui/collapsible/collapsible.d.ts

@@ -1,3 +1,4 @@
+import '@c15t/ui/styles/dialog';
 import type { ButtonHTMLAttributes, HTMLAttributes, ReactNode } from 'react';
 export declare const collapsibleVariants: () => {
     content: (options?: {

package/dist-types/components/shared/ui/collapsible/index.d.ts

@@ -1 +1 @@
-export * from './collapsible';
+export * from './collapsible.js';

package/dist-types/components/shared/ui/dialog/index.d.ts

@@ -1 +1 @@
-export * from './dialog';
+export * from './dialog.js';

package/dist-types/components/shared/ui/logo.d.ts

@@ -16,14 +16,4 @@ export declare const InthLogo: (props: SVGProps<SVGSVGElement> & IconProps) => i
  * INTH icon-only mark for compact placements like floating triggers.
  */
 export declare const InthIconOnly: (props: SVGProps<SVGSVGElement> & IconProps) => import("react").JSX.Element;
-/**
- * Fingerprint icon for privacy/consent contexts.
- * A generic icon representing user identity and privacy.
- */
-export declare const FingerprintIcon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & IconProps) => import("react").JSX.Element;
-/**
- * Settings/gear icon for preference contexts.
- * A generic icon representing configuration and settings.
- */
-export declare const SettingsIcon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & IconProps) => import("react").JSX.Element;
 export {};

package/dist-types/components/shared/ui/preference-item/index.d.ts

@@ -1 +1 @@
-export * from './preference-item';
+export * from './preference-item.js';

package/dist-types/components/shared/ui/preference-item/preference-item.d.ts

@@ -1,4 +1,5 @@
 import type { ConsentComponentSlotKey } from '@c15t/schema/config';
+import '@c15t/ui/styles/dialog';
 import type { HTMLAttributes, ReactNode } from 'react';
 export type PreferenceItemVariantsProps = Record<never, never>;
 export declare const preferenceItemVariants: () => {
@@ -66,6 +67,19 @@ export interface PreferenceItemTitleProps extends HTMLAttributes<HTMLHeadingElem
 }
 declare const PreferenceItemTitle: import("react").ForwardRefExoticComponent<PreferenceItemTitleProps & import("react").RefAttributes<HTMLHeadingElement>>;
 export interface PreferenceItemContentProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * Render the children while the item has never been opened.
+     *
+     * By default the content element is always rendered, so the trigger's
+     * `aria-controls` target exists, but its children mount the first time
+     * the item opens and then stay mounted, so the close transition and any
+     * state inside them survive. Collapsed content is `inert` and
+     * `aria-hidden` either way. Set this when collapsed children must be in
+     * the DOM, for example when custom CSS shows them.
+     *
+     * @defaultValue false
+     */
+    forceMount?: boolean;
     innerClassName?: string;
     innerSlotKey?: ConsentComponentSlotKey;
     noStyle?: boolean;

package/dist-types/components/shared/ui/switch/index.d.ts

@@ -1,2 +1,2 @@
-export * from './switch';
-export type { SwitchCSSVariables, SwitchRootCSSVariables, SwitchThumbCSSVariables, SwitchTrackCSSVariables, } from './switch.types';
+export * from './switch.js';
+export type { SwitchCSSVariables, SwitchRootCSSVariables, SwitchThumbCSSVariables, SwitchTrackCSSVariables, } from './switch.types.js';

package/dist-types/components/shared/ui/switch/switch.d.ts

@@ -1,5 +1,6 @@
+import '@c15t/ui/styles/dialog';
 import type { ButtonHTMLAttributes } from 'react';
-import type { ThemeValue } from '../../../../types/theme';
+import type { ThemeValue } from '../../../../types/theme/index.js';
 export type SwitchSize = 'medium' | 'small';
 export interface SwitchVariantsProps {
     size?: SwitchSize;

package/dist-types/components/shared/ui/tabs/index.d.ts

@@ -1 +1 @@
-export * from './tabs';
+export * from './tabs.js';

package/dist-types/components/shared/ui/tabs/tabs.d.ts

@@ -1,4 +1,5 @@
 import type { TabsOrientation } from '@c15t/ui/primitives/tabs';
+import '@c15t/ui/styles/dialog';
 import type { HTMLAttributes, ReactNode } from 'react';
 export interface TabsVariantsProps {
     orientation?: TabsOrientation;

package/dist-types/consent-gate.d.ts

@@ -0,0 +1 @@
+export * from './components/consent-gate/index.js';

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

@@ -0,0 +1,38 @@
+import type { Theme } from './types/theme/index.js';
+/** Props for {@link ConsentTheme}. */
+export interface ConsentThemeProps {
+    /**
+     * Theme tokens: colors, dark colors, typography, spacing, radius,
+     * shadows and motion. Defaults to the built-in theme, which the package
+     * stylesheet already contains, so omit it only to pick a `colorScheme`
+     * before hydration.
+     */
+    theme?: Theme;
+    /**
+     * Color scheme to apply before hydration. `'dark'` makes the dark
+     * tokens the default, and `'system'` follows `prefers-color-scheme`.
+     * Omit it to follow the `dark` / `c15t-dark` class on `<html>`. Pass the
+     * same value as the provider's `colorScheme` option.
+     */
+    colorScheme?: 'light' | 'dark' | 'system' | null;
+    /** Content Security Policy nonce for the `<style>` element. */
+    nonce?: string;
+}
+/**
+ * Renders the `--c15t-*` CSS variables for a theme as a `<style>` element.
+ *
+ * Render it once, next to the consent provider, where your framework renders
+ * on the server. The provider does not generate theme CSS itself.
+ *
+ * @param props - The theme, color scheme and CSP nonce.
+ * @returns A `<style id="c15t-theme">` element.
+ * @example
+ * ```tsx
+ * // app/layout.tsx (Server Component)
+ * import { ConsentTheme } from '@c15t/nextjs';
+ * import { theme } from './consent-theme';
+ *
+ * <ConsentTheme theme={theme} colorScheme="system" />
+ * ```
+ */
+export declare const ConsentTheme: ({ theme, colorScheme, nonce, }: ConsentThemeProps) => import("react").JSX.Element;

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

@@ -1,3 +1,3 @@
-export * from '../context';
-export * from './consent-tracking-context';
-export * from './theme-context';
+export * from '../context.js';
+export * from './consent-tracking-context.js';
+export * from './theme-context.js';

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

@@ -1,4 +1,4 @@
-import type { Theme } from '../types/theme';
+import type { Theme } from '../types/theme/index.js';
 /**
  * Configuration value type for the ThemeContext.
  *

package/dist-types/draft.d.ts

@@ -1,19 +1,54 @@
-import type { AllConsentNames, ConsentState, SaveResult, SaveInput } from '@c15t/core';
+import type { AllConsentNames, ConsentKernel, ConsentState, SaveResult, SaveInput } from '@c15t/core';
 import type { ReactNode } from 'react';
 /** A local, unmasked selection, committed only by an explicit save. */
 export interface ConsentDraftHandle {
     values: Readonly<ConsentState>;
     displayedCategories: readonly AllConsentNames[];
+    /**
+     * Granted flag per declared vendor. Seeded from the denials the gate
+     * honors, so a vendor declared `disabled` reads `true` whatever an older
+     * record says; every vendor not denied is `true`. Empty under an `iab`
+     * policy.
+     */
+    vendors: Readonly<Record<string, boolean>>;
     isDirty: boolean;
-    /** A material policy change requires reset and review before saving. */
+    /** A policy or displayed-category change requires reset and review before saving. */
     isStale: boolean;
     set: (category: AllConsentNames, value: boolean) => void;
     update: (patch: Partial<ConsentState>) => void;
+    /**
+     * Stage one vendor's grant. Recorded by the next save. Ignored for a
+     * vendor that is not declared or is declared `disabled`, since the kernel
+     * would drop the grant on save.
+     */
+    setVendor: (vendorId: string, granted: boolean) => void;
     acceptAll: () => void;
     rejectAll: () => void;
     save: () => Promise<SaveResult>;
     reset: () => void;
 }
+interface DraftSnapshot {
+    values: ConsentState;
+    displayedCategories: readonly AllConsentNames[];
+    vendors: Record<string, boolean>;
+    isDirty: boolean;
+    isStale: boolean;
+}
+declare const createDraftStore: (kernel: ConsentKernel, defaults?: Partial<ConsentState>) => {
+    acceptAll(): void;
+    connect(): import("@c15t/core").Unsubscribe;
+    getSnapshot: () => DraftSnapshot;
+    /** The kernel this draft reads from and saves into. */
+    kernel: ConsentKernel;
+    rejectAll(): void;
+    reset: () => void;
+    save(input?: SaveInput, categories?: readonly AllConsentNames[], onSuccess?: () => void): Promise<SaveResult>;
+    set(category: AllConsentNames, value: boolean): void;
+    setVendor(vendorId: string, granted: boolean): void;
+    subscribe(listener: () => void): () => void;
+    update: (patch: Partial<ConsentState>) => void;
+};
+type DraftStore = ReturnType<typeof createDraftStore>;
 export interface ConsentDraftProviderProps {
     children: ReactNode;
     /** Defaults apply only to categories without an explicit receipt. */
@@ -22,10 +57,64 @@ export interface ConsentDraftProviderProps {
 export declare const ConsentDraftProvider: ({ children, initial, }: ConsentDraftProviderProps) => import("react").JSX.Element;
 /** Internal UI save path shared by stock controls and headless actions. */
 export declare const useConsentSaveAction: () => (input?: SaveInput) => Promise<SaveResult>;
-/** Keep the compatibility manager selection and its save on the same draft. */
-export declare const useConsentManagerDraft: () => {
-    draft: ConsentDraftHandle;
-    save: (input?: SaveInput) => Promise<SaveResult>;
-};
+/**
+ * The nearest consent draft store, for the stock preference rows. Pair with
+ * {@link useConsentDraftSlice} so a row re-renders only when its own slice
+ * changes, not on every staged edit elsewhere in the draft.
+ *
+ * @returns The shared draft store, or a local one outside a provider.
+ * @internal
+ */
+export declare const useConsentDraftStore: () => DraftStore;
+/**
+ * Subscribes to one slice of a consent draft store.
+ *
+ * @param store - Store from {@link useConsentDraftStore}.
+ * @param selector - Picks the slice. Return a primitive or a reference the
+ * draft already holds.
+ * @returns The selected slice.
+ * @internal
+ */
+export declare const useConsentDraftSlice: <SliceType>(store: DraftStore, selector: (draft: DraftSnapshot) => SliceType) => SliceType;
 /** Read and edit displayed choices without replacing masked effective permissions. */
 export declare const useConsentDraft: () => ConsentDraftHandle;
+/** The vendor slice of the consent draft, for a custom vendor control. */
+export interface VendorDraftHandle {
+    /** Granted flag per declared vendor. See {@link ConsentDraftHandle.vendors}. */
+    vendors: Readonly<Record<string, boolean>>;
+    /** Stage one vendor's grant for the next save. See {@link ConsentDraftHandle.setVendor}. */
+    setVendor: (vendorId: string, granted: boolean) => void;
+    /** Whether any draft value, category or vendor, differs from the record. */
+    isDirty: boolean;
+    /**
+     * Whether the policy or the vendor surface changed under an unsaved edit.
+     * `save` refuses a stale draft. See {@link ConsentDraftHandle.isStale}.
+     */
+    isStale: boolean;
+    /** Confirm the draft, categories and vendors together. */
+    save: () => Promise<SaveResult>;
+    /** Discard staged edits and reseed from the record. See {@link ConsentDraftHandle.reset}. */
+    reset: () => void;
+}
+/**
+ * Read and stage vendor grants on the same draft the category switches use.
+ * A custom vendor toggle needs only this; the categories stay where the
+ * stock widget or `useConsentDraft()` left them, and one save confirms both.
+ * When the policy or the vendor list changes under a staged edit the draft
+ * turns stale and `save` refuses it; `reset` reseeds it from the record.
+ *
+ * @returns The draft's vendor map, the setter, the dirty and stale flags,
+ * the save and the reset.
+ * @example
+ * ```tsx
+ * const { vendors, setVendor, isStale, reset, save } = useVendorDraft();
+ * <Switch
+ *   checked={vendors['meta-pixel'] ?? true}
+ *   onCheckedChange={(on) => setVendor('meta-pixel', on)}
+ * />;
+ * {isStale && <button onClick={reset}>Review again</button>}
+ * ```
+ * @public
+ */
+export declare const useVendorDraft: () => VendorDraftHandle;
+export {};

package/dist-types/headless.d.ts

@@ -5,10 +5,9 @@
  * Pair with `ConsentProvider` from `@c15t/react` (or `@c15t/react/provider`).
  */
 export { defaultTranslationConfig, detectBrowserLanguage, mergeTranslationConfigs, prepareTranslationConfig, } from '@c15t/core';
-export { type ConsentDialogTriggerVisibility, type UseConsentDialogTriggerOptions, type UseConsentDialogTriggerResult, useConsentDialogTrigger, } from './component-hooks/use-panel-trigger';
-export { useConsentManager } from './component-hooks/use-manager';
-export { type HeadlessConsentBannerAction, type HeadlessConsentBannerState, type HeadlessConsentDialogAction, type HeadlessConsentDialogState, type HeadlessConsentSurface, type HeadlessConsentSurfaceAction, type HeadlessConsentSurfaceState, type HeadlessConsentWriteAction, useHeadlessConsentUI, } from './component-hooks/use-headless-consent-ui';
-export { useTranslations } from './component-hooks/use-translations';
-export { useColorScheme } from './hooks/use-color-scheme';
-export { useFocusTrap } from './hooks/use-focus-trap';
-export type { ReactUIOptions } from './types/manager';
+export { type ConsentDialogTriggerVisibility, type UseConsentDialogTriggerOptions, type UseConsentDialogTriggerResult, useConsentDialogTrigger, } from './component-hooks/use-panel-trigger.js';
+export { type HeadlessConsentBannerAction, type HeadlessConsentBannerState, type HeadlessConsentDialogAction, type HeadlessConsentDialogState, type HeadlessConsentSurface, type HeadlessConsentSurfaceAction, type HeadlessConsentSurfaceState, type HeadlessConsentWriteAction, useHeadlessConsentUI, } from './component-hooks/use-headless-consent-ui.js';
+export { useTranslations } from './component-hooks/use-translations.js';
+export { useColorScheme } from './hooks/use-color-scheme.js';
+export { useFocusTrap } from './hooks/use-focus-trap.js';
+export type { ReactUIOptions } from './types/manager.js';

package/dist-types/hooks/use-committed-ref.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A ref that holds `value` from the render React most recently committed.
+ *
+ * Consent guards use it to answer "is this still the kernel, draft or IAB
+ * selection this component renders?" when a kept callback runs, including
+ * from a descendant's layout effect in the very commit that switched
+ * runtimes.
+ *
+ * Why an insertion effect: React runs insertion effects while it applies a
+ * commit, before any layout effect of that commit, and never for a render it
+ * discards. Assigning the ref during render would publish values from
+ * renders React throws away (an interrupted concurrent render, StrictMode's
+ * second render). A layout effect is too late, because descendants' layout
+ * effects run before their ancestors'. A passive effect is later still.
+ * Assigning the committed value is idempotent, so StrictMode's replayed
+ * effects cannot leave a stale value behind.
+ *
+ * @param value - The value this render uses.
+ * @returns A ref whose `current` is the last committed `value`.
+ * @internal
+ */
+export declare const useCommittedRef: <Value>(value: Value) => {
+    readonly current: Value;
+};

package/dist-types/hooks/use-headless-iab-consent-ui.d.ts

@@ -1,5 +1,5 @@
 import type { HeadlessIABBannerAction, HeadlessIABDialogAction, HeadlessIABPreferenceTab } from '@c15t/iab/headless';
-import { useIABConsentManager } from './use-iab-manager';
+import { useIABConsentManager } from './use-iab-manager.js';
 export type { HeadlessIABBannerAction, HeadlessIABDialogAction, HeadlessIABPreferenceTab, };
 export interface HeadlessIABBannerState {
     isVisible: boolean;

package/dist-types/hooks/use-iab-manager.d.ts

@@ -1,7 +1,7 @@
 import type { ActiveUI, ConsentPresentation, TranslationConfig } from '@c15t/core';
 export declare const useIABConsentManager: (overrides?: ConsentPresentation) => {
     activeUI: ActiveUI;
-    iab: import("../iab-context").ReactIABState | null;
+    iab: import("../iab-context.js").ReactIABState | null;
     model: import("@c15t/core").KernelModel | null;
     policyBanner: {
         allowedActions: import("@c15t/core").PresentationAction[];

package/dist-types/hooks/use-theme.d.ts

@@ -1,2 +1,2 @@
-import type { ThemeContextValue } from '../context/theme-context';
+import type { ThemeContextValue } from '../context/theme-context.js';
 export declare const useTheme: () => ThemeContextValue;

package/dist-types/hooks.d.ts

@@ -17,7 +17,7 @@
  * observed through the selector hooks, whose subscription model handles
  * invalidation correctly.
  */
-import type { AllConsentNames, ConsentKernel, PromptPresentation, PreferencesPresentation, ConsentSnapshot, ConsentState, KernelActiveUI, KernelBranding, KernelIABState, KernelModel, KernelOverrides, KernelTranslations, KernelUser, LocationResponse, PolicyScopeMode } from '@c15t/core';
+import type { AllConsentNames, ConsentKernel, PromptPresentation, PreferencesPresentation, ConsentSnapshot, ConsentState, KernelActiveUI, KernelBranding, KernelIABState, KernelModel, KernelOverrides, KernelTranslations, KernelUser, LocationResponse, PolicyScopeMode, ResolvedVendor, VendorChoice } from '@c15t/core';
 /**
  * Full snapshot accessor. Escape hatch for consumers that genuinely need
  * multiple slices. Prefer narrow hooks for re-render isolation.
@@ -65,6 +65,8 @@ export declare const useHasConsentPolicy: () => boolean;
  * {@link useHasConsentPolicy}.
  */
 export declare const useHasConsentUI: () => boolean;
+/** Whether c15t or an external CMP offers a preferences control. */
+export declare const useHasConsentPreferences: () => boolean;
 /**
  * Derived consent model (opt-in / opt-out / iab), or `null` while no policy
  * rule is resolved. The kernel keeps a safe fallback rule internally; this
@@ -91,6 +93,33 @@ export declare const usePurposeConsent: (purposeId: number) => boolean;
 export declare const useSpecialFeatureOptIn: (featureId: number) => boolean;
 /** Latest TCF string. `null` until the IAB module encodes one. */
 export declare const useTCString: () => string | null;
+/**
+ * Vendors declared for vendor-level consent outside IAB, merged from the
+ * provider's `vendors` option, the backend and script slugs. Empty under an
+ * `iab` policy, where the TC string decides and vendor rows are not shown.
+ */
+export declare const useDeclaredVendors: () => readonly ResolvedVendor[];
+/**
+ * The visitor's recorded vendor decision.
+ *
+ * @returns The decision, whose `denied` list may be empty after a bulk
+ * action lifted every denial, or `null` when no vendor decision was ever
+ * recorded.
+ */
+export declare const useVendorChoice: () => Readonly<VendorChoice> | null;
+/**
+ * Whether one vendor is allowed: its category condition passes and the
+ * visitor has not turned it off.
+ *
+ * @param vendorId - Vendor slug as declared in `vendors` or on a script.
+ * @returns `false` while the vendor is denied outside `iab`, otherwise the
+ * result of its declared category condition. An undeclared id is `true`:
+ * nothing is known about its category, and a denial only exists for a vendor
+ * the visitor saw.
+ */
+export declare const useVendorAllowed: (vendorId: string) => boolean;
+/** Register categories used by scripts, frames, or other integrations. */
+export declare const useRegisterConsentCategories: () => (categories: readonly AllConsentNames[]) => void;
 /**
  * Sync mutation: apply overrides (country, region, language, GPC).
  */

package/dist-types/iab.d.ts

@@ -23,8 +23,8 @@
  *
  * @packageDocumentation
  */
-export { IABConsentBanner, type IABConsentBannerProps, } from './components/iab-prompt';
-export { IABConsentDialog, type IABConsentDialogProps, } from './components/iab-panel';
-export { type HeadlessIABBannerAction, type HeadlessIABBannerState, type HeadlessIABDialogAction, type HeadlessIABDialogState, type HeadlessIABPreferenceTab, type UseHeadlessIABConsentUIResult, useHeadlessIABConsentUI, } from './hooks/use-headless-iab-consent-ui';
-export { IABProvider } from './iab-context';
-export type { IABProviderProps } from './iab-context';
+export { IABConsentBanner, type IABConsentBannerProps, } from './components/iab-prompt/index.js';
+export { IABConsentDialog, type IABConsentDialogProps, } from './components/iab-panel/index.js';
+export { type HeadlessIABBannerAction, type HeadlessIABBannerState, type HeadlessIABDialogAction, type HeadlessIABDialogState, type HeadlessIABPreferenceTab, type UseHeadlessIABConsentUIResult, useHeadlessIABConsentUI, } from './hooks/use-headless-iab-consent-ui.js';
+export { IABProvider } from './iab-context.js';
+export type { IABProviderProps } from './iab-context.js';

package/dist-types/index.d.ts

@@ -33,29 +33,30 @@
  */
 export type { ConsentKernel, ConsentSnapshot, ConsentState, HostedTransportOptions, InitContext, InitResponse, InitResult, KernelConfig, KernelEvent, KernelOverrides, KernelTransport, KernelUser, Listener, HostedModeOptions, ProviderTransportContext, ProviderTransportFactory, ProviderTransportKind, SavePayload, SaveResult, Unsubscribe, } from '@c15t/core';
 export { createConsentKernel, custom, hosted } from '@c15t/core';
-export type { OfflineModeOptions } from './transports/offline';
-export { offline } from './transports/offline';
-export { ConsentDialog, ConsentWidget } from './aggregate-components';
-export type { ConsentBannerButton, ConsentBannerLayout, ConsentBannerProps, ConsentBannerRight, ConsentBannerRightLinkProps, ConsentBannerRightsProps, ConsentBannerSurface, } from './components/prompt';
-export { ConsentBanner, type ConsentBannerCompoundComponent, useConsentBannerSurface, } from './components/prompt';
-export type { ConsentDialogCompoundComponent, ConsentDialogProps, } from './components/panel';
-export type { ConsentDialogLinkProps } from './components/panel-link';
-export { ConsentDialogLink } from './components/panel-link';
-export type { ConsentDialogTriggerProps, ConsentDialogTriggerToolbarAction, ConsentDialogTriggerToolbarPreferences, ConsentDialogTriggerToolbarProps, TriggerOrientation, } from './components/panel-trigger';
-export { ConsentDialogTrigger, ConsentDialogTriggerToolbar, } from './components/panel-trigger';
-export type { ConsentWidgetCompoundComponent, ConsentWidgetProps, } from './components/preferences';
-export type { FrameProps } from './components/frame';
-export { Frame } from './components/frame';
-export type { ConsentDraftHandle, ConsentDraftProviderProps } from './draft';
-export { ConsentDraftProvider, useConsentDraft } from './draft';
-export { useConsentManager } from './component-hooks/use-manager';
-export { useTranslations } from './component-hooks/use-translations';
-export { useActiveUI, useBranding, useConsent, useConsents, useHasConsentPolicy, useHasConsentUI, useIABEnabled, useIABSnapshot, useIdentify, useInit, useLocation, useModel, useOverrides, usePromptPresentation, usePolicyCategories, usePreferencesPresentation, usePolicyScopeMode, usePurposeConsent, useSaveConsents, useSetActiveUI, useSetLanguage, useSetOverrides, useSnapshot, useSpecialFeatureOptIn, useTCString, useUser, useVendorConsent, } from './hooks';
-export type { UseIframeBlockerOptions, UseNetworkBlockerOptions, UsePersistenceOptions, UseScriptLoaderOptions, } from './module-hooks';
-export { useIframeBlocker, useNetworkBlocker, usePersistence, useScriptLoader, } from './module-hooks';
-export type { ConsentProviderOptions, ConsentProviderCallbacks, ConsentProviderPrefetch, ConsentProviderProps, ExternalRuntimeProviderOptions, ExternalRuntimeProviderProps, OwnedRuntimeProviderProps, } from './provider';
-export { ConsentProvider } from './provider';
-export type { ReactUIOptions } from './types/manager';
-export { defineTheme, type Theme } from './types/theme';
-export { useExplicitChoice, useEffectivePermissions, usePromptRequirement, useNoticeDismissal, usePrivacySignals, useOptOutDirectives, usePolicyResolution, usePolicyRule, useRestrictions, useDismissNotice, } from './hooks';
+export type { OfflineModeOptions } from './transports/offline.js';
+export { offline } from './transports/offline.js';
+export { ConsentDialog, ConsentWidget } from './aggregate-components.js';
+export type { ConsentBannerButton, ConsentBannerLayout, ConsentBannerProps, ConsentBannerRight, ConsentBannerRightLinkProps, ConsentBannerRightsProps, ConsentBannerSurface, } from './components/prompt/index.js';
+export { ConsentBanner, type ConsentBannerCompoundComponent, useConsentBannerSurface, } from './components/prompt/index.js';
+export type { ConsentDialogCompoundComponent, ConsentDialogProps, } from './components/panel/index.js';
+export type { ConsentDialogLinkProps } from './components/panel-link/index.js';
+export { ConsentDialogLink } from './components/panel-link/index.js';
+export type { ConsentDialogTriggerProps, ConsentDialogTriggerToolbarAction, ConsentDialogTriggerToolbarPreferences, ConsentDialogTriggerToolbarProps, TriggerOrientation, } from './components/panel-trigger/index.js';
+export { ConsentDialogTrigger, ConsentDialogTriggerToolbar, } from './components/panel-trigger/index.js';
+export type { ConsentWidgetCompoundComponent, ConsentWidgetProps, } from './components/preferences/index.js';
+export type { ConsentGateProps, FrameProps } from './components/consent-gate/index.js';
+export { ConsentGate, Frame } from './components/consent-gate/index.js';
+export type { ConsentDraftHandle, ConsentDraftProviderProps, VendorDraftHandle, } from './draft.js';
+export { ConsentDraftProvider, useConsentDraft, useVendorDraft } from './draft.js';
+export { useTranslations } from './component-hooks/use-translations.js';
+export { useActiveUI, useBranding, useConsent, useConsents, useHasConsentPolicy, useHasConsentPreferences, useHasConsentUI, useIABEnabled, useIABSnapshot, useIdentify, useInit, useLocation, useModel, useOverrides, usePromptPresentation, usePolicyCategories, usePreferencesPresentation, usePolicyScopeMode, usePurposeConsent, useRegisterConsentCategories, useSaveConsents, useSetActiveUI, useSetLanguage, useSetOverrides, useSnapshot, useSpecialFeatureOptIn, useSubscribeToConsentChanges, useTCString, useUser, useDeclaredVendors, useVendorAllowed, useVendorChoice, useVendorConsent, } from './hooks.js';
+export type { UseIframeBlockerOptions, UseNetworkBlockerOptions, UsePersistenceOptions, UseScriptLoaderOptions, } from './module-hooks.js';
+export { useIframeBlocker, useNetworkBlocker, usePersistence, useScriptLoader, } from './module-hooks.js';
+export type { ConsentProviderOptions, ConsentProviderCallbacks, ConsentProviderPrefetch, ConsentProviderProps, ExternalRuntimeProviderOptions, ExternalRuntimeProviderProps, OwnedRuntimeProviderProps, } from './provider.js';
+export { ConsentProvider } from './provider.js';
+export { ConsentTheme } from './consent-theme.js';
+export type { ConsentThemeProps } from './consent-theme.js';
+export type { ReactUIOptions } from './types/manager.js';
+export { defineTheme, type Theme } from './types/theme/index.js';
+export { useExplicitChoice, useEffectivePermissions, usePromptRequirement, useNoticeDismissal, usePrivacySignals, useOptOutDirectives, usePolicyResolution, usePolicyRule, useRestrictions, useDismissNotice, } from './hooks.js';
 export type { ConsentPresentation, PromptPresentation, PreferencesPresentation, PresentationAction, PromptPosition, PromptVariant, ResolvedConsentPresentation, } from '@c15t/core';

package/dist-types/kernel-selector.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Kernel access for the hooks and the stock components. The component
+ * selectors below each read a single derived value, so a component
+ * re-renders only when that value changes. Not exported from any package
+ * entry.
+ *
+ * @packageDocumentation
+ * @internal
+ */
+import type { AllConsentNames, ConsentKernel, ConsentSnapshot } from '@c15t/core';
+/**
+ * Reads the kernel from the nearest provider.
+ *
+ * @returns The provider's kernel.
+ * @throws {Error} When called outside a `ConsentProvider`.
+ * @internal
+ */
+export declare const useKernel: () => ConsentKernel;
+/**
+ * Subscribes to one slice of the kernel snapshot. React re-renders the
+ * caller only when the selected value `Object.is`-differs, so a selector
+ * must return a primitive or a reference the snapshot already holds.
+ *
+ * @param selector - Picks the slice from a snapshot.
+ * @returns The selected slice.
+ * @internal
+ */
+export declare const useKernelSelector: <SliceType>(selector: (snap: ConsentSnapshot) => SliceType) => SliceType;
+/**
+ * Like `useKernelSelector`, for selectors that evaluate a gate at a point in
+ * time. The server render and hydration evaluate at the snapshot's own
+ * `evaluatedAt`, so they never read the clock: a Next.js `cacheComponents`
+ * prerender rejects `Date.now()` in a Client Component. In the browser the
+ * gate is evaluated at `Date.now()`, so an expiry the kernel's deadline
+ * timer has not processed yet still denies.
+ *
+ * @param selector - Picks the slice from a snapshot at the given time.
+ * @returns The selected slice.
+ * @internal
+ */
+export declare const useGateSelector: <SliceType>(selector: (snap: ConsentSnapshot, now: number) => SliceType) => SliceType;
+/**
+ * Whether content gated on one category may render, with the kernel's gate
+ * semantics. Server rendering and hydration read no clock; see
+ * `useGateSelector`.
+ *
+ * @param category - Category the content needs.
+ * @returns `true` while the category is permitted.
+ * @internal
+ */
+export declare const useCategoryAllowed: (category: AllConsentNames) => boolean;
+/**
+ * Language of the active translation bundle.
+ *
+ * @returns The bundle's language, or the default language before one loads.
+ * @internal
+ */
+export declare const useTranslationLanguage: () => string;
+/**
+ * Categories the preference surface lists: `necessary` plus the recorded
+ * choice scope, or the policy scope when no choice scope applies.
+ *
+ * @returns A list whose identity changes only when the scope does.
+ * @internal
+ */
+export declare const useDisplayedCategories: () => readonly AllConsentNames[];

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

@@ -1,6 +1,33 @@
+import type { ConsentKernel } from '@c15t/core';
 import type { IframeBlockerHandle } from '@c15t/core/modules/iframe-blocker';
 export interface UseIframeBlockerOptions {
     disableAutomaticBlocking?: boolean;
 }
 export declare const useIframeBlocker: (options?: UseIframeBlockerOptions) => IframeBlockerHandle;
+/**
+ * Call `onFound` when a gated iframe is on the page: at once when one is
+ * there already, and again for each batch of gated frames that arrives.
+ *
+ * Until the returned stop function runs, a gated frame that arrives with a
+ * `src` the snapshot does not clearly allow is paused (`src` moved to
+ * `data-src`), as the loaded blocker would pause it. Frames on the page at
+ * the first call are left to the blocker, which is what happens when it
+ * loads with the provider.
+ *
+ * @param kernel - The kernel whose snapshot decides what is clearly allowed.
+ * @param onFound - Called for every sighting; the caller dedupes.
+ * @returns Stops watching.
+ * @internal
+ */
+export declare const watchGatedIframes: (kernel: ConsentKernel, onFound: () => void) => () => void;
+/**
+ * The provider's default iframe blocker. Loads the blocker module when the
+ * first gated iframe (`data-category` or `data-vendor`) is on the page
+ * instead of on every mount, so pages without one never download it.
+ *
+ * @param options - Blocker options. With `disableAutomaticBlocking` the
+ * module loads at once, as it did before.
+ * @internal
+ */
+export declare const useIframeBlockerOnDemand: (options?: UseIframeBlockerOptions) => void;
 export type { IframeBlockerHandle };

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

@@ -5,5 +5,28 @@ export interface UseNetworkBlockerOptions {
     logBlockedRequests?: boolean;
     onRequestBlocked?: (info: BlockedRequestInfo) => void;
 }
+/**
+ * Block `fetch` and XHR requests that match `rules` until the visitor's
+ * consent allows them.
+ *
+ * Blocking starts during the first render in the browser: matching requests
+ * wait from then on, including ones sent from this component's children's
+ * mount effects and from effects that run before this component's. The
+ * blocker loads after mount and decides each waiting request. On the
+ * server the hook does nothing.
+ *
+ * Rendering has a side effect: the first render patches `fetch` and
+ * `XMLHttpRequest` to hold matching requests. If React discards that
+ * render and never commits it, the hold ends after 10 seconds. Nothing
+ * checked consent for the requests it held, so they fail as blocked: a 451
+ * response for `fetch`, a failed XHR.
+ *
+ * Prefer the provider's `networkBlocker` option. It starts blocking when
+ * the provider renders, so it also covers components rendered before this
+ * one.
+ *
+ * @param options - Rules and logging options.
+ * @returns A handle to update rules or toggle blocking.
+ */
 export declare const useNetworkBlocker: (options: UseNetworkBlockerOptions) => NetworkBlockerHandle;
 export type { BlockedRequestInfo, NetworkBlockerHandle, NetworkBlockerRule };