@pinfold/react 0.0.0-stage → 0.2.0

package/dist/client.d.cts

@@ -0,0 +1,120 @@
+import * as React from 'react';
+import { PinfoldTheme, PinfoldRadius, PinfoldDir, PinfoldSize, PinfoldTone, PinfoldStylePack, PinfoldLazy, PropsBag } from '@pinfold/core';
+import { d as AccordionOptions, S as SlotOverrides } from './types-CkcgnWwL.cjs';
+export { P as PinfoldComponent, e as SlotRenderer, f as Slottable, u as usePinfoldComponent } from './types-CkcgnWwL.cjs';
+
+/** Per-component defaults. Data, state and ids never belong here, only how components look and behave. */
+interface PinfoldComponentDefaults {
+    accordion?: Omit<AccordionOptions, 'value' | 'defaultValue' | 'disabledIds' | 'id'>;
+}
+/**
+ * The global config, usually in `pinfold.config.ts` (or `.js`):
+ *
+ *   export default defineConfig({ theme: 'system', radius: 'lg', defaults: { accordion: { variant: 'separated' } } });
+ *
+ * and handed to the provider once: `<PinfoldProvider config={config}>`.
+ * Precedence, highest first: component config, `defaults.<component>`, this
+ * global theme, the library defaults. A nested provider overrides its section.
+ */
+interface PinfoldConfig {
+    theme?: PinfoldTheme;
+    radius?: PinfoldRadius;
+    dir?: PinfoldDir;
+    size?: PinfoldSize;
+    tone?: PinfoldTone;
+    /** Visual style pack (needs `@pinfold/css/packs.css`). Default `'default'`. */
+    stylePack?: PinfoldStylePack;
+    /** Default code-loading strategy for `/lazy` entries. Default `'auto'`. */
+    lazy?: PinfoldLazy;
+    /** Disable every component transition, e.g. in tests or on low-power devices. */
+    disableAnimation?: boolean;
+    defaults?: PinfoldComponentDefaults;
+}
+
+interface PinfoldContextValue {
+    theme: PinfoldTheme;
+    radius: PinfoldRadius;
+    dir: PinfoldDir;
+    size: PinfoldSize;
+    tone: PinfoldTone;
+    stylePack: PinfoldStylePack;
+    lazy: PinfoldLazy;
+    /** Disable every component transition, e.g. in tests or on low-power devices. */
+    disableAnimation: boolean;
+    defaults: PinfoldComponentDefaults;
+}
+/** Component-level defaults. Every component calls this; the provider is optional. */
+declare function usePinfold(): PinfoldContextValue;
+interface PinfoldProviderProps extends PinfoldConfig {
+    children?: React.ReactNode;
+    /** A whole config from `defineConfig()`. Individual props override it. */
+    config?: PinfoldConfig;
+    /**
+     * Write `data-pinfold-theme` / `data-pinfold-radius` / `data-pinfold-style`
+     * onto `<html>` instead of a wrapper element. Use this when portals
+     * (dialogs, tooltips) must inherit the theme. Default: false.
+     */
+    applyToDocument?: boolean;
+    className?: string;
+}
+declare function PinfoldProvider(props: PinfoldProviderProps): React.ReactElement;
+
+/** SSR-safe layout effect. */
+declare const useIsomorphicLayoutEffect: typeof React.useLayoutEffect;
+/**
+ * Stable, SSR-safe id (React 18+ `useId`). The characters React wraps ids in
+ * (`:` in 18, `«»` in 19) are stripped so the id is also a valid CSS selector.
+ */
+declare function useId(provided?: string): string;
+/**
+ * A callback whose identity never changes but which always sees fresh props.
+ * Lets us hand stable handlers to consumers without re-render churn.
+ */
+declare function useEvent<T extends (...args: any[]) => any>(fn: T): T;
+interface ControllableStateOptions<T> {
+    value?: T;
+    defaultValue: T | (() => T);
+    onChange?: (value: T) => void;
+}
+/** One state hook that is controlled, uncontrolled, or both. */
+declare function useControllableState<T>({ value, defaultValue, onChange, }: ControllableStateOptions<T>): [T, (next: T | ((prev: T) => T)) => void];
+
+/**
+ * Fold a slot's `classNames`, `styles` and `slotProps` overrides into the
+ * behaviour props a component generated. Handlers chain, classes concatenate,
+ * styles merge.
+ */
+declare function slotProps<Slot extends string, State>(overrides: SlotOverrides<Slot, State> | undefined, slot: Slot, base: PropsBag): PropsBag;
+/**
+ * Render a slot, letting the consumer swap the element while keeping every
+ * accessibility prop. `defaultRender` is used when no override exists.
+ */
+declare function renderSlot<Slot extends string, State>(overrides: SlotOverrides<Slot, State> | undefined, slot: Slot, props: PropsBag, state: State, children: React.ReactNode, defaultRender: (props: PropsBag, children: React.ReactNode) => React.ReactNode): React.ReactNode;
+
+interface LazyOptions {
+    /** Rendered while the chunk downloads, and in the placeholder. Default: nothing. */
+    fallback?: React.ReactNode;
+    /** Name shown in React DevTools. */
+    displayName?: string;
+    /** What `lazy: 'auto'` means for this component: `eager` when light, `visible` when heavy. Default `eager`. */
+    auto?: Exclude<PinfoldLazy, 'auto'>;
+}
+/**
+ * Wrap a dynamic import into a drop-in component with its own Suspense
+ * boundary, so consumers get code-splitting without touching their tree:
+ *
+ *   const Accordion = createLazyComponent(() => import('@pinfold/react/accordion'));
+ *   <Accordion items={items} lazy="visible" />
+ *
+ * `lazy` (prop, else the provider): `eager` loads at once, `visible` when the
+ * placeholder nears the viewport, `idle` when the browser is idle. Lazy entries
+ * render on the client; for complete server HTML use the main entry.
+ */
+declare function createLazyComponent<P extends object>(loader: () => Promise<{
+    default: React.ComponentType<P>;
+}>, options?: LazyOptions): React.ComponentType<P & {
+    lazy?: PinfoldLazy;
+}>;
+
+export { PinfoldProvider, SlotOverrides, createLazyComponent, renderSlot, slotProps, useControllableState, useEvent, useId, useIsomorphicLayoutEffect, usePinfold };
+export type { ControllableStateOptions, LazyOptions, PinfoldContextValue, PinfoldProviderProps };

package/dist/client.d.ts

@@ -0,0 +1,120 @@
+import * as React from 'react';
+import { PinfoldTheme, PinfoldRadius, PinfoldDir, PinfoldSize, PinfoldTone, PinfoldStylePack, PinfoldLazy, PropsBag } from '@pinfold/core';
+import { d as AccordionOptions, S as SlotOverrides } from './types-CkcgnWwL.js';
+export { P as PinfoldComponent, e as SlotRenderer, f as Slottable, u as usePinfoldComponent } from './types-CkcgnWwL.js';
+
+/** Per-component defaults. Data, state and ids never belong here, only how components look and behave. */
+interface PinfoldComponentDefaults {
+    accordion?: Omit<AccordionOptions, 'value' | 'defaultValue' | 'disabledIds' | 'id'>;
+}
+/**
+ * The global config, usually in `pinfold.config.ts` (or `.js`):
+ *
+ *   export default defineConfig({ theme: 'system', radius: 'lg', defaults: { accordion: { variant: 'separated' } } });
+ *
+ * and handed to the provider once: `<PinfoldProvider config={config}>`.
+ * Precedence, highest first: component config, `defaults.<component>`, this
+ * global theme, the library defaults. A nested provider overrides its section.
+ */
+interface PinfoldConfig {
+    theme?: PinfoldTheme;
+    radius?: PinfoldRadius;
+    dir?: PinfoldDir;
+    size?: PinfoldSize;
+    tone?: PinfoldTone;
+    /** Visual style pack (needs `@pinfold/css/packs.css`). Default `'default'`. */
+    stylePack?: PinfoldStylePack;
+    /** Default code-loading strategy for `/lazy` entries. Default `'auto'`. */
+    lazy?: PinfoldLazy;
+    /** Disable every component transition, e.g. in tests or on low-power devices. */
+    disableAnimation?: boolean;
+    defaults?: PinfoldComponentDefaults;
+}
+
+interface PinfoldContextValue {
+    theme: PinfoldTheme;
+    radius: PinfoldRadius;
+    dir: PinfoldDir;
+    size: PinfoldSize;
+    tone: PinfoldTone;
+    stylePack: PinfoldStylePack;
+    lazy: PinfoldLazy;
+    /** Disable every component transition, e.g. in tests or on low-power devices. */
+    disableAnimation: boolean;
+    defaults: PinfoldComponentDefaults;
+}
+/** Component-level defaults. Every component calls this; the provider is optional. */
+declare function usePinfold(): PinfoldContextValue;
+interface PinfoldProviderProps extends PinfoldConfig {
+    children?: React.ReactNode;
+    /** A whole config from `defineConfig()`. Individual props override it. */
+    config?: PinfoldConfig;
+    /**
+     * Write `data-pinfold-theme` / `data-pinfold-radius` / `data-pinfold-style`
+     * onto `<html>` instead of a wrapper element. Use this when portals
+     * (dialogs, tooltips) must inherit the theme. Default: false.
+     */
+    applyToDocument?: boolean;
+    className?: string;
+}
+declare function PinfoldProvider(props: PinfoldProviderProps): React.ReactElement;
+
+/** SSR-safe layout effect. */
+declare const useIsomorphicLayoutEffect: typeof React.useLayoutEffect;
+/**
+ * Stable, SSR-safe id (React 18+ `useId`). The characters React wraps ids in
+ * (`:` in 18, `«»` in 19) are stripped so the id is also a valid CSS selector.
+ */
+declare function useId(provided?: string): string;
+/**
+ * A callback whose identity never changes but which always sees fresh props.
+ * Lets us hand stable handlers to consumers without re-render churn.
+ */
+declare function useEvent<T extends (...args: any[]) => any>(fn: T): T;
+interface ControllableStateOptions<T> {
+    value?: T;
+    defaultValue: T | (() => T);
+    onChange?: (value: T) => void;
+}
+/** One state hook that is controlled, uncontrolled, or both. */
+declare function useControllableState<T>({ value, defaultValue, onChange, }: ControllableStateOptions<T>): [T, (next: T | ((prev: T) => T)) => void];
+
+/**
+ * Fold a slot's `classNames`, `styles` and `slotProps` overrides into the
+ * behaviour props a component generated. Handlers chain, classes concatenate,
+ * styles merge.
+ */
+declare function slotProps<Slot extends string, State>(overrides: SlotOverrides<Slot, State> | undefined, slot: Slot, base: PropsBag): PropsBag;
+/**
+ * Render a slot, letting the consumer swap the element while keeping every
+ * accessibility prop. `defaultRender` is used when no override exists.
+ */
+declare function renderSlot<Slot extends string, State>(overrides: SlotOverrides<Slot, State> | undefined, slot: Slot, props: PropsBag, state: State, children: React.ReactNode, defaultRender: (props: PropsBag, children: React.ReactNode) => React.ReactNode): React.ReactNode;
+
+interface LazyOptions {
+    /** Rendered while the chunk downloads, and in the placeholder. Default: nothing. */
+    fallback?: React.ReactNode;
+    /** Name shown in React DevTools. */
+    displayName?: string;
+    /** What `lazy: 'auto'` means for this component: `eager` when light, `visible` when heavy. Default `eager`. */
+    auto?: Exclude<PinfoldLazy, 'auto'>;
+}
+/**
+ * Wrap a dynamic import into a drop-in component with its own Suspense
+ * boundary, so consumers get code-splitting without touching their tree:
+ *
+ *   const Accordion = createLazyComponent(() => import('@pinfold/react/accordion'));
+ *   <Accordion items={items} lazy="visible" />
+ *
+ * `lazy` (prop, else the provider): `eager` loads at once, `visible` when the
+ * placeholder nears the viewport, `idle` when the browser is idle. Lazy entries
+ * render on the client; for complete server HTML use the main entry.
+ */
+declare function createLazyComponent<P extends object>(loader: () => Promise<{
+    default: React.ComponentType<P>;
+}>, options?: LazyOptions): React.ComponentType<P & {
+    lazy?: PinfoldLazy;
+}>;
+
+export { PinfoldProvider, SlotOverrides, createLazyComponent, renderSlot, slotProps, useControllableState, useEvent, useId, useIsomorphicLayoutEffect, usePinfold };
+export type { ControllableStateOptions, LazyOptions, PinfoldContextValue, PinfoldProviderProps };

package/dist/client.js

@@ -0,0 +1,29 @@
+'use client';
+import {
+  renderSlot,
+  slotProps,
+  usePinfoldComponent
+} from "./chunk-BPPCPHHU.js";
+import {
+  createLazyComponent
+} from "./chunk-5ZMK623A.js";
+import {
+  PinfoldProvider,
+  useControllableState,
+  useEvent,
+  useId,
+  useIsomorphicLayoutEffect,
+  usePinfold
+} from "./chunk-Q232PTPW.js";
+export {
+  PinfoldProvider,
+  createLazyComponent,
+  renderSlot,
+  slotProps,
+  useControllableState,
+  useEvent,
+  useId,
+  useIsomorphicLayoutEffect,
+  usePinfold,
+  usePinfoldComponent
+};

package/dist/index.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+var client_cjs = require('./client.cjs');
+
+// src/index.ts
+
+// src/config.ts
+function defineConfig(config) {
+  return config;
+}
+
+Object.defineProperty(exports, "PinfoldProvider", {
+  enumerable: true,
+  get: function () { return client_cjs.PinfoldProvider; }
+});
+Object.defineProperty(exports, "createLazyComponent", {
+  enumerable: true,
+  get: function () { return client_cjs.createLazyComponent; }
+});
+Object.defineProperty(exports, "renderSlot", {
+  enumerable: true,
+  get: function () { return client_cjs.renderSlot; }
+});
+Object.defineProperty(exports, "slotProps", {
+  enumerable: true,
+  get: function () { return client_cjs.slotProps; }
+});
+Object.defineProperty(exports, "useControllableState", {
+  enumerable: true,
+  get: function () { return client_cjs.useControllableState; }
+});
+Object.defineProperty(exports, "useEvent", {
+  enumerable: true,
+  get: function () { return client_cjs.useEvent; }
+});
+Object.defineProperty(exports, "useId", {
+  enumerable: true,
+  get: function () { return client_cjs.useId; }
+});
+Object.defineProperty(exports, "useIsomorphicLayoutEffect", {
+  enumerable: true,
+  get: function () { return client_cjs.useIsomorphicLayoutEffect; }
+});
+Object.defineProperty(exports, "usePinfold", {
+  enumerable: true,
+  get: function () { return client_cjs.usePinfold; }
+});
+Object.defineProperty(exports, "usePinfoldComponent", {
+  enumerable: true,
+  get: function () { return client_cjs.usePinfoldComponent; }
+});
+exports.defineConfig = defineConfig;

package/dist/index.d.cts

@@ -0,0 +1,123 @@
+import * as React from 'react';
+import { PinfoldTheme, PinfoldRadius, PinfoldDir, PinfoldSize, PinfoldTone, PinfoldStylePack, PinfoldLazy, PropsBag } from '@pinfold/core';
+import { S as SlotOverrides } from './types-N0Yo4zGa.cjs';
+import { AccordionOptions } from './accordion/index.cjs';
+export { P as PinfoldComponent, w as SlotRenderer, x as Slottable, y as usePinfoldComponent } from './types-N0Yo4zGa.cjs';
+
+/** Per-component defaults. Data, state and ids never belong here, only how components look and behave. */
+interface PinfoldComponentDefaults {
+    accordion?: Omit<AccordionOptions, 'value' | 'defaultValue' | 'disabledIds' | 'id'>;
+}
+/**
+ * The global config, usually in `pinfold.config.ts` (or `.js`):
+ *
+ *   export default defineConfig({ theme: 'system', radius: 'lg', defaults: { accordion: { variant: 'separated' } } });
+ *
+ * and handed to the provider once: `<PinfoldProvider config={config}>`.
+ * Precedence, highest first: component config, `defaults.<component>`, this
+ * global theme, the library defaults. A nested provider overrides its section.
+ */
+interface PinfoldConfig {
+    theme?: PinfoldTheme;
+    radius?: PinfoldRadius;
+    dir?: PinfoldDir;
+    size?: PinfoldSize;
+    tone?: PinfoldTone;
+    /** Visual style pack (needs `@pinfold/css/packs.css`). Default `'default'`. */
+    stylePack?: PinfoldStylePack;
+    /** Default code-loading strategy for `/lazy` entries. Default `'auto'`. */
+    lazy?: PinfoldLazy;
+    /** Disable every component transition, e.g. in tests or on low-power devices. */
+    disableAnimation?: boolean;
+    defaults?: PinfoldComponentDefaults;
+}
+/** Identity function that types a global config. Safe to call from Server Components. */
+declare function defineConfig<T extends PinfoldConfig>(config: T): T;
+
+interface PinfoldContextValue {
+    theme: PinfoldTheme;
+    radius: PinfoldRadius;
+    dir: PinfoldDir;
+    size: PinfoldSize;
+    tone: PinfoldTone;
+    stylePack: PinfoldStylePack;
+    lazy: PinfoldLazy;
+    /** Disable every component transition, e.g. in tests or on low-power devices. */
+    disableAnimation: boolean;
+    defaults: PinfoldComponentDefaults;
+}
+/** Component-level defaults. Every component calls this; the provider is optional. */
+declare function usePinfold(): PinfoldContextValue;
+interface PinfoldProviderProps extends PinfoldConfig {
+    children?: React.ReactNode;
+    /** A whole config from `defineConfig()`. Individual props override it. */
+    config?: PinfoldConfig;
+    /**
+     * Write `data-pinfold-theme` / `data-pinfold-radius` / `data-pinfold-style`
+     * onto `<html>` instead of a wrapper element. Use this when portals
+     * (dialogs, tooltips) must inherit the theme. Default: false.
+     */
+    applyToDocument?: boolean;
+    className?: string;
+}
+declare function PinfoldProvider(props: PinfoldProviderProps): React.ReactElement;
+
+/** SSR-safe layout effect. */
+declare const useIsomorphicLayoutEffect: typeof React.useLayoutEffect;
+/**
+ * Stable, SSR-safe id (React 18+ `useId`). The characters React wraps ids in
+ * (`:` in 18, `«»` in 19) are stripped so the id is also a valid CSS selector.
+ */
+declare function useId(provided?: string): string;
+/**
+ * A callback whose identity never changes but which always sees fresh props.
+ * Lets us hand stable handlers to consumers without re-render churn.
+ */
+declare function useEvent<T extends (...args: any[]) => any>(fn: T): T;
+interface ControllableStateOptions<T> {
+    value?: T;
+    defaultValue: T | (() => T);
+    onChange?: (value: T) => void;
+}
+/** One state hook that is controlled, uncontrolled, or both. */
+declare function useControllableState<T>({ value, defaultValue, onChange, }: ControllableStateOptions<T>): [T, (next: T | ((prev: T) => T)) => void];
+
+/**
+ * Fold a slot's `classNames`, `styles` and `slotProps` overrides into the
+ * behaviour props a component generated. Handlers chain, classes concatenate,
+ * styles merge.
+ */
+declare function slotProps<Slot extends string, State>(overrides: SlotOverrides<Slot, State> | undefined, slot: Slot, base: PropsBag): PropsBag;
+/**
+ * Render a slot, letting the consumer swap the element while keeping every
+ * accessibility prop. `defaultRender` is used when no override exists.
+ */
+declare function renderSlot<Slot extends string, State>(overrides: SlotOverrides<Slot, State> | undefined, slot: Slot, props: PropsBag, state: State, children: React.ReactNode, defaultRender: (props: PropsBag, children: React.ReactNode) => React.ReactNode): React.ReactNode;
+
+interface LazyOptions {
+    /** Rendered while the chunk downloads, and in the placeholder. Default: nothing. */
+    fallback?: React.ReactNode;
+    /** Name shown in React DevTools. */
+    displayName?: string;
+    /** What `lazy: 'auto'` means for this component: `eager` when light, `visible` when heavy. Default `eager`. */
+    auto?: Exclude<PinfoldLazy, 'auto'>;
+}
+/**
+ * Wrap a dynamic import into a drop-in component with its own Suspense
+ * boundary, so consumers get code-splitting without touching their tree:
+ *
+ *   const Accordion = createLazyComponent(() => import('@pinfold/react/accordion'));
+ *   <Accordion items={items} lazy="visible" />
+ *
+ * `lazy` (prop, else the provider): `eager` loads at once, `visible` when the
+ * placeholder nears the viewport, `idle` when the browser is idle. Lazy entries
+ * render on the client; for complete server HTML use the main entry.
+ */
+declare function createLazyComponent<P extends object>(loader: () => Promise<{
+    default: React.ComponentType<P>;
+}>, options?: LazyOptions): React.ComponentType<P & {
+    lazy?: PinfoldLazy;
+}>;
+
+export { PinfoldProvider, SlotOverrides, createLazyComponent, defineConfig, renderSlot, slotProps, useControllableState, useEvent, useId, useIsomorphicLayoutEffect, usePinfold };
+export type { ControllableStateOptions, LazyOptions, PinfoldComponentDefaults, PinfoldConfig, PinfoldContextValue, PinfoldProviderProps };

package/dist/index.d.ts

@@ -0,0 +1,123 @@
+import * as React from 'react';
+import { PinfoldTheme, PinfoldRadius, PinfoldDir, PinfoldSize, PinfoldTone, PinfoldStylePack, PinfoldLazy, PropsBag } from '@pinfold/core';
+import { S as SlotOverrides } from './types-N0Yo4zGa.js';
+import { AccordionOptions } from './accordion/index.js';
+export { P as PinfoldComponent, w as SlotRenderer, x as Slottable, y as usePinfoldComponent } from './types-N0Yo4zGa.js';
+
+/** Per-component defaults. Data, state and ids never belong here, only how components look and behave. */
+interface PinfoldComponentDefaults {
+    accordion?: Omit<AccordionOptions, 'value' | 'defaultValue' | 'disabledIds' | 'id'>;
+}
+/**
+ * The global config, usually in `pinfold.config.ts` (or `.js`):
+ *
+ *   export default defineConfig({ theme: 'system', radius: 'lg', defaults: { accordion: { variant: 'separated' } } });
+ *
+ * and handed to the provider once: `<PinfoldProvider config={config}>`.
+ * Precedence, highest first: component config, `defaults.<component>`, this
+ * global theme, the library defaults. A nested provider overrides its section.
+ */
+interface PinfoldConfig {
+    theme?: PinfoldTheme;
+    radius?: PinfoldRadius;
+    dir?: PinfoldDir;
+    size?: PinfoldSize;
+    tone?: PinfoldTone;
+    /** Visual style pack (needs `@pinfold/css/packs.css`). Default `'default'`. */
+    stylePack?: PinfoldStylePack;
+    /** Default code-loading strategy for `/lazy` entries. Default `'auto'`. */
+    lazy?: PinfoldLazy;
+    /** Disable every component transition, e.g. in tests or on low-power devices. */
+    disableAnimation?: boolean;
+    defaults?: PinfoldComponentDefaults;
+}
+/** Identity function that types a global config. Safe to call from Server Components. */
+declare function defineConfig<T extends PinfoldConfig>(config: T): T;
+
+interface PinfoldContextValue {
+    theme: PinfoldTheme;
+    radius: PinfoldRadius;
+    dir: PinfoldDir;
+    size: PinfoldSize;
+    tone: PinfoldTone;
+    stylePack: PinfoldStylePack;
+    lazy: PinfoldLazy;
+    /** Disable every component transition, e.g. in tests or on low-power devices. */
+    disableAnimation: boolean;
+    defaults: PinfoldComponentDefaults;
+}
+/** Component-level defaults. Every component calls this; the provider is optional. */
+declare function usePinfold(): PinfoldContextValue;
+interface PinfoldProviderProps extends PinfoldConfig {
+    children?: React.ReactNode;
+    /** A whole config from `defineConfig()`. Individual props override it. */
+    config?: PinfoldConfig;
+    /**
+     * Write `data-pinfold-theme` / `data-pinfold-radius` / `data-pinfold-style`
+     * onto `<html>` instead of a wrapper element. Use this when portals
+     * (dialogs, tooltips) must inherit the theme. Default: false.
+     */
+    applyToDocument?: boolean;
+    className?: string;
+}
+declare function PinfoldProvider(props: PinfoldProviderProps): React.ReactElement;
+
+/** SSR-safe layout effect. */
+declare const useIsomorphicLayoutEffect: typeof React.useLayoutEffect;
+/**
+ * Stable, SSR-safe id (React 18+ `useId`). The characters React wraps ids in
+ * (`:` in 18, `«»` in 19) are stripped so the id is also a valid CSS selector.
+ */
+declare function useId(provided?: string): string;
+/**
+ * A callback whose identity never changes but which always sees fresh props.
+ * Lets us hand stable handlers to consumers without re-render churn.
+ */
+declare function useEvent<T extends (...args: any[]) => any>(fn: T): T;
+interface ControllableStateOptions<T> {
+    value?: T;
+    defaultValue: T | (() => T);
+    onChange?: (value: T) => void;
+}
+/** One state hook that is controlled, uncontrolled, or both. */
+declare function useControllableState<T>({ value, defaultValue, onChange, }: ControllableStateOptions<T>): [T, (next: T | ((prev: T) => T)) => void];
+
+/**
+ * Fold a slot's `classNames`, `styles` and `slotProps` overrides into the
+ * behaviour props a component generated. Handlers chain, classes concatenate,
+ * styles merge.
+ */
+declare function slotProps<Slot extends string, State>(overrides: SlotOverrides<Slot, State> | undefined, slot: Slot, base: PropsBag): PropsBag;
+/**
+ * Render a slot, letting the consumer swap the element while keeping every
+ * accessibility prop. `defaultRender` is used when no override exists.
+ */
+declare function renderSlot<Slot extends string, State>(overrides: SlotOverrides<Slot, State> | undefined, slot: Slot, props: PropsBag, state: State, children: React.ReactNode, defaultRender: (props: PropsBag, children: React.ReactNode) => React.ReactNode): React.ReactNode;
+
+interface LazyOptions {
+    /** Rendered while the chunk downloads, and in the placeholder. Default: nothing. */
+    fallback?: React.ReactNode;
+    /** Name shown in React DevTools. */
+    displayName?: string;
+    /** What `lazy: 'auto'` means for this component: `eager` when light, `visible` when heavy. Default `eager`. */
+    auto?: Exclude<PinfoldLazy, 'auto'>;
+}
+/**
+ * Wrap a dynamic import into a drop-in component with its own Suspense
+ * boundary, so consumers get code-splitting without touching their tree:
+ *
+ *   const Accordion = createLazyComponent(() => import('@pinfold/react/accordion'));
+ *   <Accordion items={items} lazy="visible" />
+ *
+ * `lazy` (prop, else the provider): `eager` loads at once, `visible` when the
+ * placeholder nears the viewport, `idle` when the browser is idle. Lazy entries
+ * render on the client; for complete server HTML use the main entry.
+ */
+declare function createLazyComponent<P extends object>(loader: () => Promise<{
+    default: React.ComponentType<P>;
+}>, options?: LazyOptions): React.ComponentType<P & {
+    lazy?: PinfoldLazy;
+}>;
+
+export { PinfoldProvider, SlotOverrides, createLazyComponent, defineConfig, renderSlot, slotProps, useControllableState, useEvent, useId, useIsomorphicLayoutEffect, usePinfold };
+export type { ControllableStateOptions, LazyOptions, PinfoldComponentDefaults, PinfoldConfig, PinfoldContextValue, PinfoldProviderProps };

package/dist/index.js

@@ -0,0 +1,10 @@
+export { PinfoldProvider, createLazyComponent, renderSlot, slotProps, useControllableState, useEvent, useId, useIsomorphicLayoutEffect, usePinfold, usePinfoldComponent } from './client.js';
+
+// src/index.ts
+
+// src/config.ts
+function defineConfig(config) {
+  return config;
+}
+
+export { defineConfig };