react-polymorphic 1.0.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Dashice
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,5 @@
+react-polymorphic
+Copyright 2026 Dashice
+
+This project is licensed under the Apache License, Version 2.0.
+See the LICENSE file for details.

package/README.md

@@ -0,0 +1,351 @@
+# react-polymorphic
+
+[![CI](https://github.com/Dashice/react-polymorphic/actions/workflows/ci.yml/badge.svg)](https://github.com/Dashice/react-polymorphic/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/react-polymorphic.svg)](https://www.npmjs.com/package/react-polymorphic)
+[![license](https://img.shields.io/npm/l/react-polymorphic.svg)](./LICENSE)
+
+*Great to Perfect. The catalyst for your design-system.*
+
+A single component factory function for polymorphic React components. Built for React 19+ with strong TypeScript inference.
+
+```tsx
+import { createPolymorph } from 'react-polymorphic';
+
+const Button = createPolymorph<'button'>(({ as: Tag = 'button', ...rest }) => {
+	return <Tag {...rest} />
+})
+
+const App = () => {
+	return <Button as="a" href="/">Home</Button>
+}
+```
+
+## Table of Contents
+
+- [Why Polymorphic Components?](#why-polymorphic-components)
+- [Features](#features)
+- [Installation](#installation)
+- [Examples](#examples)
+  - [1 — Basic Usage](#1--basic-usage)
+  - [2 — Using `ref`](#2--using-ref)
+  - [3 — Config & Branded Types](#3--config--branded-types)
+  - [4 — Advanced `as` Composition with `root`](#4--advanced-as-composition-with-root)
+  - [5 — Advanced Composition & Inference](#5--advanced-composition--inference)
+- [API](#api)
+  - [`createPolymorph`](#createpolymorph)
+  - [Component Props](#component-props)
+  - [Generics](#generics)
+  - [Utility Types](#utility-types)
+- [Compatibility](#compatibility)
+- [Contributing + Changesets](#contributing--changesets)
+  - [Local setup](#local-setup)
+  - [PR requirements](#pr-requirements)
+  - [Automation](#automation)
+- [License](#license)
+
+## Why Polymorphic Components?
+
+Design systems need components that are reusable **without** being rigid.  
+A `<Button />` might need to render as a native `<button />` in one context and as an `<a />` in another. A heading component may need to shift from `<h1 />` to `<h3 />` based on document hierarchy.
+
+Polymorphic components let you keep one consistent API while swapping the rendered element to match context (`button -> a`, `div -> section`, `h1 -> h3`), preserving semantics, accessibility, and developer ergonomics.
+
+`react-polymorphic` is built to take this beyond a basic `as` prop, with an API that gives you precise control over inherited props, component composition, and render behavior.
+
+## Features
+
+- **Polymorphism Beyond `as`**  
+  Supports intrinsic elements, React components, and composed polymorphic components.
+
+- **`root` Override for Composition**  
+  Control the final rendered element when nesting polymorphic components.
+
+- **Type-safe Inherited Prop Control**  
+  Use `PolymorphicConfig` with `Inherit` and `Unset` to preserve, remove, or reshape inherited props.
+
+- **Ref Inference that Follows Render Target**  
+  `ref` types track the active element/component target.
+
+- **Inference Utilities Included**  
+  `InferPolymorphElement`, `InferPolymorphProps`, and `InferPolymorphConfig` for advanced typing workflows.
+
+- **TypeScript 7 Ready**  
+	Compatible with TypeScript 5.4+ and optimized for TypeScript 7.
+
+- **Built for React 19+**  
+  Leverages React 19's handling of `ref`, eliminating `forwardRef` and convoluted type gymnastics.
+
+- **ESM Exclusive**  
+  No CommonJS, no legacy build artifacts. Tree-shakable and optimized for modern bundlers.
+
+## Installation
+
+```bash
+npm install react-polymorphic
+```
+
+Use the equivalent command for your package manager of choice.
+
+## Examples
+
+### 1 — Basic Usage
+
+Most polymorphic components are simple wrappers that combine custom props with inferred DOM attributes.
+
+```tsx
+import { createPolymorph } from 'react-polymorphic';
+
+type Props = {
+	variant: 'primary' | 'secondary';
+}
+
+const Pane = createPolymorph<'div', Props>((props) => {
+	const { as: Tag = 'div', variant, className, ...rest } = props;
+	const variantClasses = variant === 'primary' ? 'bg-white' : 'bg-blue-50';
+
+	return <Tag className={`p-4 ${variantClasses} ${className}`} {...rest} />
+})
+
+const App = () => {
+	return (
+		<>
+			<Pane as="section" variant="primary" aria-label="...">...</Pane>
+			<Pane as="aside" variant="secondary" aria-label="...">...</Pane>
+		</>
+	)
+}
+```
+
+`Props` and the intrinsic attributes of `'div'` are merged into one contract. Consumers can then switch semantics with `as` (`section`, `aside`, etc.) while keeping the same component API.
+
+### 2 — Using `ref`
+
+`ref` is inferred from the active render target. With React 19, you can use `ref` directly without `forwardRef`.
+
+```tsx
+import { useRef } from 'react';
+import { createPolymorph } from 'react-polymorphic';
+
+const Component = createPolymorph<'div'>((props) => {
+	const { as: Tag = 'div', ...rest } = props;
+	return <Tag {...rest} />
+})
+
+const App = () => {
+	const ref = useRef<HTMLDivElement>(null);
+	const aRef = useRef<HTMLAnchorElement>(null);
+
+	return (
+		<>
+			<Component ref={ref} />
+			<Component as="a" ref={aRef} />
+		</>
+	)
+}
+```
+
+`ref` follows `as` automatically (and also follows `root` when composing with polymorphic components).
+
+### 3 — Config & Branded Types
+
+Use `PolymorphicConfig` to reshape inferred props: remove, preserve, override, or require attributes.
+
+```tsx
+import { createPolymorph } from 'react-polymorphic';
+import type { PolymorphicConfig, Unset, Inherit } from 'react-polymorphic';
+
+type Props = {
+	loading: boolean;
+}
+
+type Config = PolymorphicConfig<'button', {
+	'aria-loading': Unset;
+	children: string;
+	href: string;
+	target?: '_blank';
+	type: Inherit;
+}>;
+
+const Button = createPolymorph<'button', Props, Config>((props) => {
+	const { as: Tag = 'button', children, loading, ...rest } = props;
+
+	return (
+		<Tag aria-loading={loading} {...rest}>
+			{loading ? 'Loading...' : children}
+		</Tag>
+	)
+})
+
+const App = () => {
+	return (
+		<>
+			<Button type="button">Calculate</Button>
+			<Button as="a" href="/">Back to home</Button>
+		</>
+	)
+}
+```
+
+- `Unset` removes an inferred prop from the resulting contract.
+- `Inherit` preserves the inferred type (useful when making a prop required or composing unions).
+- Adding `href` and `target` to `Config` prepares the component for common `as="a"` usage.
+- `PolymorphicConfig` is optional, but recommended for code hints and safer attribute authoring.
+
+### 4 — Advanced `as` Composition with `root`
+
+When `as` points to another polymorphic component, `root` lets you control that component's final underlying element.
+
+```tsx
+import { createPolymorph } from 'react-polymorphic';
+
+const OtherComponent = createPolymorph<'div'>(...);
+
+const Component = createPolymorph<'div'>((props) => {
+	const { as: Tag = 'div', ...rest } = props;
+	return <Tag {...rest} />
+});
+
+const App = () => {
+	return <Component as={OtherComponent} root="section" />
+}
+```
+
+`root` behaves similarly to `key`: it influences rendering behavior but is not part of the consumed `props` inside your render function.
+
+### 5 — Advanced Composition & Inference
+
+You can extract generics from existing polymorphic components and reuse them when extending third-party components.
+
+```tsx
+import { createPolymorph } from 'react-polymorphic';
+import type {
+	InferPolymorphElement,
+	InferPolymorphProps,
+	InferPolymorphConfig
+} from 'react-polymorphic';
+import { TheirButton } from 'some-library';
+
+type TheirElement = InferPolymorphElement<typeof TheirButton>;
+// 'button'
+
+type TheirProps = InferPolymorphProps<typeof TheirButton>;
+// { message: string }
+
+type TheirConfig = InferPolymorphConfig<typeof TheirButton>;
+// { id?: number; title: string }
+
+type Props = { ... }
+
+const OurButton = createPolymorph<typeof TheirButton, Props>((props) => {
+	const { as: Tag = TheirButton, ...rest } = props;
+	return <Tag {...rest} />
+})
+```
+
+This pattern keeps your extension aligned with the base component contract while still allowing consumers to swap `as`.
+
+If swapping out the base would break core behavior, preserve the base and expose only its internal polymorphism:
+
+```tsx
+const OurButton = createPolymorph<TheirElement, Props & TheirProps, TheirConfig>(
+	(props) => {
+		const { as = 'button', ...rest } = props;
+		return <TheirButton as={as} {...rest} />
+	}
+)
+
+const App = () => {
+	return <OurButton as="a" />
+}
+```
+
+In this version, `OurButton` always renders `TheirButton`, and `as` only controls what `TheirButton` itself renders to the DOM.
+
+## API
+
+### `createPolymorph`
+
+Creates polymorphic components with strong inference for `as`, `root`, and `ref`.
+
+| Export            | Kind       |
+| ----------------- | ---------- |
+| `createPolymorph` | `function` |
+
+#### Component Props
+
+| Prop   | Type                               | Notes                    |
+| ------ | ---------------------------------- | ------------------------ |
+| `as?`   | element \| component              | Swaps target.            |
+| `root?` | element \| `Fragment`             | Overrides nested target. |
+| `ref?`  | inferred from final target        | Follows `as`/`root`.     |
+
+#### Generics
+
+| Generic | Meaning                              |
+| ------- | ------------------------------------ |
+| `T`     | Default render target.               |
+| `P`     | Custom component props.              |
+| `C`     | Prop config via `PolymorphicConfig`. |
+
+### Utility Types
+
+| Export                     | Purpose                        |
+| -------------------------- | ------------------------------ |
+| `PolymorphicConfig<T, C>`  | Configures inherited props.    |
+| `Inherit`                  | Preserves inferred prop type.  |
+| `Unset`                    | Removes an inferred prop.      |
+| `InferPolymorphElement<T>` | Extracts default target type.  |
+| `InferPolymorphProps<T>`   | Extracts custom props type.    |
+| `InferPolymorphConfig<T>`  | Extracts config type.          |
+
+## Compatibility
+
+| Package      | Version    |
+| ------------ | ---------- |
+| `react`      | `>=19.0.0` |
+| `react-dom`  | `>=19.0.0` |
+| `typescript` | `>=5.4.0`  |
+
+## Contributing + Changesets
+
+Contributions are welcome. For bug fixes, improvements, or new features, please open a PR with a clear summary of the change.
+
+### Local setup
+
+```bash
+pnpm install
+pnpm typecheck
+pnpm test:run
+```
+
+### PR requirements
+
+- Keep changes focused and include tests when behavior changes.
+- Add a changeset for all user-facing package changes:
+
+```bash
+pnpm changeset
+```
+
+When prompted, choose the correct bump type:
+
+- `patch` → fixes and small improvements
+- `minor` → new backward-compatible features
+- `major` → breaking changes
+
+If a PR does not require a release, you can create an empty changeset:
+
+```bash
+pnpm changeset --empty
+```
+
+### Automation
+
+- **Pre-commit** runs `biome check --write` on staged files.
+- **Pre-push** runs `pnpm typecheck` and `pnpm test:run`.
+- **CI** validates formatting, linting, type-checking, tests, and build.
+- **Release** runs only after CI succeeds on `main`, using Changesets to version and publish.
+
+## License
+
+Apache-2.0. See [LICENSE](./LICENSE) and [NOTICE](./NOTICE).

package/dist/createPolymorph.d.ts

@@ -0,0 +1,335 @@
+/** biome-ignore-all lint/suspicious/noExplicitAny: -- */
+/** biome-ignore-all lint/complexity/noBannedTypes: -- */
+import type { ComponentProps, ComponentRef, ExoticComponent, FragmentProps, FunctionComponent, JSX, ReactElement, ReactPortal, Ref } from 'react';
+/**
+ * Performs a distributive omit on a union type.
+ * @see https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types
+ */
+type DistributiveOmit<T, K extends PropertyKey> = T extends any ? Omit<T, K> : never;
+/** Helper to check if a type is exactly `any` */
+type IsAny<T> = 0 extends 1 & T ? true : false;
+/** Extracts all properties from `R` which are set to `Unset` type. */
+type ExtractUnset<R> = {
+    [K in keyof R as IsAny<R[K]> extends true ? never : R[K] extends Unset ? K : never]: R[K];
+};
+/** Check if a key in an object type has the optional modifier (?) */
+type IsOptionalKey<T, K extends keyof T> = {} extends Pick<T, K> ? true : false;
+/** Merges `T` and `Y`, overwriting properties in `T` with those in `Y` */
+type Overwrite<T, Y> = DistributiveOmit<T, keyof Y> & Y;
+/** Extracts all keys in obj `T` whom are required as a string union. */
+type RequiredKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T];
+/** Sets all keys in `K` of type `T` to required. */
+type Require<T, K extends PropertyKey> = Overwrite<T, Required<Pick<T, K extends keyof T ? K : never>>>;
+/**
+ * All valid HTML & SVG elements in string format (`"div"`, `"svg"`, `"input"`)
+ */
+type ElementType = keyof JSX.IntrinsicElements;
+/** A React Fragment component. */
+type FragmentType = ExoticComponent<FragmentProps>;
+/**
+ * Valid candidates to fulfill the `root` prop when `as` is a
+ * `FunctionComponent` derivative. This may be:
+ * - A string representing a valid HTML or SVG element
+ * - A React Fragment component
+ */
+type RootType = FragmentType | ElementType | '';
+/**
+ * Valid candidates to fulfill the `as` prop. This may be:
+ * - A string representing a valid HTML or SVG element
+ * - A React FunctionComponent
+ */
+type PolymorphicElementType<P = any> = ElementType | FunctionComponent<P>;
+/**
+ * Required return type of `createPolymorph`; a slightly more restrictive
+ * version of `ReactNode`.
+ */
+type PolymorphicElement<T extends PolymorphicElementType> = ReactElement<T> | ReactPortal | null;
+/** A generic props object. */
+type Props = Record<PropertyKey, unknown>;
+/**
+ * Infers the element type of `PolymorphicExoticComponent`, falling back to `T`
+ * if `TT` it is not a `PolymorphicExoticComponent`. In essence, if `as` prop
+ * is not specified, the element type will be `T`.
+ */
+type ElementOf<TT, T> = TT extends PolymorphicExoticComponent<infer E, any, any> ? E : TT extends PolymorphicElementType ? TT : T;
+/**
+ * Used in `PolymorphicExoticComponent` to determine fallback of `TT`.
+ * Attempts to extract a `PolymorphicElementType` from props of P, if present,
+ * otherwise falls back to `T`.
+ */
+type AsProp<T extends PolymorphicElementType, P extends Props> = 'as' extends keyof P ? P['as'] extends PolymorphicElementType ? P['as'] : T : T;
+/**
+ * Used in `PolymorphicProps` to determine `ref` property value of `T` if it is
+ * a valid `PolymorphicElementType`, otherwise returns an empty object. This is
+ * used to ensure that `ref` prop is only available for valid element types.
+ */
+type RefOf<T extends PolymorphicElementType> = ComponentRef<T> extends never ? {} : {
+    ref?: Ref<ComponentRef<T>>;
+};
+/**
+ * Used in `PolymorphicProps` to determine `as` property value of `P['as']` if
+ * it is a valid `PolymorphicElementType`, otherwise returns `T`. Respects
+ * property optionality.
+ */
+type AsOf<T extends PolymorphicElementType, P extends Props> = 'as' extends keyof P ? P['as'] extends PolymorphicElementType ? IsOptionalKey<P, 'as'> extends true ? {
+    as?: P['as'];
+} : {
+    as: P['as'];
+} : {
+    as?: T;
+} : {
+    as?: T;
+};
+/**
+ * Base props of a component created using `createPolymorph` function,
+ * available during implementation.
+ *
+ * @property as - The element type to render.
+ * @property ref - The ref to the underlying element.
+ */
+type PolymorphicProps<T extends PolymorphicElementType, P extends Props> = AsOf<T, P> & RefOf<T>;
+/**
+ * Base props of a component created using `createPolymorph` function,
+ * available during rendering.
+ *
+ * @property as - Element type to render.
+ * @property root - Root element type to render when `as` is a `FunctionComponent`.
+ * @property ref - Ref of the underlying element.
+ */
+type PolymorphicExoticProps<T extends PolymorphicElementType, R extends RootType> = {
+    as?: T | PolymorphicElementType | PolymorphicExoticComponent<any, any, any>;
+    root?: FragmentType | Exclude<R | ElementType, ''>;
+} & RefOf<R extends '' ? T : R>;
+/**
+ * Composite props of a component created using `createPolymorph` function,
+ * available during implementation. Combines props `P` with inherited element
+ * props `T`, modified using `Config` type `C`.
+ *
+ * @property as - Element type to render.
+ * @property ref - Ref of underlying element.
+ */
+type PolymorphicComponentProps<T extends PolymorphicElementType, P extends Props, C extends Config<T>> = Overwrite<Overwrite<ApplyConfig<T, C>, Omit<P, 'as'>>, PolymorphicProps<T, P>>;
+/**
+ * Composite props of a component created using `createPolymorph` function,
+ * available during rendering. Comines props `P` with inherited element props
+ * `T`, modified using `Config` type `C`.
+ *
+ * @property as - Element type to render.
+ * @property root - Root element type to render when `as` is a `FunctionComponent`.
+ * @property ref - Ref of underlying element.
+ */
+type PolymorphicExoticComponentProps<T extends PolymorphicElementType, P extends Props, C extends Config<T>, R extends RootType> = Overwrite<Overwrite<ApplyConfig<R extends '' ? T : R, C>, P>, PolymorphicExoticProps<T, R>>;
+/**
+ * Component render function passed into `createPolymorph` during
+ * initialization as first argument.
+ *
+ * @param props - Props passed to component.
+ * @returns React element to render.
+ */
+type PolymorphicRenderFunction<T extends PolymorphicElementType, P extends Props, C extends Config<T>> = {
+    (props: PolymorphicComponentProps<T, P, C>): PolymorphicElement<T>;
+    displayName?: string;
+};
+/**
+ * A component created using `createPolymorph` function, which can render
+ * different element types based on the `as` prop.
+ *
+ * When `props` are passed with a modified `as` prop from the default `T`,
+ * props will be inferred from the new externally set `as` value; changing
+ * inferred props from `T` to `TT` element type.
+ *
+ * If, in addition to a modified external `as` (`TT`), a `root` prop is also
+ * set; the `root` prop will be used to determine the final element type to render,
+ * and props will be inferred from the `root` element type instead of the `as`
+ * element type.
+ *
+ * @param props - Props passed to component; including `as` and `root` props.
+ * @returns React element to render.
+ */
+type PolymorphicExoticComponent<T extends PolymorphicElementType, P extends Props, C extends Config<T>> = {
+    <TT = AsProp<T, P>, R extends RootType = ''>(props: TT extends T ? PolymorphicComponentProps<T, P, C> : TT extends PolymorphicExoticComponent<any, any, any> ? PolymorphicExoticComponentProps<ElementOf<TT, T>, Overwrite<P, InferPolymorphProps<TT>>, Overwrite<C, InferPolymorphConfig<TT>>, R> : PolymorphicComponentProps<ElementOf<TT, T>, Overwrite<P, InferPolymorphProps<TT>>, Overwrite<C, InferPolymorphConfig<TT>>>): PolymorphicElement<ElementOf<TT, T>>;
+    displayName?: string;
+};
+/** A generic config object. */
+type Config<T extends PolymorphicElementType> = {
+    [K in keyof ComponentProps<T> | (string & {})]?: unknown;
+};
+type ResolveInherit<CK, PK> = [Extract<CK, Inherit>] extends [never] ? CK : [Exclude<CK, Inherit>] extends [never] ? PK : Exclude<CK, Inherit> | PK;
+type ApplyValues<P, C, PS = Omit<P, keyof (ExtractUnset<C> & JSX.IntrinsicAttributes)>> = {
+    [K in keyof PS]: K extends keyof C ? ResolveInherit<C[K], PS[K]> : PS[K];
+};
+type ApplyConfig<T extends PolymorphicElementType, C extends Config<T>> = Require<ApplyValues<ComponentProps<T & {}>, C>, RequiredKeys<C>>;
+/**
+ * A branded type used in `Config` to indicate that a prop should be removed
+ * from inferred props of `as`.
+ */
+export type Unset = {
+    readonly _unset: unique symbol;
+};
+/**
+ * A branded type used in `Config` to indicate that a prop should be inherited
+ * from inferred props of `as`.
+ */
+export type Inherit = {
+    readonly _inherit: unique symbol;
+};
+/**
+ * A code-hinting friendly `Config` creator for `createPolymorph`, displaying
+ * all available props for the given `as` element type. This type-helper is
+ * not required to create a valid `Config` type, but is useful for code-hinting
+ * and auto-completion in IDEs.
+ *
+ * @example ```tsx
+ * type Config = PolymorphicConfig<'button', {
+ *   title: string | number;
+ *   onClick: Inherit
+ *   type: Unset
+ * }>
+ *
+ * const Component = createPolymorph<'button', Props, Config>(...);
+ */
+export type PolymorphicConfig<T extends PolymorphicElementType, C extends Config<T>> = C & {
+    readonly _tag?: T;
+};
+/**
+ * Infers the `as` prop type from a `PolymorphicExoticComponent`.
+ *
+ * @example ```tsx
+ * const Component = createPolymorph<'div', Props, Config>(...);
+ * type Result = InferPolymorphElement<typeof Component>; // 'div'
+ * ```
+ */
+export type InferPolymorphElement<T> = T extends PolymorphicExoticComponent<infer Tag, any, any> ? Tag : unknown;
+/**
+ * Infers the props type from a `PolymorphicExoticComponent`.
+ *
+ * @example ```tsx
+ * const Component = createPolymorph<'div', Props, Config>(...);
+ * type Result = InferPolymorphProps<typeof Component>; // Props
+ * ```
+ */
+export type InferPolymorphProps<T> = T extends PolymorphicExoticComponent<any, infer P, any> ? P : {};
+/**
+ * Infers the config type from a `PolymorphicExoticComponent`.
+ *
+ * @example ```tsx
+ * const Component = createPolymorph<'div', Props, Config>(...);
+ * type Result = InferPolymorphConfig<typeof Component>; // Config
+ * ```
+ */
+export type InferPolymorphConfig<T> = T extends PolymorphicExoticComponent<any, any, infer C> ? C : {};
+type CreatePolymorph = <T extends PolymorphicElementType, P extends Props = {}, C extends PolymorphicConfig<T, Config<T>> = {}>(render: NoInfer<PolymorphicRenderFunction<T, P, C>>) => NoInfer<PolymorphicExoticComponent<T, P, C>>;
+/**
+ * **Creates a polymorphic component.**
+ * This combines user-provided props `P`, inherited props from `T`, and any
+ * optional modifications to `T` specified in `C`.
+ *
+ * In addition to inherited and user-provided props; exposes following props:
+ * - `as`: Specifies the element type to render to DOM.
+ * - `root`: When `as` is set to another `createPolymorph` created component,
+ * `root` overrides the internal `as` prop of the component being rendered,
+ * allowing for a different element type to be rendered.
+ *
+ * @param render - Render function of `PolymorphicExoticComponent`.
+ *
+ * @returns `PolymorphicExoticComponent`
+ *
+ * ---
+ * **Simple Usage**
+ *
+ * This is the most common use-case for `createPolymorph`, where a component is
+ * created with a default element type `T` and basic props `P`.
+ *
+ * @example
+ * ```tsx
+ * type DefaultTag = 'button'
+ *
+ * type ButtonProps = {
+ *   variant: 'primary' | 'secondary';
+ * }
+ *
+ * const Button = createPolymorph<DefaultTag, ButtonProps>(
+ *   ({ as: Tag = 'button', variant, ...rest }) => {
+ *     const isPrimary = variant === 'primary'
+ *     return <Tag className={isPrimary ? 'bg-black' : 'bg-gray'} {...rest} />
+ *   }
+ * )
+ *
+ * const App = () => {
+ *   return <Button as="a" href="/" variant="primary">Home</Button>
+ * }
+ * ```
+ *
+ * **Advanced Usage**
+ *
+ * This use-case leverages as many features of `createPolymorph` as possible in
+ * an effort to showcase deeper capabilities. Leverages `Button` from
+ * "**Simple Usage**".
+ *
+ * @example
+ * ```tsx
+ * type DefaultTag = typeof Button;
+ *
+ * type AdvancedButtonProps = {
+ *   loading?: boolean;
+ *   size: 'small' | 'medium' | 'large';
+ * }
+ *
+ * type AdvancedButtonConfig = PolymorphicConfig<DefaultTag, {
+ *   // Set as required and change type
+ *   children: string | number;
+ *   // Set as required and inherit type from `T`
+ *   onClick: Inherit;
+ *   // Change type
+ *   title?: number;
+ *   // Remove property
+ *   type: Unset;
+ *   // If `as` is set to an element containing `href`, require it.
+ *   href: Inherit
+ * }>
+ *
+ * const AdvancedButton = createPolymorph<
+ *   DefaultTag,
+ *   AdvancedButtonProps,
+ *   AdvancedButtonConfig
+ * >(
+ *   ({ as: Tag = Button, loading, size, ...rest }) => {
+ *     const sizeClass = (() => {
+ *       if (size === 'small') return 'h-8';
+ *       if (size === 'medium') return 'h-10';
+ *       if (size === 'large') return 'h-12';
+ *       return '';
+ *     }())
+ *
+ *     return (
+ *       <Tag
+ *         className={`${className} ${sizeClass}`}
+ *         aria-loading={loading}
+ *         {...rest}
+ *       />
+ *     )
+ *   }
+ * )
+ *
+ * const App = () => {
+ *   return (
+ *     <AdvancedButton
+ *       as="a"
+ *       href="/"
+ *       variant="primary"
+ *       size="large"
+ *       loading={true}
+ *       title={24}
+ *       onClick={() => console.log('clicked')}
+ *     >
+ *       Home
+ *     </AdvancedButton>
+ *   )
+ * }
+ * ```
+ */
+export declare const createPolymorph: CreatePolymorph;
+export {};
+//# sourceMappingURL=createPolymorph.d.ts.map

package/dist/createPolymorph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPolymorph.d.ts","sourceRoot":"","sources":["../src/createPolymorph.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './createPolymorph';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,37 @@
+// src/createPolymorph.ts
+import { version } from "react";
+var __DEV__ = process.env.NODE_ENV !== "production";
+function assert(condition, message, errorType) {
+  if (condition) return;
+  throw new (errorType || Error)(message);
+}
+if (__DEV__) {
+  assert(
+    parseInt(version.split(".")[0], 10) >= 19,
+    "createPolymorph requires React >= 19. Please upgrade your React version."
+  );
+}
+var createPolymorph = ((render) => {
+  const cache = /* @__PURE__ */ new WeakMap();
+  const _render = (props) => {
+    const { as, root, ...rest } = props;
+    let _as = as;
+    if (typeof as === "function" && root) {
+      const map = cache.get(as) ?? /* @__PURE__ */ new Map();
+      cache.set(as, map);
+      if (!map.has(root)) {
+        const adapter = (props2) => as({ ...props2, as: root });
+        if ("displayName" in as) adapter.displayName = as.displayName;
+        map.set(root, adapter);
+      }
+      _as = map.get(root) ?? as;
+    }
+    return render({ ...rest, as: _as });
+  };
+  _render.displayName = render.displayName || render.name || "PolymorphicComponent";
+  return _render;
+});
+export {
+  createPolymorph
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/createPolymorph.ts"],"sourcesContent":["/** biome-ignore-all lint/suspicious/noExplicitAny: -- */\n/** biome-ignore-all lint/complexity/noBannedTypes: -- */\n\nimport type {\n\tComponentProps,\n\tComponentRef,\n\tExoticComponent,\n\tFragmentProps,\n\tFunctionComponent,\n\tJSX,\n\tReactElement,\n\tReactPortal,\n\tRef\n} from 'react';\nimport { version } from 'react';\n\n// Version Check  -------------------------------------------------------------\n\nconst __DEV__ = process.env.NODE_ENV !== 'production';\n\n/**\n * Asserts that a condition is true, throwing an error if it is not.\n * @param condition The condition to assert.\n * @param message The error message to throw if the assertion fails.\n * @param errorType Error type to throw if assertion fails. Defaults to `Error`.\n */\nfunction assert(\n\tcondition: unknown,\n\tmessage: string,\n\terrorType?: ErrorConstructor\n): asserts condition {\n\tif (condition) return;\n\tthrow new (errorType || Error)(message);\n}\n\nif (__DEV__) {\n\tassert(\n\t\tparseInt(version.split('.')[0], 10) >= 19,\n\t\t'createPolymorph requires React >= 19. Please upgrade your React version.'\n\t);\n}\n\n// Utilities ------------------------------------------------------------------\n\n/**\n * Performs a distributive omit on a union type.\n * @see https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types\n */\ntype DistributiveOmit<T, K extends PropertyKey> = T extends any\n\t? Omit<T, K>\n\t: never;\n\n/** Helper to check if a type is exactly `any` */\ntype IsAny<T> = 0 extends 1 & T ? true : false;\n\n/** Extracts all properties from `R` which are set to `Unset` type. */\ntype ExtractUnset<R> = {\n\t[K in keyof R as IsAny<R[K]> extends true\n\t\t? never\n\t\t: R[K] extends Unset\n\t\t\t? K\n\t\t\t: never]: R[K];\n};\n\n/** Check if a key in an object type has the optional modifier (?) */\ntype IsOptionalKey<T, K extends keyof T> = {} extends Pick<T, K> ? true : false;\n\n/** Merges `T` and `Y`, overwriting properties in `T` with those in `Y` */\ntype Overwrite<T, Y> = DistributiveOmit<T, keyof Y> & Y;\n\n/** Extracts all keys in obj `T` whom are required as a string union. */\ntype RequiredKeys<T> = {\n\t[K in keyof T]-?: {} extends Pick<T, K> ? never : K;\n}[keyof T];\n\n/** Sets all keys in `K` of type `T` to required. */\ntype Require<T, K extends PropertyKey> = Overwrite<\n\tT,\n\tRequired<Pick<T, K extends keyof T ? K : never>>\n>;\n\n// Tag ------------------------------------------------------------------------\n\n/**\n * All valid HTML & SVG elements in string format (`\"div\"`, `\"svg\"`, `\"input\"`)\n */\ntype ElementType = keyof JSX.IntrinsicElements;\n\n/** A React Fragment component. */\ntype FragmentType = ExoticComponent<FragmentProps>;\n\n/**\n * Valid candidates to fulfill the `root` prop when `as` is a\n * `FunctionComponent` derivative. This may be:\n * - A string representing a valid HTML or SVG element\n * - A React Fragment component\n */\ntype RootType = FragmentType | ElementType | '';\n\n/**\n * Valid candidates to fulfill the `as` prop. This may be:\n * - A string representing a valid HTML or SVG element\n * - A React FunctionComponent\n */\ntype PolymorphicElementType<P = any> = ElementType | FunctionComponent<P>;\n\n/**\n * Required return type of `createPolymorph`; a slightly more restrictive\n * version of `ReactNode`.\n */\ntype PolymorphicElement<T extends PolymorphicElementType> =\n\t| ReactElement<T>\n\t| ReactPortal\n\t| null;\n\n/** A generic props object. */\ntype Props = Record<PropertyKey, unknown>;\n\n/**\n * Infers the element type of `PolymorphicExoticComponent`, falling back to `T`\n * if `TT` it is not a `PolymorphicExoticComponent`. In essence, if `as` prop\n * is not specified, the element type will be `T`.\n */\ntype ElementOf<TT, T> =\n\tTT extends PolymorphicExoticComponent<infer E, any, any>\n\t\t? E\n\t\t: TT extends PolymorphicElementType\n\t\t\t? TT\n\t\t\t: T;\n\n/**\n * Used in `PolymorphicExoticComponent` to determine fallback of `TT`.\n * Attempts to extract a `PolymorphicElementType` from props of P, if present,\n * otherwise falls back to `T`.\n */\ntype AsProp<\n\tT extends PolymorphicElementType,\n\tP extends Props\n> = 'as' extends keyof P\n\t? P['as'] extends PolymorphicElementType\n\t\t? P['as']\n\t\t: T\n\t: T;\n\n/**\n * Used in `PolymorphicProps` to determine `ref` property value of `T` if it is\n * a valid `PolymorphicElementType`, otherwise returns an empty object. This is\n * used to ensure that `ref` prop is only available for valid element types.\n */\ntype RefOf<T extends PolymorphicElementType> =\n\tComponentRef<T> extends never ? {} : { ref?: Ref<ComponentRef<T>> };\n\n/**\n * Used in `PolymorphicProps` to determine `as` property value of `P['as']` if\n * it is a valid `PolymorphicElementType`, otherwise returns `T`. Respects\n * property optionality.\n */\ntype AsOf<\n\tT extends PolymorphicElementType,\n\tP extends Props\n> = 'as' extends keyof P\n\t? P['as'] extends PolymorphicElementType\n\t\t? IsOptionalKey<P, 'as'> extends true\n\t\t\t? { as?: P['as'] }\n\t\t\t: { as: P['as'] }\n\t\t: { as?: T }\n\t: { as?: T };\n\n// Props ----------------------------------------------------------------------\n\n/**\n * Base props of a component created using `createPolymorph` function,\n * available during implementation.\n *\n * @property as - The element type to render.\n * @property ref - The ref to the underlying element.\n */\ntype PolymorphicProps<T extends PolymorphicElementType, P extends Props> = AsOf<\n\tT,\n\tP\n> &\n\tRefOf<T>;\n\n/**\n * Base props of a component created using `createPolymorph` function,\n * available during rendering.\n *\n * @property as - Element type to render.\n * @property root - Root element type to render when `as` is a `FunctionComponent`.\n * @property ref - Ref of the underlying element.\n */\ntype PolymorphicExoticProps<\n\tT extends PolymorphicElementType,\n\tR extends RootType\n> = {\n\tas?: T | PolymorphicElementType | PolymorphicExoticComponent<any, any, any>;\n\troot?: FragmentType | Exclude<R | ElementType, ''>;\n} & RefOf<R extends '' ? T : R>;\n\n/**\n * Composite props of a component created using `createPolymorph` function,\n * available during implementation. Combines props `P` with inherited element\n * props `T`, modified using `Config` type `C`.\n *\n * @property as - Element type to render.\n * @property ref - Ref of underlying element.\n */\ntype PolymorphicComponentProps<\n\tT extends PolymorphicElementType,\n\tP extends Props,\n\tC extends Config<T>\n> = Overwrite<\n\tOverwrite<ApplyConfig<T, C>, Omit<P, 'as'>>,\n\tPolymorphicProps<T, P>\n>;\n\n/**\n * Composite props of a component created using `createPolymorph` function,\n * available during rendering. Comines props `P` with inherited element props\n * `T`, modified using `Config` type `C`.\n *\n * @property as - Element type to render.\n * @property root - Root element type to render when `as` is a `FunctionComponent`.\n * @property ref - Ref of underlying element.\n */\ntype PolymorphicExoticComponentProps<\n\tT extends PolymorphicElementType,\n\tP extends Props,\n\tC extends Config<T>,\n\tR extends RootType\n> = Overwrite<\n\tOverwrite<ApplyConfig<R extends '' ? T : R, C>, P>,\n\tPolymorphicExoticProps<T, R>\n>;\n\n/**\n * Component render function passed into `createPolymorph` during\n * initialization as first argument.\n *\n * @param props - Props passed to component.\n * @returns React element to render.\n */\ntype PolymorphicRenderFunction<\n\tT extends PolymorphicElementType,\n\tP extends Props,\n\tC extends Config<T>\n> = {\n\t(props: PolymorphicComponentProps<T, P, C>): PolymorphicElement<T>;\n\tdisplayName?: string;\n};\n\n/**\n * A component created using `createPolymorph` function, which can render\n * different element types based on the `as` prop.\n *\n * When `props` are passed with a modified `as` prop from the default `T`,\n * props will be inferred from the new externally set `as` value; changing\n * inferred props from `T` to `TT` element type.\n *\n * If, in addition to a modified external `as` (`TT`), a `root` prop is also\n * set; the `root` prop will be used to determine the final element type to render,\n * and props will be inferred from the `root` element type instead of the `as`\n * element type.\n *\n * @param props - Props passed to component; including `as` and `root` props.\n * @returns React element to render.\n */\ntype PolymorphicExoticComponent<\n\tT extends PolymorphicElementType,\n\tP extends Props,\n\tC extends Config<T>\n> = {\n\t<TT = AsProp<T, P>, R extends RootType = ''>(\n\t\tprops: TT extends T\n\t\t\t? PolymorphicComponentProps<T, P, C>\n\t\t\t: TT extends PolymorphicExoticComponent<any, any, any>\n\t\t\t\t? PolymorphicExoticComponentProps<\n\t\t\t\t\t\tElementOf<TT, T>,\n\t\t\t\t\t\tOverwrite<P, InferPolymorphProps<TT>>,\n\t\t\t\t\t\tOverwrite<C, InferPolymorphConfig<TT>>,\n\t\t\t\t\t\tR\n\t\t\t\t\t>\n\t\t\t\t: PolymorphicComponentProps<\n\t\t\t\t\t\tElementOf<TT, T>,\n\t\t\t\t\t\tOverwrite<P, InferPolymorphProps<TT>>,\n\t\t\t\t\t\tOverwrite<C, InferPolymorphConfig<TT>>\n\t\t\t\t\t>\n\t): PolymorphicElement<ElementOf<TT, T>>;\n\tdisplayName?: string;\n};\n\n// Config ---------------------------------------------------------------------\n\n/** A generic config object. */\ntype Config<T extends PolymorphicElementType> = {\n\t[K in keyof ComponentProps<T> | (string & {})]?: unknown;\n};\n\ntype ResolveInherit<CK, PK> = [Extract<CK, Inherit>] extends [never]\n\t? CK\n\t: [Exclude<CK, Inherit>] extends [never]\n\t\t? PK\n\t\t: Exclude<CK, Inherit> | PK;\n\ntype ApplyValues<\n\tP,\n\tC,\n\tPS = Omit<P, keyof (ExtractUnset<C> & JSX.IntrinsicAttributes)>\n> = {\n\t[K in keyof PS]: K extends keyof C ? ResolveInherit<C[K], PS[K]> : PS[K];\n};\n\ntype ApplyConfig<\n\tT extends PolymorphicElementType,\n\tC extends Config<T>\n> = Require<ApplyValues<ComponentProps<T & {}>, C>, RequiredKeys<C>>;\n\n// Helpers --------------------------------------------------------------------\n\n/**\n * A branded type used in `Config` to indicate that a prop should be removed\n * from inferred props of `as`.\n */\nexport type Unset = { readonly _unset: unique symbol };\n\n/**\n * A branded type used in `Config` to indicate that a prop should be inherited\n * from inferred props of `as`.\n */\nexport type Inherit = { readonly _inherit: unique symbol };\n\n/**\n * A code-hinting friendly `Config` creator for `createPolymorph`, displaying\n * all available props for the given `as` element type. This type-helper is\n * not required to create a valid `Config` type, but is useful for code-hinting\n * and auto-completion in IDEs.\n *\n * @example ```tsx\n * type Config = PolymorphicConfig<'button', {\n *   title: string | number;\n *   onClick: Inherit\n *   type: Unset\n * }>\n *\n * const Component = createPolymorph<'button', Props, Config>(...);\n */\nexport type PolymorphicConfig<\n\tT extends PolymorphicElementType,\n\tC extends Config<T>\n> = C & { readonly _tag?: T };\n\n/**\n * Infers the `as` prop type from a `PolymorphicExoticComponent`.\n *\n * @example ```tsx\n * const Component = createPolymorph<'div', Props, Config>(...);\n * type Result = InferPolymorphElement<typeof Component>; // 'div'\n * ```\n */\nexport type InferPolymorphElement<T> =\n\tT extends PolymorphicExoticComponent<infer Tag, any, any> ? Tag : unknown;\n\n/**\n * Infers the props type from a `PolymorphicExoticComponent`.\n *\n * @example ```tsx\n * const Component = createPolymorph<'div', Props, Config>(...);\n * type Result = InferPolymorphProps<typeof Component>; // Props\n * ```\n */\nexport type InferPolymorphProps<T> =\n\tT extends PolymorphicExoticComponent<any, infer P, any> ? P : {};\n\n/**\n * Infers the config type from a `PolymorphicExoticComponent`.\n *\n * @example ```tsx\n * const Component = createPolymorph<'div', Props, Config>(...);\n * type Result = InferPolymorphConfig<typeof Component>; // Config\n * ```\n */\nexport type InferPolymorphConfig<T> =\n\tT extends PolymorphicExoticComponent<any, any, infer C> ? C : {};\n\n// Implementation -------------------------------------------------------------\n\ntype CreatePolymorph = <\n\tT extends PolymorphicElementType,\n\tP extends Props = {},\n\tC extends PolymorphicConfig<T, Config<T>> = {}\n>(\n\trender: NoInfer<PolymorphicRenderFunction<T, P, C>>\n) => NoInfer<PolymorphicExoticComponent<T, P, C>>;\n\n/**\n * **Creates a polymorphic component.**\n * This combines user-provided props `P`, inherited props from `T`, and any\n * optional modifications to `T` specified in `C`.\n *\n * In addition to inherited and user-provided props; exposes following props:\n * - `as`: Specifies the element type to render to DOM.\n * - `root`: When `as` is set to another `createPolymorph` created component,\n * `root` overrides the internal `as` prop of the component being rendered,\n * allowing for a different element type to be rendered.\n *\n * @param render - Render function of `PolymorphicExoticComponent`.\n *\n * @returns `PolymorphicExoticComponent`\n *\n * ---\n * **Simple Usage**\n *\n * This is the most common use-case for `createPolymorph`, where a component is\n * created with a default element type `T` and basic props `P`.\n *\n * @example\n * ```tsx\n * type DefaultTag = 'button'\n *\n * type ButtonProps = {\n *   variant: 'primary' | 'secondary';\n * }\n *\n * const Button = createPolymorph<DefaultTag, ButtonProps>(\n *   ({ as: Tag = 'button', variant, ...rest }) => {\n *     const isPrimary = variant === 'primary'\n *     return <Tag className={isPrimary ? 'bg-black' : 'bg-gray'} {...rest} />\n *   }\n * )\n *\n * const App = () => {\n *   return <Button as=\"a\" href=\"/\" variant=\"primary\">Home</Button>\n * }\n * ```\n *\n * **Advanced Usage**\n *\n * This use-case leverages as many features of `createPolymorph` as possible in\n * an effort to showcase deeper capabilities. Leverages `Button` from\n * \"**Simple Usage**\".\n *\n * @example\n * ```tsx\n * type DefaultTag = typeof Button;\n *\n * type AdvancedButtonProps = {\n *   loading?: boolean;\n *   size: 'small' | 'medium' | 'large';\n * }\n *\n * type AdvancedButtonConfig = PolymorphicConfig<DefaultTag, {\n *   // Set as required and change type\n *   children: string | number;\n *   // Set as required and inherit type from `T`\n *   onClick: Inherit;\n *   // Change type\n *   title?: number;\n *   // Remove property\n *   type: Unset;\n *   // If `as` is set to an element containing `href`, require it.\n *   href: Inherit\n * }>\n *\n * const AdvancedButton = createPolymorph<\n *   DefaultTag,\n *   AdvancedButtonProps,\n *   AdvancedButtonConfig\n * >(\n *   ({ as: Tag = Button, loading, size, ...rest }) => {\n *     const sizeClass = (() => {\n *       if (size === 'small') return 'h-8';\n *       if (size === 'medium') return 'h-10';\n *       if (size === 'large') return 'h-12';\n *       return '';\n *     }())\n *\n *     return (\n *       <Tag\n *         className={`${className} ${sizeClass}`}\n *         aria-loading={loading}\n *         {...rest}\n *       />\n *     )\n *   }\n * )\n *\n * const App = () => {\n *   return (\n *     <AdvancedButton\n *       as=\"a\"\n *       href=\"/\"\n *       variant=\"primary\"\n *       size=\"large\"\n *       loading={true}\n *       title={24}\n *       onClick={() => console.log('clicked')}\n *     >\n *       Home\n *     </AdvancedButton>\n *   )\n * }\n * ```\n */\nexport const createPolymorph = (<\n\tT extends PolymorphicElementType,\n\tP extends Props = {},\n\tC extends PolymorphicConfig<T, Config<T>> = {}\n>(\n\trender: NoInfer<PolymorphicRenderFunction<T, P, C>>\n): NoInfer<PolymorphicExoticComponent<T, P, C>> => {\n\ttype AdapterFunction = {\n\t\t(props: Props): ReturnType<FunctionComponent>;\n\t\tdisplayName?: string;\n\t};\n\n\tconst cache = new WeakMap<\n\t\tFunction,\n\t\tMap<ElementType | FragmentType, AdapterFunction>\n\t>();\n\n\tconst _render = (\n\t\tprops: PolymorphicComponentProps<T, P, C> & {\n\t\t\troot?: FragmentType | ElementType;\n\t\t}\n\t) => {\n\t\tconst { as, root, ...rest } = props;\n\n\t\tlet _as = as;\n\n\t\tif (typeof as === 'function' && root) {\n\t\t\tconst map = cache.get(as) ?? new Map();\n\t\t\tcache.set(as, map);\n\n\t\t\tif (!map.has(root)) {\n\t\t\t\tconst adapter: AdapterFunction = (props) => as({ ...props, as: root });\n\n\t\t\t\tif ('displayName' in as) adapter.displayName = as.displayName;\n\t\t\t\tmap.set(root, adapter);\n\t\t\t}\n\n\t\t\t_as = map.get(root) ?? as;\n\t\t}\n\n\t\treturn render({ ...rest, as: _as } as PolymorphicComponentProps<T, P, C>);\n\t};\n\n\t_render.displayName =\n\t\trender.displayName || render.name || 'PolymorphicComponent';\n\n\treturn _render as PolymorphicExoticComponent<T, P, C>;\n}) as CreatePolymorph;\n"],"mappings":";AAcA,SAAS,eAAe;AAIxB,IAAM,UAAU,QAAQ,IAAI,aAAa;AAQzC,SAAS,OACR,WACA,SACA,WACoB;AACpB,MAAI,UAAW;AACf,QAAM,KAAK,aAAa,OAAO,OAAO;AACvC;AAEA,IAAI,SAAS;AACZ;AAAA,IACC,SAAS,QAAQ,MAAM,GAAG,EAAE,CAAC,GAAG,EAAE,KAAK;AAAA,IACvC;AAAA,EACD;AACD;AA+cO,IAAM,mBAAmB,CAK/B,WACkD;AAMlD,QAAM,QAAQ,oBAAI,QAGhB;AAEF,QAAM,UAAU,CACf,UAGI;AACJ,UAAM,EAAE,IAAI,MAAM,GAAG,KAAK,IAAI;AAE9B,QAAI,MAAM;AAEV,QAAI,OAAO,OAAO,cAAc,MAAM;AACrC,YAAM,MAAM,MAAM,IAAI,EAAE,KAAK,oBAAI,IAAI;AACrC,YAAM,IAAI,IAAI,GAAG;AAEjB,UAAI,CAAC,IAAI,IAAI,IAAI,GAAG;AACnB,cAAM,UAA2B,CAACA,WAAU,GAAG,EAAE,GAAGA,QAAO,IAAI,KAAK,CAAC;AAErE,YAAI,iBAAiB,GAAI,SAAQ,cAAc,GAAG;AAClD,YAAI,IAAI,MAAM,OAAO;AAAA,MACtB;AAEA,YAAM,IAAI,IAAI,IAAI,KAAK;AAAA,IACxB;AAEA,WAAO,OAAO,EAAE,GAAG,MAAM,IAAI,IAAI,CAAuC;AAAA,EACzE;AAEA,UAAQ,cACP,OAAO,eAAe,OAAO,QAAQ;AAEtC,SAAO;AACR;","names":["props"]}

package/package.json

@@ -0,0 +1,83 @@
+{
+	"name": "react-polymorphic",
+	"version": "1.0.0",
+	"description": "Create polymorphic React 19+ components with strong TypeScript inference.",
+	"keywords": [
+		"react",
+		"typescript",
+		"polymorphic",
+		"component-library",
+		"design-system",
+		"as-prop",
+		"headless-ui",
+		"ui"
+	],
+	"author": "Dashice",
+	"license": "Apache-2.0",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Dashice/react-polymorphic.git"
+	},
+	"homepage": "https://github.com/Dashice/react-polymorphic#readme",
+	"bugs": {
+		"url": "https://github.com/Dashice/react-polymorphic/issues"
+	},
+	"type": "module",
+	"types": "dist/index.d.ts",
+	"files": [
+		"dist",
+		"README.md",
+		"LICENSE",
+		"NOTICE"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"packageManager": "pnpm@10.20.0",
+	"engines": {
+		"node": ">=22.0.0"
+	},
+	"scripts": {
+		"clean": "rm -rf dist",
+		"build": "pnpm clean && tsup && tsc -p tsconfig.build.json",
+		"prepack": "pnpm build",
+		"format": "biome format . --write",
+		"format:check": "biome format .",
+		"lint": "biome lint .",
+		"lint:fix": "biome lint . --write",
+		"check": "biome check . --write",
+		"test": "vitest",
+		"test:run": "vitest run",
+		"typecheck": "tsc -p tsconfig.json",
+		"lint:staged": "lint-staged",
+		"changeset": "changeset",
+		"version:packages": "changeset version",
+		"release": "changeset publish",
+		"prepare": "husky"
+	},
+	"dependencies": {},
+	"devDependencies": {
+		"@biomejs/biome": "^2.4.16",
+		"@changesets/cli": "^2.31.1",
+		"@testing-library/dom": "^10.4.1",
+		"@testing-library/react": "^16.3.2",
+		"@types/node": "^24.0.0",
+		"@types/react": "^19.2.15",
+		"happy-dom": "^20.9.0",
+		"husky": "^9.1.7",
+		"lint-staged": "^17.2.0",
+		"react": "^19.2.7",
+		"react-dom": "^19.2.7",
+		"tsup": "^8.5.1",
+		"typescript": "^7.0.2",
+		"vitest": "^2.1.9"
+	},
+	"peerDependencies": {
+		"react": ">=19.0.0",
+		"react-dom": ">=19.0.0",
+		"typescript": ">=5.4.0"
+	}
+}