cva 1.0.0-beta.7 → 1.0.0-beta.9

package/LICENSE

@@ -175,7 +175,7 @@
 
    END OF TERMS AND CONDITIONS
 
-   Copyright 2022 Joe Bell
+   Copyright 2022-present Joe Bell
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/dist/config.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_core = require("./core-iwLcNxRW.cjs");
+exports.defineConfig = require_core.defineConfig;

package/dist/config.d.cts

@@ -0,0 +1,2 @@
+import { _ as VariantProps, a as CVAVariantShape, c as CXOptions, d as ClassDictionary, f as ClassValue, h as DefineConfigOptions, i as CVAComponentShape, l as CXReturn, m as DefineConfig, n as CVA, o as CX, p as Compose, r as CVAComponent, s as CXInput, t as AnyCX, u as ClassArray, v as defineConfig } from "./core-BMF1ydiV.cjs";
+export { type AnyCX, type CVA, type CVAComponent, type CVAComponentShape, type CVAVariantShape, type CX, type CXInput, type CXOptions, type CXReturn, type ClassArray, type ClassDictionary, type ClassValue, type Compose, type DefineConfig, type DefineConfigOptions, type VariantProps, defineConfig };

package/dist/config.d.mts

@@ -0,0 +1,2 @@
+import { _ as VariantProps, a as CVAVariantShape, c as CXOptions, d as ClassDictionary, f as ClassValue, h as DefineConfigOptions, i as CVAComponentShape, l as CXReturn, m as DefineConfig, n as CVA, o as CX, p as Compose, r as CVAComponent, s as CXInput, t as AnyCX, u as ClassArray, v as defineConfig } from "./core-BMF1ydiV.mjs";
+export { type AnyCX, type CVA, type CVAComponent, type CVAComponentShape, type CVAVariantShape, type CX, type CXInput, type CXOptions, type CXReturn, type ClassArray, type ClassDictionary, type ClassValue, type Compose, type DefineConfig, type DefineConfigOptions, type VariantProps, defineConfig };

package/dist/config.mjs

@@ -0,0 +1,2 @@
+import { t as defineConfig } from "./core-DPc9m0ph.mjs";
+export { defineConfig };

package/dist/core-BMF1ydiV.d.cts

@@ -0,0 +1,188 @@
+//#region src/core.d.ts
+/**
+ * Copyright 2022-present Joe Bell. All rights reserved.
+ *
+ * This file is licensed to you 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 REPRESENTATIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+type ClassValue = ClassArray | ClassDictionary | string | number | bigint | null | boolean | undefined;
+type ClassDictionary = Record<string, any>;
+type ClassArray = ClassValue[];
+/**
+ * Any function usable as a `cx` concatenator.
+ */
+type AnyCX = (...inputs: any[]) => string;
+type CXInputs<TCX extends AnyCX> = TCX extends ((...inputs: readonly [...infer Inputs]) => string) ? Inputs : never;
+type CXInputElement<TCX extends AnyCX> = CXInputs<TCX>[number];
+type CXHasSafeArity<TCX extends AnyCX> = CXInputs<TCX> extends (infer Inputs) ? Inputs extends readonly unknown[] ? Inputs extends [] ? true : [] extends Inputs ? number extends Inputs["length"] ? true : false : false : false : false;
+type CXConstraint<TCX extends AnyCX> = false extends CXHasSafeArity<TCX> ? "cva's cx must accept zero arguments and an unbounded rest parameter." : [TCX] extends [(...inputs: (string | CXInput<TCX>)[]) => string] ? unknown : "cva's cx must accept its inferred class values and composed strings.";
+/**
+ * The class value type a concatenator accepts, inferred from its
+ * parameters — `defineConfig` uses this to type the authoring surface
+ * (`base`, variant values, `class`/`className`) against the configured
+ * concatenator's own input grammar.
+ */
+type CXInput<TCX extends AnyCX> = CXInputElement<TCX> extends (infer P) ? 0 extends 1 & P ? ClassValue : [P] extends [never] ? ClassValue : [P] extends [ClassValue] ? P : [Extract<P, ClassValue>] extends [never] ? ClassValue : Extract<P, ClassValue> : ClassValue;
+type OmitUndefined<T> = T extends undefined ? never : T;
+type Uninferred<T> = [T][T extends any ? 0 : never];
+type StringToBoolean<T> = T extends "true" | "false" ? boolean : T;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type ComposedTuple<S extends CVAComponentShape | undefined, L extends readonly CVAComponentShape[]> = [S] extends [CVAComponentShape] ? [S] : L;
+type MergedVariants<T extends readonly unknown[]> = UnionToIntersection<{ [K in keyof T]: T[K] extends {
+  config: {
+    variants?: infer V extends CVAVariantShape;
+  };
+} ? V : never; }[number]>;
+type RightMerge<A, B> = { [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never; };
+type DefaultsOf<Component> = Component extends {
+  config: {
+    defaultVariants?: infer D;
+  };
+} ? D extends undefined ? {} : D : {};
+type MergedDefaultVariants<T extends readonly unknown[]> = T extends readonly [infer Head, ...infer Rest] ? RightMerge<DefaultsOf<Head>, MergedDefaultVariants<Rest>> : {};
+type ComponentProps<Component extends (...args: any) => any> = Omit<OmitUndefined<Parameters<Component>[0]>, "class" | "className">;
+type InternalVariantKey = `_${string}`;
+type VariantProps<Component extends (...args: any) => any> = Omit<ComponentProps<Component>, InternalVariantKey>;
+/**
+ * @deprecated Use the `composes` property inside `cva` instead.
+ * @example
+ * // Before
+ * const card = compose(box, stack)
+ * // After
+ * const card = cva({ composes: [box, stack] })
+ */
+interface Compose<T extends ClassValue = ClassValue> {
+  <Components extends readonly unknown[]>(...components: Components & (Components[number] extends CVAComponentShape ? unknown : never)): (props?: (UnionToIntersection<{ [K in keyof Components]: Components[K] extends CVAComponentShape ? ComponentProps<Components[K]> : never; }[number]> | undefined) & CVAClassProp<T>) => string;
+}
+interface CX<T extends ClassValue = ClassValue> {
+  (...inputs: T[]): string;
+}
+type CXOptions = Parameters<CX>;
+type CXReturn = ReturnType<CX>;
+type CVAComponentConfigBase<T extends ClassValue = ClassValue> = {
+  base?: T;
+};
+/**
+ * Exported so TypeScript can name this type in your generated declarations
+ * (`declaration: true`) — you shouldn't really use it directly.
+ */
+type CVAVariantShape = Record<string, Record<string, ClassValue>>;
+type CVAVariantSchema<V> = { [Variant in keyof V]?: StringToBoolean<keyof V[Variant]> | undefined; };
+type CVAClassProp<T extends ClassValue = ClassValue> = {
+  class?: T;
+  className?: never;
+} | {
+  class?: never;
+  className?: T;
+};
+type InternalOnlyWarning = "cva's generic parameters are restricted to internal use only.";
+type CVAComponentConfig<Config, Variants, ComposedSingle extends CVAComponentShape | undefined = CVAComponentShape | undefined, ComposedList extends readonly CVAComponentShape[] = readonly CVAComponentShape[], T extends ClassValue = ClassValue, Merged = Variants> = Config & {
+  composes?: ComposedSingle | readonly [...ComposedList];
+} & (Variants extends Record<string, Record<string, T>> ? CVAComponentConfigBase<T> & {
+  variants?: Variants;
+} : CVAComponentConfigBase<T> & {
+  variants?: never;
+}) & ([keyof Merged] extends [never] ? {
+  compoundVariants?: never;
+  defaultVariants?: never;
+} : {
+  compoundVariants?: ((CVAVariantSchema<Uninferred<Merged>> | { [Variant in keyof Uninferred<Merged>]?: StringToBoolean<keyof Uninferred<Merged>[Variant]> | StringToBoolean<keyof Uninferred<Merged>[Variant]>[] | undefined; }) & CVAClassProp<T>)[];
+  defaultVariants?: CVAVariantSchema<Uninferred<Merged>>;
+});
+/**
+ * Exported so TypeScript can name this type in your generated declarations
+ * (`declaration: true`) — you shouldn't really use it directly.
+ */
+interface CVAComponent<Config, Variants, T extends ClassValue = ClassValue> {
+  (props?: Variants extends CVAVariantShape ? CVAVariantSchema<Variants> & CVAClassProp<T> : CVAClassProp<T>): string;
+  /** @internal */
+  config: Config;
+}
+/**
+ * Exported so TypeScript can name this type in your generated declarations
+ * (`declaration: true`) — you shouldn't really use it directly.
+ */
+type CVAComponentShape = CVAComponent<any, any, any>;
+type CVADefaultVariants<Config> = Config extends {
+  defaultVariants?: infer D;
+} ? D : {};
+interface CVA<T extends ClassValue = ClassValue> {
+  <_ extends InternalOnlyWarning, Config, Variants, ComposedSingle extends CVAComponentShape | undefined = undefined, ComposedList extends readonly CVAComponentShape[] = []>(config: CVAComponentConfig<Config, Variants, ComposedSingle, ComposedList, T, Variants & MergedVariants<ComposedTuple<ComposedSingle, ComposedList>>>): CVAComponent<Omit<Config, "defaultVariants"> & {
+    variants: Variants & MergedVariants<ComposedTuple<ComposedSingle, ComposedList>>;
+    defaultVariants: Omit<MergedDefaultVariants<ComposedTuple<ComposedSingle, ComposedList>>, keyof CVADefaultVariants<Config>> & CVADefaultVariants<Config>;
+  }, Variants & MergedVariants<ComposedTuple<ComposedSingle, ComposedList>>, T>;
+}
+interface DefineConfigOptions<TCX extends AnyCX = CX> {
+  /**
+   * The class name concatenator used by `cva`, `cx`, and `compose`. It owns
+   * the class name grammar entirely: cva assembles the authored values
+   * (composed component outputs, `base`, matched variant and compound
+   * variant values, `class`/`className`) and passes them through verbatim,
+   * one argument each, without interpreting them.
+   *
+   * The authoring surface adopts the concatenator's own input type
+   * automatically (see {@link CXInput}): pass `twMerge` and your variants
+   * are checked against tailwind-merge's `ClassNameValue`; pass `clsx` (or
+   * any function whose parameters don't narrow further) and you keep the
+   * full clsx-flavored `ClassValue` grammar.
+   */
+  cx: TCX & CXConstraint<TCX>;
+  hooks?: {
+    /**
+     * @deprecated please use the `cx` option instead
+     */
+    "cx:done"?: (className: string) => string;
+    /**
+     * @deprecated please use the `cx` option instead
+     */
+    onComplete?: (className: string) => string;
+  };
+}
+interface DefineConfig {
+  <TCX extends AnyCX>(options: DefineConfigOptions<TCX>): {
+    /**
+     * @deprecated Use the `composes` property inside `cva` instead.
+     * @example
+     * // Before
+     * const card = compose(box, stack)
+     * // After
+     * const card = cva({ composes: [box, stack] })
+     */
+    compose: Compose<CXInput<TCX>>;
+    cx: CX<CXInput<TCX>>;
+    cva: CVA<CXInput<TCX>>;
+  };
+}
+declare const defineConfig: DefineConfig;
+interface GetSchema {
+  <_ extends InternalOnlyWarning, Component, Config, Variants>(component: Component & (Component extends CVAComponentShape ? Component extends {
+    config: {
+      variants: infer V;
+    };
+  } ? unknown extends V ? unknown : {
+    config: CVAComponentConfig<Config, Variants>;
+  } : {
+    config: CVAComponentConfig<Config, Variants>;
+  } : never)): { [Variant in keyof Variants as Variant extends InternalVariantKey ? never : Variant]: Config extends CVAComponentConfig<Config, Variants> ? Variant extends keyof Config["defaultVariants"] ? Config["defaultVariants"][Variant] extends undefined ? never : {
+    values: ReadonlyArray<StringToBoolean<keyof Variants[Variant]>>;
+    defaultValue: Readonly<StringToBoolean<Config["defaultVariants"][Variant]>>;
+  } : {
+    values: ReadonlyArray<StringToBoolean<keyof Variants[Variant]>>;
+  } : never; } extends (infer Schema) ? { [K in keyof Schema as Schema[K] extends {
+    values: readonly never[];
+  } ? never : K]: Schema[K] extends {
+    defaultValue: never;
+  } ? never : Schema[K]; } : never;
+}
+//#endregion
+export { VariantProps as _, CVAVariantShape as a, CXOptions as c, ClassDictionary as d, ClassValue as f, GetSchema as g, DefineConfigOptions as h, CVAComponentShape as i, CXReturn as l, DefineConfig as m, CVA as n, CX as o, Compose as p, CVAComponent as r, CXInput as s, AnyCX as t, ClassArray as u, defineConfig as v };
+//# sourceMappingURL=core-BMF1ydiV.d.cts.map

package/dist/core-BMF1ydiV.d.mts

@@ -0,0 +1,188 @@
+//#region src/core.d.ts
+/**
+ * Copyright 2022-present Joe Bell. All rights reserved.
+ *
+ * This file is licensed to you 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 REPRESENTATIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+type ClassValue = ClassArray | ClassDictionary | string | number | bigint | null | boolean | undefined;
+type ClassDictionary = Record<string, any>;
+type ClassArray = ClassValue[];
+/**
+ * Any function usable as a `cx` concatenator.
+ */
+type AnyCX = (...inputs: any[]) => string;
+type CXInputs<TCX extends AnyCX> = TCX extends ((...inputs: readonly [...infer Inputs]) => string) ? Inputs : never;
+type CXInputElement<TCX extends AnyCX> = CXInputs<TCX>[number];
+type CXHasSafeArity<TCX extends AnyCX> = CXInputs<TCX> extends (infer Inputs) ? Inputs extends readonly unknown[] ? Inputs extends [] ? true : [] extends Inputs ? number extends Inputs["length"] ? true : false : false : false : false;
+type CXConstraint<TCX extends AnyCX> = false extends CXHasSafeArity<TCX> ? "cva's cx must accept zero arguments and an unbounded rest parameter." : [TCX] extends [(...inputs: (string | CXInput<TCX>)[]) => string] ? unknown : "cva's cx must accept its inferred class values and composed strings.";
+/**
+ * The class value type a concatenator accepts, inferred from its
+ * parameters — `defineConfig` uses this to type the authoring surface
+ * (`base`, variant values, `class`/`className`) against the configured
+ * concatenator's own input grammar.
+ */
+type CXInput<TCX extends AnyCX> = CXInputElement<TCX> extends (infer P) ? 0 extends 1 & P ? ClassValue : [P] extends [never] ? ClassValue : [P] extends [ClassValue] ? P : [Extract<P, ClassValue>] extends [never] ? ClassValue : Extract<P, ClassValue> : ClassValue;
+type OmitUndefined<T> = T extends undefined ? never : T;
+type Uninferred<T> = [T][T extends any ? 0 : never];
+type StringToBoolean<T> = T extends "true" | "false" ? boolean : T;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type ComposedTuple<S extends CVAComponentShape | undefined, L extends readonly CVAComponentShape[]> = [S] extends [CVAComponentShape] ? [S] : L;
+type MergedVariants<T extends readonly unknown[]> = UnionToIntersection<{ [K in keyof T]: T[K] extends {
+  config: {
+    variants?: infer V extends CVAVariantShape;
+  };
+} ? V : never; }[number]>;
+type RightMerge<A, B> = { [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never; };
+type DefaultsOf<Component> = Component extends {
+  config: {
+    defaultVariants?: infer D;
+  };
+} ? D extends undefined ? {} : D : {};
+type MergedDefaultVariants<T extends readonly unknown[]> = T extends readonly [infer Head, ...infer Rest] ? RightMerge<DefaultsOf<Head>, MergedDefaultVariants<Rest>> : {};
+type ComponentProps<Component extends (...args: any) => any> = Omit<OmitUndefined<Parameters<Component>[0]>, "class" | "className">;
+type InternalVariantKey = `_${string}`;
+type VariantProps<Component extends (...args: any) => any> = Omit<ComponentProps<Component>, InternalVariantKey>;
+/**
+ * @deprecated Use the `composes` property inside `cva` instead.
+ * @example
+ * // Before
+ * const card = compose(box, stack)
+ * // After
+ * const card = cva({ composes: [box, stack] })
+ */
+interface Compose<T extends ClassValue = ClassValue> {
+  <Components extends readonly unknown[]>(...components: Components & (Components[number] extends CVAComponentShape ? unknown : never)): (props?: (UnionToIntersection<{ [K in keyof Components]: Components[K] extends CVAComponentShape ? ComponentProps<Components[K]> : never; }[number]> | undefined) & CVAClassProp<T>) => string;
+}
+interface CX<T extends ClassValue = ClassValue> {
+  (...inputs: T[]): string;
+}
+type CXOptions = Parameters<CX>;
+type CXReturn = ReturnType<CX>;
+type CVAComponentConfigBase<T extends ClassValue = ClassValue> = {
+  base?: T;
+};
+/**
+ * Exported so TypeScript can name this type in your generated declarations
+ * (`declaration: true`) — you shouldn't really use it directly.
+ */
+type CVAVariantShape = Record<string, Record<string, ClassValue>>;
+type CVAVariantSchema<V> = { [Variant in keyof V]?: StringToBoolean<keyof V[Variant]> | undefined; };
+type CVAClassProp<T extends ClassValue = ClassValue> = {
+  class?: T;
+  className?: never;
+} | {
+  class?: never;
+  className?: T;
+};
+type InternalOnlyWarning = "cva's generic parameters are restricted to internal use only.";
+type CVAComponentConfig<Config, Variants, ComposedSingle extends CVAComponentShape | undefined = CVAComponentShape | undefined, ComposedList extends readonly CVAComponentShape[] = readonly CVAComponentShape[], T extends ClassValue = ClassValue, Merged = Variants> = Config & {
+  composes?: ComposedSingle | readonly [...ComposedList];
+} & (Variants extends Record<string, Record<string, T>> ? CVAComponentConfigBase<T> & {
+  variants?: Variants;
+} : CVAComponentConfigBase<T> & {
+  variants?: never;
+}) & ([keyof Merged] extends [never] ? {
+  compoundVariants?: never;
+  defaultVariants?: never;
+} : {
+  compoundVariants?: ((CVAVariantSchema<Uninferred<Merged>> | { [Variant in keyof Uninferred<Merged>]?: StringToBoolean<keyof Uninferred<Merged>[Variant]> | StringToBoolean<keyof Uninferred<Merged>[Variant]>[] | undefined; }) & CVAClassProp<T>)[];
+  defaultVariants?: CVAVariantSchema<Uninferred<Merged>>;
+});
+/**
+ * Exported so TypeScript can name this type in your generated declarations
+ * (`declaration: true`) — you shouldn't really use it directly.
+ */
+interface CVAComponent<Config, Variants, T extends ClassValue = ClassValue> {
+  (props?: Variants extends CVAVariantShape ? CVAVariantSchema<Variants> & CVAClassProp<T> : CVAClassProp<T>): string;
+  /** @internal */
+  config: Config;
+}
+/**
+ * Exported so TypeScript can name this type in your generated declarations
+ * (`declaration: true`) — you shouldn't really use it directly.
+ */
+type CVAComponentShape = CVAComponent<any, any, any>;
+type CVADefaultVariants<Config> = Config extends {
+  defaultVariants?: infer D;
+} ? D : {};
+interface CVA<T extends ClassValue = ClassValue> {
+  <_ extends InternalOnlyWarning, Config, Variants, ComposedSingle extends CVAComponentShape | undefined = undefined, ComposedList extends readonly CVAComponentShape[] = []>(config: CVAComponentConfig<Config, Variants, ComposedSingle, ComposedList, T, Variants & MergedVariants<ComposedTuple<ComposedSingle, ComposedList>>>): CVAComponent<Omit<Config, "defaultVariants"> & {
+    variants: Variants & MergedVariants<ComposedTuple<ComposedSingle, ComposedList>>;
+    defaultVariants: Omit<MergedDefaultVariants<ComposedTuple<ComposedSingle, ComposedList>>, keyof CVADefaultVariants<Config>> & CVADefaultVariants<Config>;
+  }, Variants & MergedVariants<ComposedTuple<ComposedSingle, ComposedList>>, T>;
+}
+interface DefineConfigOptions<TCX extends AnyCX = CX> {
+  /**
+   * The class name concatenator used by `cva`, `cx`, and `compose`. It owns
+   * the class name grammar entirely: cva assembles the authored values
+   * (composed component outputs, `base`, matched variant and compound
+   * variant values, `class`/`className`) and passes them through verbatim,
+   * one argument each, without interpreting them.
+   *
+   * The authoring surface adopts the concatenator's own input type
+   * automatically (see {@link CXInput}): pass `twMerge` and your variants
+   * are checked against tailwind-merge's `ClassNameValue`; pass `clsx` (or
+   * any function whose parameters don't narrow further) and you keep the
+   * full clsx-flavored `ClassValue` grammar.
+   */
+  cx: TCX & CXConstraint<TCX>;
+  hooks?: {
+    /**
+     * @deprecated please use the `cx` option instead
+     */
+    "cx:done"?: (className: string) => string;
+    /**
+     * @deprecated please use the `cx` option instead
+     */
+    onComplete?: (className: string) => string;
+  };
+}
+interface DefineConfig {
+  <TCX extends AnyCX>(options: DefineConfigOptions<TCX>): {
+    /**
+     * @deprecated Use the `composes` property inside `cva` instead.
+     * @example
+     * // Before
+     * const card = compose(box, stack)
+     * // After
+     * const card = cva({ composes: [box, stack] })
+     */
+    compose: Compose<CXInput<TCX>>;
+    cx: CX<CXInput<TCX>>;
+    cva: CVA<CXInput<TCX>>;
+  };
+}
+declare const defineConfig: DefineConfig;
+interface GetSchema {
+  <_ extends InternalOnlyWarning, Component, Config, Variants>(component: Component & (Component extends CVAComponentShape ? Component extends {
+    config: {
+      variants: infer V;
+    };
+  } ? unknown extends V ? unknown : {
+    config: CVAComponentConfig<Config, Variants>;
+  } : {
+    config: CVAComponentConfig<Config, Variants>;
+  } : never)): { [Variant in keyof Variants as Variant extends InternalVariantKey ? never : Variant]: Config extends CVAComponentConfig<Config, Variants> ? Variant extends keyof Config["defaultVariants"] ? Config["defaultVariants"][Variant] extends undefined ? never : {
+    values: ReadonlyArray<StringToBoolean<keyof Variants[Variant]>>;
+    defaultValue: Readonly<StringToBoolean<Config["defaultVariants"][Variant]>>;
+  } : {
+    values: ReadonlyArray<StringToBoolean<keyof Variants[Variant]>>;
+  } : never; } extends (infer Schema) ? { [K in keyof Schema as Schema[K] extends {
+    values: readonly never[];
+  } ? never : K]: Schema[K] extends {
+    defaultValue: never;
+  } ? never : Schema[K]; } : never;
+}
+//#endregion
+export { VariantProps as _, CVAVariantShape as a, CXOptions as c, ClassDictionary as d, ClassValue as f, GetSchema as g, DefineConfigOptions as h, CVAComponentShape as i, CXReturn as l, DefineConfig as m, CVA as n, CX as o, Compose as p, CVAComponent as r, CXInput as s, AnyCX as t, ClassArray as u, defineConfig as v };
+//# sourceMappingURL=core-BMF1ydiV.d.mts.map

package/dist/core-DPc9m0ph.mjs

@@ -0,0 +1,99 @@
+//#region src/core.ts
+const falsyToString = (value) => typeof value === "boolean" ? `${value}` : value === 0 ? "0" : value;
+const emptyClassNames = [];
+const defineConfig = ((options) => {
+	const cx = (...inputs) => {
+		var _options$hooks$cxDon, _options$hooks, _options$hooks2;
+		const className = options.cx(...inputs.filter((input) => input !== void 0));
+		const hook = (_options$hooks$cxDon = (_options$hooks = options.hooks) === null || _options$hooks === void 0 ? void 0 : _options$hooks["cx:done"]) !== null && _options$hooks$cxDon !== void 0 ? _options$hooks$cxDon : (_options$hooks2 = options.hooks) === null || _options$hooks2 === void 0 ? void 0 : _options$hooks2.onComplete;
+		return hook ? hook(className) : className;
+	};
+	const cva = ((config) => {
+		const components = (config === null || config === void 0 ? void 0 : config.composes) == null ? [] : Array.isArray(config.composes) ? config.composes : [config.composes];
+		const mergeVariants = (acc, variants) => {
+			if (!variants) return acc;
+			const merged = { ...acc };
+			for (const key of Object.keys(variants)) merged[key] = {
+				...merged[key],
+				...variants[key]
+			};
+			return merged;
+		};
+		const mergedVariants = mergeVariants(components.reduce((acc, component) => {
+			var _component$config;
+			return mergeVariants(acc, (_component$config = component.config) === null || _component$config === void 0 ? void 0 : _component$config.variants);
+		}, {}), config === null || config === void 0 ? void 0 : config.variants);
+		const mergedDefaultVariants = {
+			...components.reduce((acc, component) => {
+				var _component$config2;
+				return {
+					...acc,
+					...(_component$config2 = component.config) === null || _component$config2 === void 0 ? void 0 : _component$config2.defaultVariants
+				};
+			}, {}),
+			...config === null || config === void 0 ? void 0 : config.defaultVariants
+		};
+		const component = (props) => {
+			var _config$variants, _config$compoundVaria, _config$compoundVaria2;
+			const definedPropsWithoutClass = components.length || (config === null || config === void 0 ? void 0 : config.compoundVariants) ? Object.fromEntries(Object.entries(props || {}).filter(([key, value]) => key !== "class" && key !== "className" && typeof value !== "undefined")) : {};
+			const getComposedClassNames = components.length ? components.map((component) => component({
+				...mergedDefaultVariants,
+				...definedPropsWithoutClass
+			})) : emptyClassNames;
+			if (!(config === null || config === void 0 ? void 0 : config.variants) && !(config === null || config === void 0 ? void 0 : config.compoundVariants)) return getComposedClassNames.length ? cx(...getComposedClassNames, config === null || config === void 0 ? void 0 : config.base, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className) : cx(config === null || config === void 0 ? void 0 : config.base, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
+			const variants = (_config$variants = config.variants) !== null && _config$variants !== void 0 ? _config$variants : {};
+			const getVariantClassNames = Object.keys(variants).map((variant) => {
+				const variantProp = props === null || props === void 0 ? void 0 : props[variant];
+				const defaultVariantProp = mergedDefaultVariants[variant];
+				const variantKey = falsyToString(variantProp) || falsyToString(defaultVariantProp);
+				return variants[variant][variantKey];
+			});
+			const defaultsAndProps = {
+				...mergedDefaultVariants,
+				...definedPropsWithoutClass
+			};
+			const getCompoundVariantClassNames = (_config$compoundVaria = config === null || config === void 0 || (_config$compoundVaria2 = config.compoundVariants) === null || _config$compoundVaria2 === void 0 ? void 0 : _config$compoundVaria2.reduce((acc, { class: cvClass, className: cvClassName, ...cvConfig }) => Object.entries(cvConfig).every(([cvKey, cvSelector]) => {
+				const selector = defaultsAndProps[cvKey];
+				return Array.isArray(cvSelector) ? cvSelector.includes(selector) : selector === cvSelector;
+			}) ? [
+				...acc,
+				cvClass,
+				cvClassName
+			] : acc, [])) !== null && _config$compoundVaria !== void 0 ? _config$compoundVaria : emptyClassNames;
+			return cx(...getComposedClassNames, config === null || config === void 0 ? void 0 : config.base, ...getVariantClassNames, ...getCompoundVariantClassNames, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
+		};
+		component.config = {
+			...config,
+			variants: mergedVariants,
+			defaultVariants: mergedDefaultVariants
+		};
+		return component;
+	});
+	const compose = (...components) => {
+		const composedComponents = components;
+		const config = composedComponents.reduce((acc, { config }) => {
+			Object.entries(config || {}).forEach(([key, value]) => {
+				acc[key] = typeof value === "object" && value !== null && !Array.isArray(value) ? {
+					...acc[key],
+					...value
+				} : value;
+			});
+			return acc;
+		}, {});
+		const component = (props) => {
+			const propsWithoutClass = Object.fromEntries(Object.entries(props || {}).filter(([key]) => !["class", "className"].includes(key)));
+			return cx(...composedComponents.map((component) => component(propsWithoutClass)), props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
+		};
+		component.config = config;
+		return component;
+	};
+	return {
+		compose,
+		cva,
+		cx
+	};
+});
+//#endregion
+export { defineConfig as t };
+
+//# sourceMappingURL=core-DPc9m0ph.mjs.map

package/dist/core-DPc9m0ph.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-DPc9m0ph.mjs","names":[],"sources":["../src/core.ts"],"sourcesContent":["/**\n * Copyright 2022-present Joe Bell. All rights reserved.\n *\n * This file is licensed to you under the Apache License, Version 2.0\n * (the \"License\"); you may not use this file except in compliance with the\n * License. You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR REPRESENTATIONS OF ANY KIND, either express or implied. See the\n * License for the specific language governing permissions and limitations under\n * the License.\n */\n\n/* Types\n  ============================================ */\n\n/* ClassValue\n  ---------------------------------- */\n\n// Mirrors clsx's `ClassValue`; local to keep `core` dependency-free (TS2742).\n\nexport type ClassValue =\n  | ClassArray\n  | ClassDictionary\n  | string\n  | number\n  | bigint\n  | null\n  | boolean\n  | undefined;\nexport type ClassDictionary = Record<string, any>;\nexport type ClassArray = ClassValue[];\n\n/* CXInput\n  ---------------------------------- */\n\n/**\n * Any function usable as a `cx` concatenator.\n */\nexport type AnyCX = (...inputs: any[]) => string;\n\n// Infer directly from a readonly rest pattern instead of `Parameters<T>[number]`:\n// the latter is `never` for zero-argument callbacks and loses readonly rest\n// element types.\ntype CXInputs<TCX extends AnyCX> = TCX extends (\n  ...inputs: readonly [...infer Inputs]\n) => string\n  ? Inputs\n  : never;\ntype CXInputElement<TCX extends AnyCX> = CXInputs<TCX>[number];\n\n// cva may call `cx` with no values, or with any number of authored values and\n// composed component strings. A constant callback is safe; every other\n// callback must accept arbitrary lists of its own grammar plus strings.\ntype CXHasSafeArity<TCX extends AnyCX> =\n  CXInputs<TCX> extends infer Inputs\n    ? Inputs extends readonly unknown[]\n      ? Inputs extends []\n        ? true\n        : [] extends Inputs\n          ? number extends Inputs[\"length\"]\n            ? true\n            : false\n          : false\n      : false\n    : false;\ntype CXConstraint<TCX extends AnyCX> =\n  false extends CXHasSafeArity<TCX>\n    ? \"cva's cx must accept zero arguments and an unbounded rest parameter.\"\n    : [TCX] extends [(...inputs: (string | CXInput<TCX>)[]) => string]\n      ? unknown\n      : \"cva's cx must accept its inferred class values and composed strings.\";\n\n/**\n * The class value type a concatenator accepts, inferred from its\n * parameters — `defineConfig` uses this to type the authoring surface\n * (`base`, variant values, `class`/`className`) against the configured\n * concatenator's own input grammar.\n */\nexport type CXInput<TCX extends AnyCX> =\n  CXInputElement<TCX> extends infer P\n    ? // `0 extends 1 & P` detects `any`; `any`/`never` use `ClassValue`.\n      0 extends 1 & P\n      ? ClassValue\n      : [P] extends [never]\n        ? ClassValue\n        : [P] extends [ClassValue]\n          ? P\n          : // A concatenator accepting more than cva's grammar (e.g. `string |\n            // URL`) narrows to the subset it shares with it, since the surface\n            // can't widen beyond what the concatenator accepts; when nothing is\n            // shared (e.g. `unknown`), the full grammar applies.\n            [Extract<P, ClassValue>] extends [never]\n            ? ClassValue\n            : Extract<P, ClassValue>\n    : ClassValue;\n\n/* Utils\n  ---------------------------------- */\n\ntype OmitUndefined<T> = T extends undefined ? never : T;\n// Blocks inference from a site that merely checks a type parameter.\ntype Uninferred<T> = [T][T extends any ? 0 : never];\ntype StringToBoolean<T> = T extends \"true\" | \"false\" ? boolean : T;\ntype UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (\n  k: infer I,\n) => void\n  ? I\n  : never;\n\n// `composes` accepts either a single component or a list of components. A\n// plain union (`CVAComponentShape | CVAComponentShape[]`) collapses an array\n// literal's element type to a union, silently dropping components whose\n// variants are a structural subtype of another composed component's (e.g.\n// `composes: [a, b]` where `b`'s variants are a superset of `a`'s). Splitting\n// inference across two type parameters preserves the array as a real tuple.\ntype ComposedTuple<\n  S extends CVAComponentShape | undefined,\n  L extends readonly CVAComponentShape[],\n> = [S] extends [CVAComponentShape] ? [S] : L;\n\ntype MergedVariants<T extends readonly unknown[]> = UnionToIntersection<\n  {\n    [K in keyof T]: T[K] extends {\n      config: { variants?: infer V extends CVAVariantShape };\n    }\n      ? V\n      : never;\n  }[number]\n>;\n\n// Right-biased merge (`B`'s keys win on conflicts) implemented as a mapped\n// type rather than `Omit<A, keyof B> & B`: the latter stays an unresolved\n// deferred type when `A`/`B` are themselves generic (as they are here, via\n// `ReturnType<CVA>` with no concrete `Config`), which then breaks downstream\n// `any`-narrowing in unrelated code that consumes `ReturnType<CVA>` (e.g.\n// the deprecated `compose`). A mapped type resolves eagerly instead.\ntype RightMerge<A, B> = {\n  [K in keyof A | keyof B]: K extends keyof B\n    ? B[K]\n    : K extends keyof A\n      ? A[K]\n      : never;\n};\n\n// `D` infers as `undefined` (not absent) when a component declares no\n// `defaultVariants` at all. `NonNullable<undefined>` would give `never`,\n// and `keyof never` is `string | number | symbol` (not `never`) — poisoning\n// `RightMerge`'s key union with every possible key. Normalize to `{}` instead,\n// matching a component that contributes nothing to the merge.\ntype DefaultsOf<Component> = Component extends {\n  config: { defaultVariants?: infer D };\n}\n  ? D extends undefined\n    ? {}\n    : D\n  : {};\n\ntype MergedDefaultVariants<T extends readonly unknown[]> = T extends readonly [\n  infer Head,\n  ...infer Rest,\n]\n  ? RightMerge<DefaultsOf<Head>, MergedDefaultVariants<Rest>>\n  : {};\n\ntype ComponentProps<Component extends (...args: any) => any> = Omit<\n  OmitUndefined<Parameters<Component>[0]>,\n  \"class\" | \"className\"\n>;\n\n// A variant name prefixed with `_` is internal: the component still accepts\n// it, but `VariantProps` and `getSchema` omit it from the public surface.\ntype InternalVariantKey = `_${string}`;\n\nexport type VariantProps<Component extends (...args: any) => any> = Omit<\n  ComponentProps<Component>,\n  InternalVariantKey\n>;\n\n/* compose\n  ---------------------------------- */\n\n/**\n * @deprecated Use the `composes` property inside `cva` instead.\n * @example\n * // Before\n * const card = compose(box, stack)\n * // After\n * const card = cva({ composes: [box, stack] })\n */\nexport interface Compose<T extends ClassValue = ClassValue> {\n  <Components extends readonly unknown[]>(\n    ...components: Components &\n      (Components[number] extends CVAComponentShape ? unknown : never)\n  ): (\n    props?: (\n      | UnionToIntersection<\n          {\n            [K in keyof Components]: Components[K] extends CVAComponentShape\n              ? ComponentProps<Components[K]>\n              : never;\n          }[number]\n        >\n      | undefined\n    ) &\n      CVAClassProp<T>,\n  ) => string;\n}\n\n/* cx\n  ---------------------------------- */\n\nexport interface CX<T extends ClassValue = ClassValue> {\n  (...inputs: T[]): string;\n}\n\nexport type CXOptions = Parameters<CX>;\nexport type CXReturn = ReturnType<CX>;\n\n/* cva\n  ============================================ */\n\ntype CVAComponentConfigBase<T extends ClassValue = ClassValue> = { base?: T };\n/**\n * Exported so TypeScript can name this type in your generated declarations\n * (`declaration: true`) — you shouldn't really use it directly.\n */\nexport type CVAVariantShape = Record<string, Record<string, ClassValue>>;\n// Unconstrained so it can map over the merged (local plus composed)\n// variants, which is only known to be an intersection, not a\n// `CVAVariantShape`.\ntype CVAVariantSchema<V> = {\n  [Variant in keyof V]?: StringToBoolean<keyof V[Variant]> | undefined;\n};\ntype CVAClassProp<T extends ClassValue = ClassValue> =\n  | {\n      class?: T;\n      className?: never;\n    }\n  | {\n      class?: never;\n      className?: T;\n    };\n\ntype InternalOnlyWarning =\n  \"cva's generic parameters are restricted to internal use only.\";\n\ntype CVAComponentConfig<\n  Config,\n  Variants,\n  ComposedSingle extends CVAComponentShape | undefined =\n    | CVAComponentShape\n    | undefined,\n  ComposedList extends readonly CVAComponentShape[] =\n    readonly CVAComponentShape[],\n  T extends ClassValue = ClassValue,\n  // `defaultVariants` and `compoundVariants` are checked against local variants\n  // merged with composed variants. Defaults to local variants for introspection\n  // guards.\n  //\n  // Gate on `keyof Merged` to preserve literal defaults, and wrap in\n  // `Uninferred` to prevent reverse inference from authored values.\n  Merged = Variants,\n> = Config & {\n  composes?: ComposedSingle | readonly [...ComposedList];\n  // The gate checks variant values against the configured concatenator's\n  // input type, so e.g. object syntax fails here (on the `variants` key)\n  // under a concatenator that doesn't accept objects.\n} & (Variants extends Record<string, Record<string, T>>\n    ? CVAComponentConfigBase<T> & { variants?: Variants }\n    : CVAComponentConfigBase<T> & { variants?: never }) &\n  ([keyof Merged] extends [never]\n    ? { compoundVariants?: never; defaultVariants?: never }\n    : {\n        compoundVariants?: ((\n          | CVAVariantSchema<Uninferred<Merged>>\n          | {\n              [Variant in keyof Uninferred<Merged>]?:\n                | StringToBoolean<keyof Uninferred<Merged>[Variant]>\n                | StringToBoolean<keyof Uninferred<Merged>[Variant]>[]\n                | undefined;\n            }\n        ) &\n          CVAClassProp<T>)[];\n        defaultVariants?: CVAVariantSchema<Uninferred<Merged>>;\n      });\n\n/**\n * Exported so TypeScript can name this type in your generated declarations\n * (`declaration: true`) — you shouldn't really use it directly.\n */\nexport interface CVAComponent<\n  Config,\n  Variants,\n  T extends ClassValue = ClassValue,\n> {\n  (\n    props?: Variants extends CVAVariantShape\n      ? CVAVariantSchema<Variants> & CVAClassProp<T>\n      : CVAClassProp<T>,\n  ): string;\n  /** @internal */\n  config: Config;\n}\n\n// The loosest form a composable component can take, constraining `composes`\n// and the composition merge helpers above. Deriving it from `CVAComponent`\n// keeps the two from drifting: instantiated with `any`, the props conditional\n// and `config` both collapse to `any` (mapped types over `any` are `any`),\n// i.e. `{ (props?: any): string; config: any }`. The required `config`\n// property is what rejects plain functions and (deprecated) `compose`\n// results.\n//\n// The `any` arguments are deliberate, not lazy typing — a shaped `config`\n// (e.g. `{ variants?: CVAVariantShape }`) was tried and verifiably breaks:\n// a variant-less `cva({ base })` carries `variants: unknown`, and\n// `ReturnType<CVA>` instantiates this constraint inside the\n// `Compose`/`GetSchema` guards, where the shaped form rejects every real\n// component via props contravariance.\n//\n// Its class-value parameter must be `any`: narrowed components otherwise fail\n// props contravariance in `composes` and `getSchema`.\n/**\n * Exported so TypeScript can name this type in your generated declarations\n * (`declaration: true`) — you shouldn't really use it directly.\n */\nexport type CVAComponentShape = CVAComponent<any, any, any>;\n\ntype CVADefaultVariants<Config> = Config extends { defaultVariants?: infer D }\n  ? D\n  : {};\n\nexport interface CVA<T extends ClassValue = ClassValue> {\n  <\n    _ extends InternalOnlyWarning,\n    Config,\n    Variants,\n    ComposedSingle extends CVAComponentShape | undefined = undefined,\n    ComposedList extends readonly CVAComponentShape[] = [],\n  >(\n    config: CVAComponentConfig<\n      Config,\n      Variants,\n      ComposedSingle,\n      ComposedList,\n      T,\n      Variants & MergedVariants<ComposedTuple<ComposedSingle, ComposedList>>\n    >,\n  ): CVAComponent<\n    Omit<Config, \"defaultVariants\"> & {\n      variants: Variants &\n        MergedVariants<ComposedTuple<ComposedSingle, ComposedList>>;\n      // Local `defaultVariants` win over composed ones on key conflicts,\n      // matching the runtime spread order. A plain intersection would collapse\n      // a conflicting key's value to `never` (e.g. `\"sm\" & \"lg\"`), which then\n      // silently drops the variant from `getSchema`'s inferred type.\n      defaultVariants: Omit<\n        MergedDefaultVariants<ComposedTuple<ComposedSingle, ComposedList>>,\n        keyof CVADefaultVariants<Config>\n      > &\n        CVADefaultVariants<Config>;\n    },\n    Variants & MergedVariants<ComposedTuple<ComposedSingle, ComposedList>>,\n    T\n  >;\n}\n\n/* defineConfig\n  ---------------------------------- */\n\nexport interface DefineConfigOptions<TCX extends AnyCX = CX> {\n  /**\n   * The class name concatenator used by `cva`, `cx`, and `compose`. It owns\n   * the class name grammar entirely: cva assembles the authored values\n   * (composed component outputs, `base`, matched variant and compound\n   * variant values, `class`/`className`) and passes them through verbatim,\n   * one argument each, without interpreting them.\n   *\n   * The authoring surface adopts the concatenator's own input type\n   * automatically (see {@link CXInput}): pass `twMerge` and your variants\n   * are checked against tailwind-merge's `ClassNameValue`; pass `clsx` (or\n   * any function whose parameters don't narrow further) and you keep the\n   * full clsx-flavored `ClassValue` grammar.\n   */\n  cx: TCX & CXConstraint<TCX>;\n  hooks?: {\n    /**\n     * @deprecated please use the `cx` option instead\n     */\n    \"cx:done\"?: (className: string) => string;\n    /**\n     * @deprecated please use the `cx` option instead\n     */\n    onComplete?: (className: string) => string;\n  };\n}\n\nexport interface DefineConfig {\n  <TCX extends AnyCX>(\n    options: DefineConfigOptions<TCX>,\n  ): {\n    /**\n     * @deprecated Use the `composes` property inside `cva` instead.\n     * @example\n     * // Before\n     * const card = compose(box, stack)\n     * // After\n     * const card = cva({ composes: [box, stack] })\n     */\n    compose: Compose<CXInput<TCX>>;\n    cx: CX<CXInput<TCX>>;\n    cva: CVA<CXInput<TCX>>;\n  };\n}\n\n/* Exports\n  ============================================ */\n\nconst falsyToString = <T extends unknown>(value: T) =>\n  typeof value === \"boolean\" ? `${value}` : value === 0 ? \"0\" : value;\n\n// Shared across every non-composed call, rather than allocating a fresh `[]`\n// per call — spreading an empty array contributes no arguments.\nconst emptyClassNames: string[] = [];\n\n// Cast to `DefineConfig`: runtime uses `ClassValue`; `CXInput` is type-only.\nexport const defineConfig = ((options: DefineConfigOptions) => {\n  const cx: CX = (...inputs) => {\n    // Drop absent values so a narrower concatenator never receives `undefined`.\n    const className = options.cx(\n      ...inputs.filter((input) => input !== undefined),\n    );\n\n    const hook = options.hooks?.[\"cx:done\"] ?? options.hooks?.onComplete;\n    return hook ? hook(className) : className;\n  };\n\n  const cva = (<\n    _ extends InternalOnlyWarning,\n    Config,\n    Variants,\n    ComposedSingle extends CVAComponentShape | undefined = undefined,\n    ComposedList extends readonly CVAComponentShape[] = [],\n  >(\n    config: CVAComponentConfig<Config, Variants, ComposedSingle, ComposedList>,\n  ) => {\n    const components = (\n      config?.composes == null\n        ? []\n        : Array.isArray(config.composes)\n          ? config.composes\n          : [config.composes]\n    ) as CVAComponentShape[];\n    // A one-level-deep merge per variant key, so overlapping variants (e.g.\n    // multiple composed components declaring `style`) union their values\n    // instead of the last component's values silently replacing the rest.\n    const mergeVariants = (\n      acc: CVAVariantShape,\n      variants: CVAVariantShape | undefined,\n    ): CVAVariantShape => {\n      if (!variants) return acc;\n      const merged: CVAVariantShape = { ...acc };\n      for (const key of Object.keys(variants)) {\n        merged[key] = { ...merged[key], ...variants[key] };\n      }\n      return merged;\n    };\n    const mergedVariantsFromComposed = components.reduce(\n      (acc: CVAVariantShape, component: CVAComponentShape) =>\n        mergeVariants(acc, component.config?.variants),\n      {} as CVAVariantShape,\n    );\n    const mergedVariants = mergeVariants(\n      mergedVariantsFromComposed,\n      config?.variants as CVAVariantShape | undefined,\n    );\n    const mergedDefaultVariantsFromComposed = components.reduce(\n      (acc: Record<string, unknown>, component: CVAComponentShape) => ({\n        ...acc,\n        ...component.config?.defaultVariants,\n      }),\n      {} as Record<string, unknown>,\n    );\n    // Local `defaultVariants` win over composed ones here too (last spread).\n    const mergedDefaultVariants: Record<string, unknown> = {\n      ...mergedDefaultVariantsFromComposed,\n      ...config?.defaultVariants,\n    };\n\n    const component: CVAComponent<typeof config, typeof config.variants> = (\n      props,\n    ) => {\n      // Strip `class`/`className` and explicit `undefined` from props once,\n      // reused for both the composed-component calls and compound-variant\n      // matching. An explicit `{ variant: undefined }` is dropped so it falls\n      // back to the (possibly composed) default, matching variant resolution\n      // below. Only built when something consumes it — a plain component with\n      // no `composes` and no `compoundVariants` skips the work entirely.\n      const definedPropsWithoutClass =\n        components.length || config?.compoundVariants\n          ? Object.fromEntries(\n              Object.entries(props || {}).filter(\n                ([key, value]) =>\n                  key !== \"class\" &&\n                  key !== \"className\" &&\n                  typeof value !== \"undefined\",\n              ),\n            )\n          : {};\n\n      const getComposedClassNames = components.length\n        ? components.map((component: CVAComponentShape) =>\n            component({\n              ...mergedDefaultVariants,\n              ...definedPropsWithoutClass,\n            }),\n          )\n        : emptyClassNames;\n\n      // Compound variants may target composed-only keys, so a component with\n      // no local `variants` still resolves them.\n      if (!config?.variants && !config?.compoundVariants) {\n        return getComposedClassNames.length\n          ? cx(\n              ...getComposedClassNames,\n              config?.base,\n              props?.class,\n              props?.className,\n            )\n          : cx(config?.base, props?.class, props?.className);\n      }\n\n      const variants = (config.variants ?? {}) as CVAVariantShape;\n\n      // Resolve against the *merged* defaults (composed + local) so a variant\n      // redeclared locally over a composed key uses the same effective default\n      // the composed components and `getSchema` see.\n      const getVariantClassNames = Object.keys(variants).map((variant) => {\n        const variantProp = props?.[variant as keyof typeof props];\n        const defaultVariantProp = mergedDefaultVariants[variant];\n\n        const variantKey = (falsyToString(variantProp) ||\n          falsyToString(defaultVariantProp)) as string;\n\n        return variants[variant][variantKey];\n      });\n\n      const defaultsAndProps = {\n        ...mergedDefaultVariants,\n        ...definedPropsWithoutClass,\n      };\n\n      const getCompoundVariantClassNames =\n        config?.compoundVariants?.reduce(\n          (\n            acc: ClassValue[],\n            {\n              class: cvClass,\n              className: cvClassName,\n              ...cvConfig\n            }: CVAClassProp & Record<string, unknown>,\n          ) =>\n            Object.entries(cvConfig).every(([cvKey, cvSelector]) => {\n              const selector =\n                defaultsAndProps[cvKey as keyof typeof defaultsAndProps];\n\n              return Array.isArray(cvSelector)\n                ? cvSelector.includes(selector)\n                : selector === cvSelector;\n            })\n              ? [...acc, cvClass, cvClassName]\n              : acc,\n          [] as ClassValue[],\n        ) ?? emptyClassNames;\n\n      return cx(\n        ...getComposedClassNames,\n        config?.base,\n        ...getVariantClassNames,\n        ...getCompoundVariantClassNames,\n        props?.class,\n        props?.className,\n      );\n    };\n\n    component.config = {\n      ...config,\n      variants: mergedVariants,\n      defaultVariants: mergedDefaultVariants,\n    };\n\n    return component as ReturnType<CVA>;\n  }) as CVA;\n\n  const compose: Compose = (...components) => {\n    const composedComponents = components as CVAComponentShape[];\n    const config = composedComponents.reduce(\n      (acc, { config }) => {\n        Object.entries(config || {}).forEach(([key, value]) => {\n          acc[key] =\n            typeof value === \"object\" && value !== null && !Array.isArray(value)\n              ? {\n                  ...acc[key],\n                  ...value,\n                }\n              : value;\n        });\n        return acc;\n      },\n      // A loose accumulator: composed configs carry heterogeneous values\n      // (base strings, variant maps, compoundVariant arrays), not just the\n      // `CVAVariantShape` the merged `variants` key holds.\n      {} as Record<string, any>,\n    );\n\n    const component: CVAComponent<typeof config, typeof config.variants> = (\n      props,\n    ) => {\n      const propsWithoutClass = Object.fromEntries(\n        Object.entries(props || {}).filter(\n          ([key]) => ![\"class\", \"className\"].includes(key),\n        ),\n      );\n\n      return cx(\n        ...composedComponents.map((component) => component(propsWithoutClass)),\n        props?.class,\n        props?.className,\n      );\n    };\n\n    component.config = config;\n\n    return component;\n  };\n\n  return {\n    compose,\n    cva,\n    cx,\n  };\n}) as DefineConfig;\n\nexport interface GetSchema {\n  <_ extends InternalOnlyWarning, Component, Config, Variants>(\n    component: Component &\n      (Component extends CVAComponentShape\n        ? Component extends { config: { variants: infer V } }\n          ? // A variant-less component carries `variants: unknown` and a\n            // `defaultVariants: {}` that no `CVAComponentConfig` branch\n            // accepts; leave `Variants` uninferred so the schema maps over\n            // `keyof unknown` (`never`) to `{}`.\n            unknown extends V\n            ? unknown\n            : { config: CVAComponentConfig<Config, Variants> }\n          : { config: CVAComponentConfig<Config, Variants> }\n        : never),\n  ): {\n    [Variant in keyof Variants as Variant extends InternalVariantKey\n      ? never\n      : Variant]: Config extends CVAComponentConfig<Config, Variants>\n      ? Variant extends keyof Config[\"defaultVariants\"]\n        ? Config[\"defaultVariants\"][Variant] extends undefined\n          ? never\n          : {\n              values: ReadonlyArray<StringToBoolean<keyof Variants[Variant]>>;\n              defaultValue: Readonly<\n                StringToBoolean<Config[\"defaultVariants\"][Variant]>\n              >;\n            }\n        : {\n            values: ReadonlyArray<StringToBoolean<keyof Variants[Variant]>>;\n          }\n      : never;\n    // Iterate over the returned schema and remove any keys that have no values\n  } extends infer Schema\n    ? {\n        [K in keyof Schema as Schema[K] extends {\n          values: readonly never[];\n        }\n          ? never\n          : K]: Schema[K] extends { defaultValue: never } ? never : Schema[K];\n      }\n    : never;\n}\n"],"mappings":";AAqaA,MAAM,iBAAoC,UACxC,OAAO,UAAU,YAAY,GAAG,UAAU,UAAU,IAAI,MAAM;AAIhE,MAAM,kBAA4B,CAAC;AAGnC,MAAa,iBAAiB,YAAiC;CAC7D,MAAM,MAAU,GAAG,WAAW;;EAE5B,MAAM,YAAY,QAAQ,GACxB,GAAG,OAAO,QAAQ,UAAU,UAAU,KAAA,CAAS,CACjD;EAEA,MAAM,QAAA,wBAAA,iBAAO,QAAQ,WAAA,QAAA,mBAAA,KAAA,IAAA,KAAA,IAAA,eAAQ,gBAAA,QAAA,yBAAA,KAAA,IAAA,wBAAA,kBAAc,QAAQ,WAAA,QAAA,oBAAA,KAAA,IAAA,KAAA,IAAA,gBAAO;EAC1D,OAAO,OAAO,KAAK,SAAS,IAAI;CAClC;CAEA,MAAM,QAOJ,WACG;EACH,MAAM,cAAA,WAAA,QAAA,WAAA,KAAA,IAAA,KAAA,IACJ,OAAQ,aAAY,OAChB,CAAC,IACD,MAAM,QAAQ,OAAO,QAAQ,IAC3B,OAAO,WACP,CAAC,OAAO,QAAQ;EAKxB,MAAM,iBACJ,KACA,aACoB;GACpB,IAAI,CAAC,UAAU,OAAO;GACtB,MAAM,SAA0B,EAAE,GAAG,IAAI;GACzC,KAAK,MAAM,OAAO,OAAO,KAAK,QAAQ,GACpC,OAAO,OAAO;IAAE,GAAG,OAAO;IAAM,GAAG,SAAS;GAAK;GAEnD,OAAO;EACT;EAMA,MAAM,iBAAiB,cALY,WAAW,QAC3C,KAAsB,cACrB;;wBAAc,MAAA,oBAAK,UAAU,YAAA,QAAA,sBAAA,KAAA,IAAA,KAAA,IAAA,kBAAQ,QAAQ;KAC/C,CAAC,CAGwB,GAAA,WAAA,QAAA,WAAA,KAAA,IAAA,KAAA,IACzB,OAAQ,QACV;EASA,MAAM,wBAAiD;GACrD,GATwC,WAAW,QAClD,KAA8B,cAAiC;;WAAC;KAC/D,GAAG;KACH,IAAA,qBAAG,UAAU,YAAA,QAAA,uBAAA,KAAA,IAAA,KAAA,IAAA,mBAAQ;IACvB;GAAC,GACD,CAAC,CAIkC;GACnC,GAAA,WAAA,QAAA,WAAA,KAAA,IAAA,KAAA,IAAG,OAAQ;EACb;EAEA,MAAM,aACJ,UACG;;GAOH,MAAM,2BACJ,WAAW,WAAA,WAAA,QAAA,WAAA,KAAA,IAAA,KAAA,IAAU,OAAQ,oBACzB,OAAO,YACL,OAAO,QAAQ,SAAS,CAAC,CAAC,CAAC,CAAC,QACzB,CAAC,KAAK,WACL,QAAQ,WACR,QAAQ,eACR,OAAO,UAAU,WACrB,CACF,IACA,CAAC;GAEP,MAAM,wBAAwB,WAAW,SACrC,WAAW,KAAK,cACd,UAAU;IACR,GAAG;IACH,GAAG;GACL,CAAC,CACH,IACA;GAIJ,IAAI,EAAA,WAAA,QAAA,WAAA,KAAA,IAAA,KAAA,IAAC,OAAQ,aAAY,EAAA,WAAA,QAAA,WAAA,KAAA,IAAA,KAAA,IAAC,OAAQ,mBAChC,OAAO,sBAAsB,SACzB,GACE,GAAG,uBAAA,WAAA,QAAA,WAAA,KAAA,IAAA,KAAA,IACH,OAAQ,MAAA,UAAA,QAAA,UAAA,KAAA,IAAA,KAAA,IACR,MAAO,OAAA,UAAA,QAAA,UAAA,KAAA,IAAA,KAAA,IACP,MAAO,SACT,IACA,GAAA,WAAA,QAAA,WAAA,KAAA,IAAA,KAAA,IAAG,OAAQ,MAAA,UAAA,QAAA,UAAA,KAAA,IAAA,KAAA,IAAM,MAAO,OAAA,UAAA,QAAA,UAAA,KAAA,IAAA,KAAA,IAAO,MAAO,SAAS;GAGrD,MAAM,YAAA,mBAAY,OAAO,cAAA,QAAA,qBAAA,KAAA,IAAA,mBAAY,CAAC;GAKtC,MAAM,uBAAuB,OAAO,KAAK,QAAQ,CAAC,CAAC,KAAK,YAAY;IAClE,MAAM,cAAA,UAAA,QAAA,UAAA,KAAA,IAAA,KAAA,IAAc,MAAQ;IAC5B,MAAM,qBAAqB,sBAAsB;IAEjD,MAAM,aAAc,cAAc,WAAW,KAC3C,cAAc,kBAAkB;IAElC,OAAO,SAAS,QAAQ,CAAC;GAC3B,CAAC;GAED,MAAM,mBAAmB;IACvB,GAAG;IACH,GAAG;GACL;GAEA,MAAM,gCAAA,wBAAA,WAAA,QAAA,WAAA,KAAA,MAAA,yBACJ,OAAQ,sBAAA,QAAA,2BAAA,KAAA,IAAA,KAAA,IAAA,uBAAkB,QAEtB,KACA,EACE,OAAO,SACP,WAAW,aACX,GAAG,eAGL,OAAO,QAAQ,QAAQ,CAAC,CAAC,OAAO,CAAC,OAAO,gBAAgB;IACtD,MAAM,WACJ,iBAAiB;IAEnB,OAAO,MAAM,QAAQ,UAAU,IAC3B,WAAW,SAAS,QAAQ,IAC5B,aAAa;GACnB,CAAC,IACG;IAAC,GAAG;IAAK;IAAS;GAAW,IAC7B,KACN,CAAC,CACH,OAAA,QAAA,0BAAA,KAAA,IAAA,wBAAK;GAEP,OAAO,GACL,GAAG,uBAAA,WAAA,QAAA,WAAA,KAAA,IAAA,KAAA,IACH,OAAQ,MACR,GAAG,sBACH,GAAG,8BAAA,UAAA,QAAA,UAAA,KAAA,IAAA,KAAA,IACH,MAAO,OAAA,UAAA,QAAA,UAAA,KAAA,IAAA,KAAA,IACP,MAAO,SACT;EACF;EAEA,UAAU,SAAS;GACjB,GAAG;GACH,UAAU;GACV,iBAAiB;EACnB;EAEA,OAAO;CACT;CAEA,MAAM,WAAoB,GAAG,eAAe;EAC1C,MAAM,qBAAqB;EAC3B,MAAM,SAAS,mBAAmB,QAC/B,KAAK,EAAE,aAAa;GACnB,OAAO,QAAQ,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,WAAW;IACrD,IAAI,OACF,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK,IAC/D;KACE,GAAG,IAAI;KACP,GAAG;IACL,IACA;GACR,CAAC;GACD,OAAO;EACT,GAIA,CAAC,CACH;EAEA,MAAM,aACJ,UACG;GACH,MAAM,oBAAoB,OAAO,YAC/B,OAAO,QAAQ,SAAS,CAAC,CAAC,CAAC,CAAC,QACzB,CAAC,SAAS,CAAC,CAAC,SAAS,WAAW,CAAC,CAAC,SAAS,GAAG,CACjD,CACF;GAEA,OAAO,GACL,GAAG,mBAAmB,KAAK,cAAc,UAAU,iBAAiB,CAAC,GAAA,UAAA,QAAA,UAAA,KAAA,IAAA,KAAA,IACrE,MAAO,OAAA,UAAA,QAAA,UAAA,KAAA,IAAA,KAAA,IACP,MAAO,SACT;EACF;EAEA,UAAU,SAAS;EAEnB,OAAO;CACT;CAEA,OAAO;EACL;EACA;EACA;CACF;AACF"}