praxis-kit 4.0.0 → 4.0.3

package/dist/merge-refs-DUuHyTRO.d.ts

@@ -1,144 +0,0 @@
-import { ComponentType, PropsWithChildren, ReactElement, JSX, Ref, ReactNode } from 'react';
-import { ElementType, VariantMap, RecipeMap, EmptyRecord, ClassPluginFactory, AnyRecord, FactoryOptions, IntrinsicTag, PolymorphicGenerics, DefaultOf, PropsOf, VariantProps, VariantsOf, AllowedOf, ClassName, RecipeOf } from '@praxis-kit/core';
-import { ComponentDefinition } from '@praxis-kit/runtime';
-import { Simplify, NonEmptyTuple } from 'type-fest';
-
-type UnknownProps = Record<string, unknown>;
-type SlotComponent = ComponentType<UnknownProps>;
-
-/**
- * Props passed to the `render` callback — the component's resolved className,
- * filtered own props, and ref. Spread these onto the target element.
- *
- * Typed loosely to accommodate any element tag the user chooses.
- */
-type RenderCallbackProps = Readonly<Record<string, unknown>>;
-
-type SlottableProps = PropsWithChildren;
-declare function Slottable({ children }: SlottableProps): ReactElement;
-
-/** Structural subset of `CompiledComponentArtifact` consumed by the React adapter. */
-interface CompiledArtifact {
-    readonly definition: ComponentDefinition;
-    readonly precomputed?: {
-        readonly variantLookup?: Record<string, string>;
-    };
-}
-/**
- * Extends FactoryOptions with React-specific configuration.
- * slotComponent is intentionally not in core — it is a React rendering concern.
- */
-type ReactFactoryOptions<TDefault extends ElementType, Props extends UnknownProps, Variants extends Readonly<VariantMap>, TPreset extends RecipeMap<Variants> = Readonly<EmptyRecord>, TPlugin extends ClassPluginFactory<AnyRecord> | undefined = ClassPluginFactory<AnyRecord> | undefined, TAllowed extends ElementType = ElementType> = FactoryOptions<TDefault, Props, Variants, TPreset, TPlugin, TAllowed> & {
-    /** Component used to render the asChild slot. Defaults to the built-in Slot. */
-    slotComponent?: SlotComponent;
-    /**
-     * Return true for any prop key that should be consumed but not forwarded to the DOM.
-     * The adapter strips nothing by default — implementations decide what is safe to drop.
-     * Receives `runtime.options.variantKeys` as a convenience if needed.
-     */
-    filterProps?: (key: string, variantKeys: ReadonlySet<string>) => boolean;
-    /** Pre-compiled artifact from `@praxis-kit/runtime`'s compiler. When provided, replaces the stub
-     *  definition and enables the precomputed variant lookup fast path. */
-    artifact?: CompiledArtifact;
-};
-
-/** Maps a core ElementType to its DOM instance type for ref inference. */
-type ElementRef<T extends ElementType> = T extends IntrinsicTag ? HTMLElementTagNameMap[T] : unknown;
-/** @internal React JSX intrinsic props for a given element type. */
-type IntrinsicJSXProps<T extends ElementType> = T extends IntrinsicTag ? JSX.IntrinsicElements[T] : UnknownProps;
-/**
- * @internal
- * Removes index signatures (e.g. `[key: string]: T`) from a type, keeping only
- * explicitly named properties. Used to prevent fallback-to-constraint generics
- * like `Record<string, unknown>` or `Readonly<VariantMap>` from producing a
- * `[key: string]: T` member that makes `keyof` resolve to `string` — which
- * would cause `Omit<IntrinsicJSXProps<TAs>, string>` to remove all HTML props.
- */
-type StripIndexSignature<T> = {
-    [K in keyof T as string extends K ? never : K]: T[K];
-};
-type ComponentProps<G extends PolymorphicGenerics> = StripIndexSignature<PropsOf<G>>;
-type ComponentVariants<G extends PolymorphicGenerics> = StripIndexSignature<VariantProps<VariantsOf<G>>>;
-type OwnedProps<G extends PolymorphicGenerics> = ComponentProps<G> & ComponentVariants<G>;
-/**
- * @internal
- * Polymorphic machinery props. Separated from `OwnedProps` so the two concerns
- * are distinct: user-defined props vs. the tag/ref/class system.
- *
- * `asChild` and `children` are excluded — typed separately in the discriminated
- * union below so each render mode can enforce different child constraints.
- */
-type PolymorphicControlProps<G extends PolymorphicGenerics, TAs extends ElementType> = {
-    as?: TAs & AllowedOf<G>;
-    className?: ClassName | undefined;
-    recipe?: keyof RecipeOf<G>;
-    ref?: Ref<ElementRef<TAs>>;
-};
-/** @internal Full set of props owned by the component — used as the Omit key in IntrinsicPropsWithoutOwned. */
-type ControlProps<G extends PolymorphicGenerics, TAs extends ElementType> = OwnedProps<G> & PolymorphicControlProps<G, TAs>;
-type IntrinsicPropsWithoutOwned<G extends PolymorphicGenerics, TAs extends ElementType> = Omit<IntrinsicJSXProps<TAs>, keyof ControlProps<G, TAs> | 'children'>;
-type SharedProps<G extends PolymorphicGenerics, TAs extends ElementType> = IntrinsicPropsWithoutOwned<G, TAs> & ControlProps<G, TAs>;
-/** Discriminant for the normal render path: `asChild` absent or false, any children. */
-type NormalRenderMode = {
-    asChild?: false;
-    children?: ReactNode | undefined;
-};
-/**
- * Discriminant for the slot render path. One or more `ReactElement` children required.
- * `as` is forbidden — combining `as` with `asChild` is a runtime invariant violation.
- */
-type SlotRenderMode = {
-    asChild: true;
-    as?: never;
-    children: ReactElement | NonEmptyTuple<ReactElement>;
-};
-/**
- * Discriminant for the render-prop path. The callback receives all resolved props
- * (className, ref, filtered component props) and returns the target element.
- *
- * This is the output form for the compile-time `asChild` transform: keeps the same
- * rendering flexibility as `asChild` without the `cloneElement` cost at runtime.
- * Unlike `asChild`, the render callback does not auto-merge conflicting event
- * handlers — spread position determines precedence.
- *
- * ```tsx
- * <Button render={(p) => <a href="/home" {...p} />} size="lg" />
- * ```
- */
-type CallbackRenderMode = {
-    render: (props: RenderCallbackProps) => ReactElement;
-    asChild?: never;
-    children?: never;
-};
-/**
- * Props for the normal render path. HTML attributes are inferred from `TAs`.
- *
- * `Omit + intersection` (not `Merge`) is used so TypeScript can infer `TAs` from
- * the `as` prop value; control props win on key conflicts.
- */
-type PolymorphicProps<G extends PolymorphicGenerics, TAs extends ElementType = DefaultOf<G>> = Simplify<SharedProps<G, TAs> & NormalRenderMode>;
-/**
- * Props for the slot render path (`asChild: true`). One or more `ReactElement`
- * children are required. Multiple children are permitted for the Slottable
- * sibling pattern where one child is a `<Slottable>` wrapper.
- */
-type PolymorphicWithAsChild<G extends PolymorphicGenerics, TAs extends ElementType = DefaultOf<G>> = Simplify<SharedProps<G, TAs> & SlotRenderMode>;
-type PolymorphicWithRender<G extends PolymorphicGenerics, TAs extends ElementType = DefaultOf<G>> = Simplify<SharedProps<G, TAs> & CallbackRenderMode>;
-/**
- * A polymorphic component that infers HTML attributes and ref type from the `as` prop.
- *
- * Three call signatures form a discriminated union:
- * - `render` present       → render-prop path; no Slot or cloneElement at runtime
- * - `asChild: true`        → slot path; exactly one `ReactElement` child required
- * - `asChild?: false`      → normal path; any `ReactNode` children accepted
- */
-type PolymorphicComponent<G extends PolymorphicGenerics> = {
-    <TAs extends ElementType = DefaultOf<G>>(props: PolymorphicWithRender<G, TAs>): ReactElement;
-    <TAs extends ElementType = DefaultOf<G>>(props: PolymorphicWithAsChild<G, TAs>): ReactElement;
-    <TAs extends ElementType = DefaultOf<G>>(props: PolymorphicProps<G, TAs>): ReactElement;
-    displayName?: string;
-};
-
-declare function mergeRefs<T>(...refs: (Ref<T> | null | undefined)[]): Ref<T> | null;
-
-export { type ElementRef as E, type PolymorphicComponent as P, type ReactFactoryOptions as R, Slottable as S, type UnknownProps as U, type PolymorphicProps as a, type PolymorphicWithAsChild as b, type PolymorphicWithRender as c, type RenderCallbackProps as d, type SlottableProps as e, mergeRefs as m };