responsive-class-variants 1.3.1 → 1.4.0

package/README.md

@@ -8,7 +8,7 @@ rcv helps you create responsive class variants. It handles the logic of generati
 - You just need to provide the base classes, the variants and optionally compound variants.
 - **Slots support**: Create multiple class-generating functions for different parts of a component.
 - **Framework agnostic**: Supports both `className` (React) and `class` (Svelte, Vue, SolidJS) props.
-- You can use the default breakpoints (sm, md, lg, xl) or provide your own.
+- You can use the default breakpoints (`sm`, `md`, `lg`, `xl`) or teach TypeScript your own names with an optional **`breakpoints`** tuple on the config (type-only) or with **`createRcv`**.
 - You can pass an optional onComplete callback to the createRcv function. This callback will be called with the generated classes. Helpful if you want to pass your classes to a library like twMerge.
 
 ## Installation
@@ -23,10 +23,12 @@ rcv is a function that takes a config object and returns a function that takes a
 
 The config object has the following properties:
 
-- base: The base classes that are always applied.
-- variants: An object with the keys of the variants and the values are the values of the variants.
-- compoundVariants: An array of compound variants that apply additional classes when multiple variants have specific values.
-- onComplete: An optional callback function that receives the generated classes and returns the final classes.
+- **base** (non-slots): The base classes that are always applied.
+- **slots** (slots API): An object mapping slot names to their base classes.
+- **variants**: An object with the keys of the variants and the values are the values of the variants.
+- **compoundVariants**: An array of compound variants that apply additional classes when multiple variants have specific values.
+- **breakpoints** (optional): A `const` tuple of breakpoint names used **only for TypeScript** so responsive props are typed with your names (e.g. `mobile`, `tablet`). Not read at runtime. Omit to use the defaults `sm`, `md`, `lg`, `xl`.
+- **onComplete**: An optional callback function that receives the generated classes and returns the final classes.
 
 rcv works very well with tailwindcss but it can be used with any CSS solution.
 
@@ -282,13 +284,18 @@ const SIZES = {
 
 The structure doesn't really matter, the classes just need to be in the compiled javascript to be picked up by the JIT compiler.
 
-## Custom breakpoints (via createRcv)
+## Custom breakpoints
 
-```ts
-const rcv = createRcv(['mobile', 'tablet', 'desktop']);
+Runtime behavior is unchanged: class names are still prefixed with whatever breakpoint key you use (e.g. `mobile:`, `md:`). You only need to tell TypeScript which names are valid.
+
+### Option A: `breakpoints` on `rcv` (recommended)
 
+Pass a `const` tuple so responsive props are inferred for `initial` plus those keys only:
+
+```ts
 const getButtonVariants = rcv({
   base: "px-4 py-2 rounded",
+  breakpoints: ["mobile", "tablet", "desktop"] as const,
   variants: {
     intent: {
       primary: "bg-blue-500 text-white",
@@ -297,24 +304,37 @@ const getButtonVariants = rcv({
   }
 });
 
-// Usage with custom breakpoints:
-getButtonVariants({ intent: { initial: "primary", mobile: "secondary", desktop: "primary" } })
+getButtonVariants({
+  intent: { initial: "primary", mobile: "secondary", desktop: "primary" }
+});
+```
 
-// Works with slots too:
-const getCardVariants = rcv({
-  slots: {
-    base: "rounded-xl p-4 bg-white",
-    title: "font-bold text-gray-900"
-  },
+The `breakpoints` field is **not** read at runtime; it exists so the compiler can infer the breakpoint union.
+
+### Option B: `createRcv`
+
+Same typing effect by passing the tuple to `createRcv` once (also type-only for the first argument):
+
+```ts
+const rcv = createRcv(["mobile", "tablet", "desktop"]);
+
+const getButtonVariants = rcv({
+  base: "px-4 py-2 rounded",
   variants: {
-    size: {
-      sm: { base: "p-2", title: "text-sm" },
-      lg: { base: "p-8", title: "text-2xl" }
+    intent: {
+      primary: "bg-blue-500 text-white",
+      secondary: "bg-gray-200 text-gray-800"
     }
   }
 });
+
+getButtonVariants({
+  intent: { initial: "primary", mobile: "secondary", desktop: "primary" }
+});
 ```
 
+Custom breakpoints work with the slots API as well—add `breakpoints: [...] as const` next to `slots` / `variants`, or use `createRcv` as above.
+
 ## onComplete callback (via createRcv)
 
 You can pass an optional onComplete callback to the createRcv function. This callback will be called with the generated classes. Helpful if you want to pass your classes to a library like tailwind Merge.
@@ -363,7 +383,7 @@ compoundVariants: [
 
 rcv provides a helper type to make it easier to type your component props.
 
-If you use the default breakpoints (sm, md, lg, xl), you can use the `ResponsiveValue` type to make existing props responsive.
+If you use the default breakpoints (`sm`, `md`, `lg`, `xl`), you can use the `ResponsiveValue` type to make existing props responsive.
 
 ```ts
 type ButtonProps = {
@@ -374,16 +394,15 @@ type ButtonProps = {
 };
 ```
 
-If you use custom breakpoints you need to pass the breakpoints to the `ResponsiveValue` type.
+If you use **custom** breakpoint names, pass the same union as the second generic parameter, or derive it once from your `const` tuple:
 
 ```ts
-import { createRcv, type ResponsiveValue as RcvResponsiveValue } from "responsive-class-variants";
+import { type ResponsiveValue as RcvResponsiveValue } from "responsive-class-variants";
 
 const breakpoints = ["tablet", "desktop", "wide"] as const;
+type CustomBreakpoint = (typeof breakpoints)[number];
 
-export const customRcv = createRcv(breakpoints);
-
-type Breakpoints = (typeof breakpoints)[number];
-
-export type ResponsiveValue<T> = RcvResponsiveValue<T, Breakpoints>;
+export type ResponsiveValue<T> = RcvResponsiveValue<T, CustomBreakpoint>;
 ```
+
+When you define variants with `rcv({ breakpoints: [...] as const, ... })` or `createRcv(breakpoints)`, the returned function’s props are already inferred; you only need the snippet above for **separate** prop types (e.g. wrapping a design-system component).

package/dist/helpers.d.ts

@@ -0,0 +1,38 @@
+import type { CompoundVariantWithSlots, DefaultBreakpoints, ResponsiveClassesConfig, ResponsiveClassesConfigSlots, ResponsiveValue, SlotConfig, VariantConfig, VariantProps } from "./types.js";
+/**
+ * Maps a ResponsiveValue to a new ResponsiveValue using the provided mapper function. Singular values are passed through as is.
+ *
+ * @template V The type of the original value
+ * @template T The type of the mapped value
+ * @template B The type of breakpoints
+ * @param {ResponsiveValue<V, B>} value - The original ResponsiveValue to be mapped
+ * @param {function(V): T} mapper - A function that maps a ResponsiveValue to a new ResponsiveValue
+ * @returns {ResponsiveValue<T, B>} A new ResponsiveValue with the mapped values
+ *
+ *
+ * @example
+ * const sizes = {
+ *  initial: 'md',
+ *  sm: 'lg',
+ * }
+ *
+ * const output = mapResponsiveValue(sizes, size => {
+ *	switch (size) {
+ *		case 'initial':
+ *		return 'sm';
+ *		case 'sm':
+ *			return 'md';
+ *		}
+ *	});
+ *
+ * // console.log(output)
+ * {
+ *	initial: 'sm',
+ *	sm: 'md',
+ * }
+ */
+export declare const mapResponsiveValue: <V, T, B extends string = DefaultBreakpoints>(value: ResponsiveValue<V, B>, mapper: (value: V) => T) => ResponsiveValue<T, B>;
+export declare const isSlotsConfig: <T extends VariantConfig, B extends string>(config: ResponsiveClassesConfig<T, B>) => config is ResponsiveClassesConfigSlots<T, Record<string, SlotConfig>, B>;
+export declare const processVariantProps: <T extends VariantConfig, B extends string>(props: Omit<VariantProps<T, B>, "className" | "class">, variants: T | undefined, slotName?: string) => (string | (string | undefined)[] | undefined)[];
+export declare const matchesCompoundVariant: <T extends VariantConfig, B extends string>(compound: Omit<CompoundVariantWithSlots<T, string, B>, "className" | "class">, props: Omit<VariantProps<T, B>, "className" | "class">) => boolean;
+export declare const createSlotFunction: <T extends VariantConfig, B extends string>(slotConfig: SlotConfig, variants: T | undefined, compoundVariants: CompoundVariantWithSlots<T, string, B>[] | undefined, onComplete: ((classes: string) => string) | undefined, slotName: string) => ({ className, class: classFromProps, ...props }?: VariantProps<T, B>) => string;

package/dist/helpers.js

@@ -0,0 +1,139 @@
+import { clsx } from "clsx";
+const isSingularValue = (value) => !isBreakpointsMap(value);
+const isBreakpointsMap = (value) => typeof value === "object" && value != null && !Array.isArray(value);
+/**
+ * Maps a ResponsiveValue to a new ResponsiveValue using the provided mapper function. Singular values are passed through as is.
+ *
+ * @template V The type of the original value
+ * @template T The type of the mapped value
+ * @template B The type of breakpoints
+ * @param {ResponsiveValue<V, B>} value - The original ResponsiveValue to be mapped
+ * @param {function(V): T} mapper - A function that maps a ResponsiveValue to a new ResponsiveValue
+ * @returns {ResponsiveValue<T, B>} A new ResponsiveValue with the mapped values
+ *
+ *
+ * @example
+ * const sizes = {
+ *  initial: 'md',
+ *  sm: 'lg',
+ * }
+ *
+ * const output = mapResponsiveValue(sizes, size => {
+ *	switch (size) {
+ *		case 'initial':
+ *		return 'sm';
+ *		case 'sm':
+ *			return 'md';
+ *		}
+ *	});
+ *
+ * // console.log(output)
+ * {
+ *	initial: 'sm',
+ *	sm: 'md',
+ * }
+ */
+export const mapResponsiveValue = (value, mapper) => {
+    if (isSingularValue(value)) {
+        return mapper(value);
+    }
+    const result = {};
+    for (const key of Object.keys(value)) {
+        result[key] = mapper(value[key]);
+    }
+    return result;
+};
+// Helper functions for slots
+export const isSlotsConfig = (config) => {
+    return "slots" in config;
+};
+const normalizeClassValue = (value) => {
+    if (Array.isArray(value)) {
+        return value.join(" ");
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    return undefined;
+};
+const prefixClasses = (classes, prefix) => classes.replace(/(\S+)/g, `${prefix}:$1`);
+// Helper function to get variant value for a specific slot or base
+const getVariantValue = (variants, key, value, slotName) => {
+    const variantValue = variants?.[key]?.[value];
+    // Early return if no variant value found
+    if (variantValue == null)
+        return undefined;
+    // Handle string or array values directly
+    if (typeof variantValue === "string" || Array.isArray(variantValue)) {
+        return normalizeClassValue(variantValue);
+    }
+    // Handle slot-specific values (object with slot keys)
+    if (slotName && slotName in variantValue) {
+        return normalizeClassValue(variantValue[slotName]);
+    }
+    return undefined;
+};
+// Helper function to process responsive values
+const processResponsiveValue = (variants, key, value, slotName) => {
+    return Object.entries(value).map(([breakpoint, breakpointValue]) => {
+        const variantValue = getVariantValue(variants, key, breakpointValue, slotName);
+        if (!variantValue)
+            return undefined;
+        // If the breakpoint is initial, return without prefix
+        if (breakpoint === "initial") {
+            return variantValue;
+        }
+        // Otherwise, return with breakpoint prefix
+        return prefixClasses(variantValue, breakpoint);
+    });
+};
+// Helper function to process variant props into classes
+export const processVariantProps = (props, variants, slotName) => {
+    return Object.entries(props).map(([key, propValue]) => {
+        const value = typeof propValue === "boolean" ? String(propValue) : propValue;
+        // Handle undefined values
+        if (!value)
+            return undefined;
+        // Handle singular values
+        if (typeof value === "string") {
+            return getVariantValue(variants, key, value, slotName);
+        }
+        // Handle responsive values
+        return processResponsiveValue(variants, key, value, slotName);
+    });
+};
+// Helper function to match compound variants
+export const matchesCompoundVariant = (compound, props) => {
+    return Object.entries(compound).every(([key, value]) => {
+        const propValue = props[key];
+        // Direct comparison first, then try string conversion for boolean handling
+        return propValue === value || propValue === String(value);
+    });
+};
+// Helper function to extract class value from compound variant class prop
+const getCompoundVariantSlotClass = (classValue, slotName) => {
+    if (!classValue)
+        return undefined;
+    if (typeof classValue === "object" && classValue[slotName]) {
+        return normalizeClassValue(classValue[slotName]);
+    }
+    if (typeof classValue === "string") {
+        return classValue;
+    }
+    return undefined;
+};
+export const createSlotFunction = (slotConfig, variants, compoundVariants, onComplete, slotName) => ({ className, class: classFromProps, ...props } = {}) => {
+    const responsiveClasses = processVariantProps(props, variants, slotName);
+    const compoundClasses = compoundVariants?.map(({ class: classFromCompound, className: classNameFromCompound, ...compound }) => {
+        if (matchesCompoundVariant(compound, props)) {
+            return [
+                getCompoundVariantSlotClass(classFromCompound, slotName),
+                getCompoundVariantSlotClass(classNameFromCompound, slotName),
+            ];
+        }
+        return undefined;
+    });
+    const classes = clsx(slotConfig, responsiveClasses, compoundClasses, className, classFromProps);
+    return onComplete ? onComplete(classes) : classes;
+};
+//# sourceMappingURL=helpers.js.map

package/dist/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"/","sources":["helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAe5B,MAAM,eAAe,GAAG,CACvB,KAA4B,EACf,EAAE,CAAC,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;AAE1C,MAAM,gBAAgB,GAAG,CACxB,KAA4B,EACI,EAAE,CAClC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CACjC,KAA4B,EAC5B,MAAuB,EACC,EAAE;IAC1B,IAAI,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC;IAED,MAAM,MAAM,GAAsB,EAAE,CAAC;IACrC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACtC,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,GAAyB,CAAM,CAAC,CAAC;IAC7D,CAAC;IACD,OAAO,MAA8B,CAAC;AACvC,CAAC,CAAC;AAEF,6BAA6B;AAC7B,MAAM,CAAC,MAAM,aAAa,GAAG,CAC5B,MAAqC,EACsC,EAAE;IAC7E,OAAO,OAAO,IAAI,MAAM,CAAC;AAC1B,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAG,CAC3B,KAAiD,EAChD,EAAE;IACH,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACxB,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC/B,OAAO,KAAK,CAAC;IACd,CAAC;IACD,OAAO,SAAS,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,aAAa,GAAG,CAAC,OAAe,EAAE,MAAc,EAAE,EAAE,CACzD,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,MAAM,KAAK,CAAC,CAAC;AAE3C,mEAAmE;AACnE,MAAM,eAAe,GAAG,CACvB,QAAuB,EACvB,GAAY,EACZ,KAAa,EACb,QAAiB,EACI,EAAE;IACvB,MAAM,YAAY,GAAG,QAAQ,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;IAE9C,yCAAyC;IACzC,IAAI,YAAY,IAAI,IAAI;QAAE,OAAO,SAAS,CAAC;IAE3C,yCAAyC;IACzC,IAAI,OAAO,YAAY,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC;QACrE,OAAO,mBAAmB,CAAC,YAAY,CAAC,CAAC;IAC1C,CAAC;IAED,sDAAsD;IACtD,IAAI,QAAQ,IAAI,QAAQ,IAAI,YAAY,EAAE,CAAC;QAC1C,OAAO,mBAAmB,CACxB,YAA+D,CAC/D,QAAQ,CACR,CACD,CAAC;IACH,CAAC;IAED,OAAO,SAAS,CAAC;AAClB,CAAC,CAAC;AAEF,+CAA+C;AAC/C,MAAM,sBAAsB,GAAG,CAC9B,QAAuB,EACvB,GAAY,EACZ,KAAoC,EACpC,QAAiB,EAChB,EAAE;IACH,OAAO,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,EAAE,eAAe,CAAC,EAAE,EAAE;QAClE,MAAM,YAAY,GAAG,eAAe,CACnC,QAAQ,EACR,GAAG,EACH,eAAyB,EACzB,QAAQ,CACR,CAAC;QAEF,IAAI,CAAC,YAAY;YAAE,OAAO,SAAS,CAAC;QAEpC,sDAAsD;QACtD,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC9B,OAAO,YAAY,CAAC;QACrB,CAAC;QAED,2CAA2C;QAC3C,OAAO,aAAa,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;IAChD,CAAC,CAAC,CAAC;AACJ,CAAC,CAAC;AAEF,wDAAwD;AACxD,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAClC,KAAsD,EACtD,QAAuB,EACvB,QAAiB,EAChB,EAAE;IACH,OAAO,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAC/B,CAAC,CAAC,GAAG,EAAE,SAAS,CAA6C,EAAE,EAAE;QAChE,MAAM,KAAK,GACV,OAAO,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAEhE,0BAA0B;QAC1B,IAAI,CAAC,KAAK;YAAE,OAAO,SAAS,CAAC;QAE7B,yBAAyB;QACzB,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC/B,OAAO,eAAe,CAAC,QAAQ,EAAE,GAAG,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;QACxD,CAAC;QAED,2BAA2B;QAC3B,OAAO,sBAAsB,CAC5B,QAAQ,EACR,GAAG,EACH,KAAsC,EACtC,QAAQ,CACR,CAAC;IACH,CAAC,CACD,CAAC;AACH,CAAC,CAAC;AAEF,6CAA6C;AAC7C,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAIrC,QAA6E,EAC7E,KAAsD,EACrD,EAAE;IACH,OAAO,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;QACtD,MAAM,SAAS,GAAG,KAAK,CAAC,GAAyB,CAAC,CAAC;QACnD,2EAA2E;QAC3E,OAAO,SAAS,KAAK,KAAK,IAAI,SAAS,KAAK,MAAM,CAAC,KAAK,CAAC,CAAC;IAC3D,CAAC,CAAC,CAAC;AACJ,CAAC,CAAC;AAEF,0EAA0E;AAC1E,MAAM,2BAA2B,GAAG,CACnC,UAAoD,EACpD,QAAgB,EACK,EAAE;IACvB,IAAI,CAAC,UAAU;QAAE,OAAO,SAAS,CAAC;IAElC,IAAI,OAAO,UAAU,KAAK,QAAQ,IAAI,UAAU,CAAC,QAAa,CAAC,EAAE,CAAC;QACjE,OAAO,mBAAmB,CAAC,UAAU,CAAC,QAAa,CAAC,CAAC,CAAC;IACvD,CAAC;IAED,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;QACpC,OAAO,UAAU,CAAC;IACnB,CAAC;IAED,OAAO,SAAS,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAC9B,CACC,UAAsB,EACtB,QAAuB,EACvB,gBAAsE,EACtE,UAAqD,EACrD,QAAgB,EACf,EAAE,CACJ,CACC,EACC,SAAS,EACT,KAAK,EAAE,cAAc,EACrB,GAAG,KAAK,KACe,EAAwB,EAC/C,EAAE;IACH,MAAM,iBAAiB,GAAG,mBAAmB,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAEzE,MAAM,eAAe,GAAG,gBAAgB,EAAE,GAAG,CAC5C,CAAC,EACA,KAAK,EAAE,iBAAiB,EACxB,SAAS,EAAE,qBAAqB,EAChC,GAAG,QAAQ,EACX,EAAE,EAAE;QACJ,IAAI,sBAAsB,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC;YAC7C,OAAO;gBACN,2BAA2B,CAAC,iBAAiB,EAAE,QAAQ,CAAC;gBACxD,2BAA2B,CAAC,qBAAqB,EAAE,QAAQ,CAAC;aAC5D,CAAC;QACH,CAAC;QACD,OAAO,SAAS,CAAC;IAClB,CAAC,CACD,CAAC;IAEF,MAAM,OAAO,GAAG,IAAI,CACnB,UAAU,EACV,iBAAiB,EACjB,eAAe,EACf,SAAS,EACT,cAAc,CACd,CAAC;IACF,OAAO,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;AACnD,CAAC,CAAC","sourcesContent":["import { clsx } from \"clsx\";\nimport type {\n\tBreakpointsMap,\n\tCompoundVariantClassValue,\n\tCompoundVariantWithSlots,\n\tDefaultBreakpoints,\n\tResponsiveClassesConfig,\n\tResponsiveClassesConfigSlots,\n\tResponsiveValue,\n\tSlotConfig,\n\tVariantConfig,\n\tVariantProps,\n\tVariantPropValue,\n} from \"./types\";\n\nconst isSingularValue = <A, B extends string>(\n\tvalue: ResponsiveValue<A, B>,\n): value is A => !isBreakpointsMap(value);\n\nconst isBreakpointsMap = <A, B extends string>(\n\tvalue: ResponsiveValue<A, B>,\n): value is BreakpointsMap<A, B> =>\n\ttypeof value === \"object\" && value != null && !Array.isArray(value);\n\n/**\n * Maps a ResponsiveValue to a new ResponsiveValue using the provided mapper function. Singular values are passed through as is.\n *\n * @template V The type of the original value\n * @template T The type of the mapped value\n * @template B The type of breakpoints\n * @param {ResponsiveValue<V, B>} value - The original ResponsiveValue to be mapped\n * @param {function(V): T} mapper - A function that maps a ResponsiveValue to a new ResponsiveValue\n * @returns {ResponsiveValue<T, B>} A new ResponsiveValue with the mapped values\n *\n *\n * @example\n * const sizes = {\n *  initial: 'md',\n *  sm: 'lg',\n * }\n *\n * const output = mapResponsiveValue(sizes, size => {\n *\tswitch (size) {\n *\t\tcase 'initial':\n *\t\treturn 'sm';\n *\t\tcase 'sm':\n *\t\t\treturn 'md';\n *\t\t}\n *\t});\n *\n * // console.log(output)\n * {\n *\tinitial: 'sm',\n *\tsm: 'md',\n * }\n */\nexport const mapResponsiveValue = <V, T, B extends string = DefaultBreakpoints>(\n\tvalue: ResponsiveValue<V, B>,\n\tmapper: (value: V) => T,\n): ResponsiveValue<T, B> => {\n\tif (isSingularValue(value)) {\n\t\treturn mapper(value);\n\t}\n\n\tconst result: Record<string, T> = {};\n\tfor (const key of Object.keys(value)) {\n\t\tresult[key] = mapper(value[key as keyof typeof value] as V);\n\t}\n\treturn result as BreakpointsMap<T, B>;\n};\n\n// Helper functions for slots\nexport const isSlotsConfig = <T extends VariantConfig, B extends string>(\n\tconfig: ResponsiveClassesConfig<T, B>,\n): config is ResponsiveClassesConfigSlots<T, Record<string, SlotConfig>, B> => {\n\treturn \"slots\" in config;\n};\n\nconst normalizeClassValue = (\n\tvalue: string | ReadonlyArray<string> | undefined,\n) => {\n\tif (Array.isArray(value)) {\n\t\treturn value.join(\" \");\n\t}\n\tif (typeof value === \"string\") {\n\t\treturn value;\n\t}\n\treturn undefined;\n};\n\nconst prefixClasses = (classes: string, prefix: string) =>\n\tclasses.replace(/(\\S+)/g, `${prefix}:$1`);\n\n// Helper function to get variant value for a specific slot or base\nconst getVariantValue = <T extends VariantConfig>(\n\tvariants: T | undefined,\n\tkey: keyof T,\n\tvalue: string,\n\tslotName?: string,\n): string | undefined => {\n\tconst variantValue = variants?.[key]?.[value];\n\n\t// Early return if no variant value found\n\tif (variantValue == null) return undefined;\n\n\t// Handle string or array values directly\n\tif (typeof variantValue === \"string\" || Array.isArray(variantValue)) {\n\t\treturn normalizeClassValue(variantValue);\n\t}\n\n\t// Handle slot-specific values (object with slot keys)\n\tif (slotName && slotName in variantValue) {\n\t\treturn normalizeClassValue(\n\t\t\t(variantValue as Record<string, string | ReadonlyArray<string>>)[\n\t\t\t\tslotName\n\t\t\t],\n\t\t);\n\t}\n\n\treturn undefined;\n};\n\n// Helper function to process responsive values\nconst processResponsiveValue = <T extends VariantConfig, B extends string>(\n\tvariants: T | undefined,\n\tkey: keyof T,\n\tvalue: Partial<BreakpointsMap<T, B>>,\n\tslotName?: string,\n) => {\n\treturn Object.entries(value).map(([breakpoint, breakpointValue]) => {\n\t\tconst variantValue = getVariantValue(\n\t\t\tvariants,\n\t\t\tkey,\n\t\t\tbreakpointValue as string,\n\t\t\tslotName,\n\t\t);\n\n\t\tif (!variantValue) return undefined;\n\n\t\t// If the breakpoint is initial, return without prefix\n\t\tif (breakpoint === \"initial\") {\n\t\t\treturn variantValue;\n\t\t}\n\n\t\t// Otherwise, return with breakpoint prefix\n\t\treturn prefixClasses(variantValue, breakpoint);\n\t});\n};\n\n// Helper function to process variant props into classes\nexport const processVariantProps = <T extends VariantConfig, B extends string>(\n\tprops: Omit<VariantProps<T, B>, \"className\" | \"class\">,\n\tvariants: T | undefined,\n\tslotName?: string,\n) => {\n\treturn Object.entries(props).map(\n\t\t([key, propValue]: [keyof T, VariantPropValue<T[keyof T], B>]) => {\n\t\t\tconst value =\n\t\t\t\ttypeof propValue === \"boolean\" ? String(propValue) : propValue;\n\n\t\t\t// Handle undefined values\n\t\t\tif (!value) return undefined;\n\n\t\t\t// Handle singular values\n\t\t\tif (typeof value === \"string\") {\n\t\t\t\treturn getVariantValue(variants, key, value, slotName);\n\t\t\t}\n\n\t\t\t// Handle responsive values\n\t\t\treturn processResponsiveValue(\n\t\t\t\tvariants,\n\t\t\t\tkey,\n\t\t\t\tvalue as Partial<BreakpointsMap<T, B>>,\n\t\t\t\tslotName,\n\t\t\t);\n\t\t},\n\t);\n};\n\n// Helper function to match compound variants\nexport const matchesCompoundVariant = <\n\tT extends VariantConfig,\n\tB extends string,\n>(\n\tcompound: Omit<CompoundVariantWithSlots<T, string, B>, \"className\" | \"class\">,\n\tprops: Omit<VariantProps<T, B>, \"className\" | \"class\">,\n) => {\n\treturn Object.entries(compound).every(([key, value]) => {\n\t\tconst propValue = props[key as keyof typeof props];\n\t\t// Direct comparison first, then try string conversion for boolean handling\n\t\treturn propValue === value || propValue === String(value);\n\t});\n};\n\n// Helper function to extract class value from compound variant class prop\nconst getCompoundVariantSlotClass = <S extends string>(\n\tclassValue: CompoundVariantClassValue<S> | undefined,\n\tslotName: string,\n): string | undefined => {\n\tif (!classValue) return undefined;\n\n\tif (typeof classValue === \"object\" && classValue[slotName as S]) {\n\t\treturn normalizeClassValue(classValue[slotName as S]);\n\t}\n\n\tif (typeof classValue === \"string\") {\n\t\treturn classValue;\n\t}\n\n\treturn undefined;\n};\n\nexport const createSlotFunction =\n\t<T extends VariantConfig, B extends string>(\n\t\tslotConfig: SlotConfig,\n\t\tvariants: T | undefined,\n\t\tcompoundVariants: CompoundVariantWithSlots<T, string, B>[] | undefined,\n\t\tonComplete: ((classes: string) => string) | undefined,\n\t\tslotName: string,\n\t) =>\n\t(\n\t\t{\n\t\t\tclassName,\n\t\t\tclass: classFromProps,\n\t\t\t...props\n\t\t}: VariantProps<T, B> = {} as VariantProps<T, B>,\n\t) => {\n\t\tconst responsiveClasses = processVariantProps(props, variants, slotName);\n\n\t\tconst compoundClasses = compoundVariants?.map(\n\t\t\t({\n\t\t\t\tclass: classFromCompound,\n\t\t\t\tclassName: classNameFromCompound,\n\t\t\t\t...compound\n\t\t\t}) => {\n\t\t\t\tif (matchesCompoundVariant(compound, props)) {\n\t\t\t\t\treturn [\n\t\t\t\t\t\tgetCompoundVariantSlotClass(classFromCompound, slotName),\n\t\t\t\t\t\tgetCompoundVariantSlotClass(classNameFromCompound, slotName),\n\t\t\t\t\t];\n\t\t\t\t}\n\t\t\t\treturn undefined;\n\t\t\t},\n\t\t);\n\n\t\tconst classes = clsx(\n\t\t\tslotConfig,\n\t\t\tresponsiveClasses,\n\t\t\tcompoundClasses,\n\t\t\tclassName,\n\t\t\tclassFromProps,\n\t\t);\n\t\treturn onComplete ? onComplete(classes) : classes;\n\t};\n"]}

package/dist/index.d.ts

@@ -1,117 +1,3 @@
-export type DefaultBreakpoints = "sm" | "md" | "lg" | "xl";
-export type Breakpoints = DefaultBreakpoints;
-export type BreakpointsMap<V, B extends string = DefaultBreakpoints> = {
-    initial: V;
-} & Partial<{
-    [breakpoint in B]: V;
-}>;
-export type ResponsiveValue<T, B extends string = DefaultBreakpoints> = T | BreakpointsMap<T, B>;
-/**
- * Maps a ResponsiveValue to a new ResponsiveValue using the provided mapper function. Singular values are passed through as is.
- *
- * @template V The type of the original value
- * @template T The type of the mapped value
- * @template B The type of breakpoints
- * @param {ResponsiveValue<V, B>} value - The original ResponsiveValue to be mapped
- * @param {function(V): T} mapper - A function that maps a ResponsiveValue to a new ResponsiveValue
- * @returns {ResponsiveValue<T, B>} A new ResponsiveValue with the mapped values
- *
- *
- * @example
- * const sizes = {
- *  initial: 'md',
- *  sm: 'lg',
- * }
- *
- * const output = mapResponsiveValue(sizes, size => {
- *	switch (size) {
- *		case 'initial':
- *		return 'sm';
- *		case 'sm':
- *			return 'md';
- *		}
- *	});
- *
- * // console.log(output)
- * {
- *	initial: 'sm',
- *	sm: 'md',
- * }
- */
-export declare const mapResponsiveValue: <V, T, B extends string = DefaultBreakpoints>(value: ResponsiveValue<V, B>, mapper: (value: V) => T) => ResponsiveValue<T, B>;
-/**
- * Start of rcv and types
- */
-type ClassValue = string | ReadonlyArray<string>;
-type ValueType = ClassValue | Record<string, ClassValue>;
-type VariantValue = Record<string, ValueType>;
-type VariantConfig = Record<string, VariantValue>;
-type StringBoolean = "true" | "false";
-type BooleanVariant = Partial<Record<StringBoolean, ClassValue | Record<string, ClassValue>>>;
-type VariantPropValue<T, B extends string> = T extends BooleanVariant ? ResponsiveValue<boolean, B> | undefined : T extends Record<string, unknown> ? ResponsiveValue<keyof T, B> : never;
-type VariantPropsBase<T extends VariantConfig, B extends string> = {
-    [K in keyof T]?: VariantPropValue<T[K], B>;
-};
-type VariantProps<T extends VariantConfig, B extends string> = VariantPropsBase<T, B> & {
-    className?: string;
-    class?: string;
-};
-type SlotConfig = ClassValue;
-type CompoundVariantClassValue<S extends string> = string | Partial<Record<S, ClassValue>>;
-type CompoundVariantWithSlots<T extends VariantConfig, S extends string, B extends string> = Partial<Omit<VariantProps<T, B>, "class" | "className">> & {
-    class?: CompoundVariantClassValue<S>;
-    className?: CompoundVariantClassValue<S>;
-};
-export declare function rcv<T extends VariantConfig = Record<never, VariantValue>, S extends Record<string, SlotConfig> = Record<string, SlotConfig>, B extends string = DefaultBreakpoints>(config: {
-    slots: S;
-    variants?: T;
-    compoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];
-    onComplete?: (classes: string) => string;
-}): () => {
-    [K in keyof S]: (props?: VariantProps<T, B>) => string;
-};
-export declare function rcv<T extends VariantConfig = Record<never, VariantValue>, B extends string = DefaultBreakpoints>(config: {
-    base: string;
-    variants?: T;
-    compoundVariants?: Partial<VariantProps<T, B>>[];
-    onComplete?: (classes: string) => string;
-}): (props?: VariantProps<T, B>) => string;
-/**
- * Creates a custom rcv function with custom breakpoints and an optional onComplete callback
- *
- * @template B - The custom breakpoints type
- * @param breakpoints - Optional array of custom breakpoint names
- * @param onComplete - Optional callback function that receives the generated classes and returns the final classes
- * @returns A function that creates rcv with custom breakpoints
- *
- * @example
- * const customRcv = createRcv(['mobile', 'tablet', 'desktop']);
- *
- * const getButtonVariants = customRcv({
- *   base: "px-4 py-2 rounded",
- *   variants: {
- *     intent: {
- *       primary: "bg-blue-500 text-white",
- *       secondary: "bg-gray-200 text-gray-800"
- *     }
- *   }
- * });
- *
- * // Usage with custom breakpoints:
- * getButtonVariants({ intent: { initial: "primary", mobile: "secondary", desktop: "primary" } })
- */
-export declare const createRcv: <B extends string>(_breakpoints?: readonly B[], onComplete?: (classes: string) => string) => {
-    <T extends VariantConfig = Record<never, VariantValue>, S extends Record<string, SlotConfig> = Record<string, ClassValue>>(config: {
-        slots: S;
-        variants?: T;
-        compoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];
-        onComplete?: (classes: string) => string;
-    }): () => { [K in keyof S]: (props?: VariantProps<T, B>) => string; };
-    <T extends VariantConfig = Record<never, VariantValue>>(config: {
-        base: string;
-        variants?: T;
-        compoundVariants?: Partial<VariantProps<T, B>>[];
-        onComplete?: (classes: string) => string;
-    }): (props?: VariantProps<T, B>) => string;
-};
-export {};
+export { mapResponsiveValue } from "./helpers.js";
+export { createRcv, rcv } from "./rcv.js";
+export type { Breakpoints, BreakpointsMap, DefaultBreakpoints, ResponsiveValue, } from "./types.js";

package/dist/index.js

@@ -1,208 +1,3 @@
-import { clsx } from "clsx";
-const isSingularValue = (value) => !isBreakpointsMap(value);
-const isBreakpointsMap = (value) => typeof value === "object" && value != null && !Array.isArray(value);
-/**
- * Maps a ResponsiveValue to a new ResponsiveValue using the provided mapper function. Singular values are passed through as is.
- *
- * @template V The type of the original value
- * @template T The type of the mapped value
- * @template B The type of breakpoints
- * @param {ResponsiveValue<V, B>} value - The original ResponsiveValue to be mapped
- * @param {function(V): T} mapper - A function that maps a ResponsiveValue to a new ResponsiveValue
- * @returns {ResponsiveValue<T, B>} A new ResponsiveValue with the mapped values
- *
- *
- * @example
- * const sizes = {
- *  initial: 'md',
- *  sm: 'lg',
- * }
- *
- * const output = mapResponsiveValue(sizes, size => {
- *	switch (size) {
- *		case 'initial':
- *		return 'sm';
- *		case 'sm':
- *			return 'md';
- *		}
- *	});
- *
- * // console.log(output)
- * {
- *	initial: 'sm',
- *	sm: 'md',
- * }
- */
-export const mapResponsiveValue = (value, mapper) => {
-    if (isSingularValue(value)) {
-        return mapper(value);
-    }
-    const result = {};
-    for (const key of Object.keys(value)) {
-        result[key] = mapper(value[key]);
-    }
-    return result;
-};
-// Helper functions for slots
-const isSlotsConfig = (config) => {
-    return "slots" in config;
-};
-const normalizeClassValue = (value) => {
-    if (Array.isArray(value)) {
-        return value.join(" ");
-    }
-    if (typeof value === "string") {
-        return value;
-    }
-    return undefined;
-};
-const prefixClasses = (classes, prefix) => classes.replace(/(\S+)/g, `${prefix}:$1`);
-// Helper function to get variant value for a specific slot or base
-const getVariantValue = (variants, key, value, slotName) => {
-    const variantValue = variants?.[key]?.[value];
-    // Early return if no variant value found
-    if (variantValue == null)
-        return undefined;
-    // Handle string or array values directly
-    if (typeof variantValue === "string" || Array.isArray(variantValue)) {
-        return normalizeClassValue(variantValue);
-    }
-    // Handle slot-specific values (object with slot keys)
-    if (slotName && slotName in variantValue) {
-        return normalizeClassValue(variantValue[slotName]);
-    }
-    return undefined;
-};
-// Helper function to process responsive values
-const processResponsiveValue = (variants, key, value, slotName) => {
-    return Object.entries(value).map(([breakpoint, breakpointValue]) => {
-        const variantValue = getVariantValue(variants, key, breakpointValue, slotName);
-        if (!variantValue)
-            return undefined;
-        // If the breakpoint is initial, return without prefix
-        if (breakpoint === "initial") {
-            return variantValue;
-        }
-        // Otherwise, return with breakpoint prefix
-        return prefixClasses(variantValue, breakpoint);
-    });
-};
-// Helper function to process variant props into classes
-const processVariantProps = (props, variants, slotName) => {
-    return Object.entries(props).map(([key, propValue]) => {
-        const value = typeof propValue === "boolean" ? String(propValue) : propValue;
-        // Handle undefined values
-        if (!value)
-            return undefined;
-        // Handle singular values
-        if (typeof value === "string") {
-            return getVariantValue(variants, key, value, slotName);
-        }
-        // Handle responsive values
-        return processResponsiveValue(variants, key, value, slotName);
-    });
-};
-// Helper function to match compound variants
-const matchesCompoundVariant = (compound, props) => {
-    return Object.entries(compound).every(([key, value]) => {
-        const propValue = props[key];
-        // Direct comparison first, then try string conversion for boolean handling
-        return propValue === value || propValue === String(value);
-    });
-};
-// Helper function to extract class value from compound variant class prop
-const getCompoundVariantSlotClass = (classValue, slotName) => {
-    if (!classValue)
-        return undefined;
-    if (typeof classValue === "object" && classValue[slotName]) {
-        return normalizeClassValue(classValue[slotName]);
-    }
-    if (typeof classValue === "string") {
-        return classValue;
-    }
-    return undefined;
-};
-const createSlotFunction = (slotConfig, variants, compoundVariants, onComplete, slotName) => ({ className, class: classFromProps, ...props } = {}) => {
-    const responsiveClasses = processVariantProps(props, variants, slotName);
-    const compoundClasses = compoundVariants?.map(({ class: classFromCompound, className: classNameFromCompound, ...compound }) => {
-        if (matchesCompoundVariant(compound, props)) {
-            return [
-                getCompoundVariantSlotClass(classFromCompound, slotName),
-                getCompoundVariantSlotClass(classNameFromCompound, slotName),
-            ];
-        }
-        return undefined;
-    });
-    const classes = clsx(slotConfig, responsiveClasses, compoundClasses, className, classFromProps);
-    return onComplete ? onComplete(classes) : classes;
-};
-export function rcv(config) {
-    // Check if config is a slots config
-    if (isSlotsConfig(config)) {
-        const { slots, variants, compoundVariants, onComplete } = config;
-        return () => {
-            const slotFunctions = {};
-            // Create slot functions for each slot - ensure all slots are always present
-            for (const [slotName, slotConfig] of Object.entries(slots)) {
-                const slotFunction = createSlotFunction(slotConfig, variants, compoundVariants, onComplete, slotName);
-                slotFunctions[slotName] = slotFunction;
-            }
-            return slotFunctions;
-        };
-    }
-    // If config is not a slots config, create a base function
-    const { base, variants, compoundVariants, onComplete } = config;
-    return ({ className, class: classFromProps, ...props } = {}) => {
-        const responsiveClasses = processVariantProps(props, variants);
-        const compoundClasses = compoundVariants?.map(({ className: compoundClassName, ...compound }) => {
-            if (matchesCompoundVariant(compound, props)) {
-                return compoundClassName;
-            }
-            return undefined;
-        });
-        const classes = clsx(base, responsiveClasses, compoundClasses, className, classFromProps);
-        return onComplete ? onComplete(classes) : classes;
-    };
-}
-/**
- * Creates a custom rcv function with custom breakpoints and an optional onComplete callback
- *
- * @template B - The custom breakpoints type
- * @param breakpoints - Optional array of custom breakpoint names
- * @param onComplete - Optional callback function that receives the generated classes and returns the final classes
- * @returns A function that creates rcv with custom breakpoints
- *
- * @example
- * const customRcv = createRcv(['mobile', 'tablet', 'desktop']);
- *
- * const getButtonVariants = customRcv({
- *   base: "px-4 py-2 rounded",
- *   variants: {
- *     intent: {
- *       primary: "bg-blue-500 text-white",
- *       secondary: "bg-gray-200 text-gray-800"
- *     }
- *   }
- * });
- *
- * // Usage with custom breakpoints:
- * getButtonVariants({ intent: { initial: "primary", mobile: "secondary", desktop: "primary" } })
- */
-export const createRcv = (_breakpoints, onComplete) => {
-    function customRcv(config) {
-        if (isSlotsConfig(config)) {
-            return rcv({
-                ...config,
-                onComplete: onComplete || config.onComplete,
-            });
-        }
-        else {
-            return rcv({
-                ...config,
-                onComplete: onComplete || config.onComplete,
-            });
-        }
-    }
-    return customRcv;
-};
+export { mapResponsiveValue } from "./helpers.js";
+export { createRcv, rcv } from "./rcv.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"/","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import { clsx } from \"clsx\";\n\nexport type DefaultBreakpoints = \"sm\" | \"md\" | \"lg\" | \"xl\";\nexport type Breakpoints = DefaultBreakpoints;\n\nexport type BreakpointsMap<V, B extends string = DefaultBreakpoints> = {\n\tinitial: V;\n} & Partial<{\n\t[breakpoint in B]: V;\n}>;\n\nexport type ResponsiveValue<T, B extends string = DefaultBreakpoints> =\n\t| T\n\t| BreakpointsMap<T, B>;\n\nconst isSingularValue = <A, B extends string>(\n\tvalue: ResponsiveValue<A, B>,\n): value is A => !isBreakpointsMap(value);\n\nconst isBreakpointsMap = <A, B extends string>(\n\tvalue: ResponsiveValue<A, B>,\n): value is BreakpointsMap<A, B> =>\n\ttypeof value === \"object\" && value != null && !Array.isArray(value);\n\n/**\n * Maps a ResponsiveValue to a new ResponsiveValue using the provided mapper function. Singular values are passed through as is.\n *\n * @template V The type of the original value\n * @template T The type of the mapped value\n * @template B The type of breakpoints\n * @param {ResponsiveValue<V, B>} value - The original ResponsiveValue to be mapped\n * @param {function(V): T} mapper - A function that maps a ResponsiveValue to a new ResponsiveValue\n * @returns {ResponsiveValue<T, B>} A new ResponsiveValue with the mapped values\n *\n *\n * @example\n * const sizes = {\n *  initial: 'md',\n *  sm: 'lg',\n * }\n *\n * const output = mapResponsiveValue(sizes, size => {\n *\tswitch (size) {\n *\t\tcase 'initial':\n *\t\treturn 'sm';\n *\t\tcase 'sm':\n *\t\t\treturn 'md';\n *\t\t}\n *\t});\n *\n * // console.log(output)\n * {\n *\tinitial: 'sm',\n *\tsm: 'md',\n * }\n */\nexport const mapResponsiveValue = <V, T, B extends string = DefaultBreakpoints>(\n\tvalue: ResponsiveValue<V, B>,\n\tmapper: (value: V) => T,\n): ResponsiveValue<T, B> => {\n\tif (isSingularValue(value)) {\n\t\treturn mapper(value);\n\t}\n\n\tconst result: Record<string, T> = {};\n\tfor (const key of Object.keys(value)) {\n\t\tresult[key] = mapper(value[key as keyof typeof value] as V);\n\t}\n\treturn result as BreakpointsMap<T, B>;\n};\n\n/**\n * Start of rcv and types\n */\n\ntype ClassValue = string | ReadonlyArray<string>;\n\ntype ValueType = ClassValue | Record<string, ClassValue>;\n\ntype VariantValue = Record<string, ValueType>;\ntype VariantConfig = Record<string, VariantValue>;\n\ntype StringBoolean = \"true\" | \"false\";\ntype BooleanVariant = Partial<\n\tRecord<StringBoolean, ClassValue | Record<string, ClassValue>>\n>;\n\ntype VariantPropValue<T, B extends string> = T extends BooleanVariant\n\t? ResponsiveValue<boolean, B> | undefined\n\t: T extends Record<string, unknown>\n\t\t? ResponsiveValue<keyof T, B>\n\t\t: never;\n\ntype VariantPropsBase<T extends VariantConfig, B extends string> = {\n\t[K in keyof T]?: VariantPropValue<T[K], B>;\n};\n\ntype VariantProps<T extends VariantConfig, B extends string> = VariantPropsBase<\n\tT,\n\tB\n> & {\n\tclassName?: string;\n\tclass?: string;\n};\n\n// Slot configuration types\ntype SlotConfig = ClassValue;\n\ntype SlotsConfig<S extends Record<string, SlotConfig>> = S;\n\ntype CompoundVariantClassValue<S extends string> =\n\t| string\n\t| Partial<Record<S, ClassValue>>;\n\ntype CompoundVariantWithSlots<\n\tT extends VariantConfig,\n\tS extends string,\n\tB extends string,\n> = Partial<Omit<VariantProps<T, B>, \"class\" | \"className\">> & {\n\tclass?: CompoundVariantClassValue<S>;\n\tclassName?: CompoundVariantClassValue<S>;\n};\n\ntype ResponsiveClassesConfigBase<T extends VariantConfig, B extends string> = {\n\tbase: string;\n\tvariants?: T;\n\tcompoundVariants?: Partial<VariantProps<T, B>>[];\n\tonComplete?: (classes: string) => string;\n};\n\ntype ResponsiveClassesConfigSlots<\n\tT extends VariantConfig,\n\tS extends Record<string, SlotConfig>,\n\tB extends string,\n> = {\n\tslots: SlotsConfig<S>;\n\tvariants?: T;\n\tcompoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];\n\tonComplete?: (classes: string) => string;\n};\n\ntype ResponsiveClassesConfig<T extends VariantConfig, B extends string> =\n\t| ResponsiveClassesConfigBase<T, B>\n\t| ResponsiveClassesConfigSlots<T, Record<string, SlotConfig>, B>;\n\n// Helper functions for slots\nconst isSlotsConfig = <T extends VariantConfig, B extends string>(\n\tconfig: ResponsiveClassesConfig<T, B>,\n): config is ResponsiveClassesConfigSlots<T, Record<string, SlotConfig>, B> => {\n\treturn \"slots\" in config;\n};\n\nconst normalizeClassValue = (value: ClassValue | undefined) => {\n\tif (Array.isArray(value)) {\n\t\treturn value.join(\" \");\n\t}\n\tif (typeof value === \"string\") {\n\t\treturn value;\n\t}\n\treturn undefined;\n};\n\nconst prefixClasses = (classes: string, prefix: string) =>\n\tclasses.replace(/(\\S+)/g, `${prefix}:$1`);\n\n// Helper function to get variant value for a specific slot or base\nconst getVariantValue = <T extends VariantConfig>(\n\tvariants: T | undefined,\n\tkey: keyof T,\n\tvalue: string,\n\tslotName?: string,\n): string | undefined => {\n\tconst variantValue = variants?.[key]?.[value];\n\n\t// Early return if no variant value found\n\tif (variantValue == null) return undefined;\n\n\t// Handle string or array values directly\n\tif (typeof variantValue === \"string\" || Array.isArray(variantValue)) {\n\t\treturn normalizeClassValue(variantValue);\n\t}\n\n\t// Handle slot-specific values (object with slot keys)\n\tif (slotName && slotName in variantValue) {\n\t\treturn normalizeClassValue(\n\t\t\t(variantValue as Record<string, ClassValue>)[slotName],\n\t\t);\n\t}\n\n\treturn undefined;\n};\n\n// Helper function to process responsive values\nconst processResponsiveValue = <T extends VariantConfig, B extends string>(\n\tvariants: T | undefined,\n\tkey: keyof T,\n\tvalue: Partial<BreakpointsMap<T, B>>,\n\tslotName?: string,\n) => {\n\treturn Object.entries(value).map(([breakpoint, breakpointValue]) => {\n\t\tconst variantValue = getVariantValue(\n\t\t\tvariants,\n\t\t\tkey,\n\t\t\tbreakpointValue as string,\n\t\t\tslotName,\n\t\t);\n\n\t\tif (!variantValue) return undefined;\n\n\t\t// If the breakpoint is initial, return without prefix\n\t\tif (breakpoint === \"initial\") {\n\t\t\treturn variantValue;\n\t\t}\n\n\t\t// Otherwise, return with breakpoint prefix\n\t\treturn prefixClasses(variantValue, breakpoint);\n\t});\n};\n\n// Helper function to process variant props into classes\nconst processVariantProps = <T extends VariantConfig, B extends string>(\n\tprops: Omit<VariantProps<T, B>, \"className\" | \"class\">,\n\tvariants: T | undefined,\n\tslotName?: string,\n) => {\n\treturn Object.entries(props).map(\n\t\t([key, propValue]: [keyof T, VariantPropValue<T[keyof T], B>]) => {\n\t\t\tconst value =\n\t\t\t\ttypeof propValue === \"boolean\" ? String(propValue) : propValue;\n\n\t\t\t// Handle undefined values\n\t\t\tif (!value) return undefined;\n\n\t\t\t// Handle singular values\n\t\t\tif (typeof value === \"string\") {\n\t\t\t\treturn getVariantValue(variants, key, value, slotName);\n\t\t\t}\n\n\t\t\t// Handle responsive values\n\t\t\treturn processResponsiveValue(\n\t\t\t\tvariants,\n\t\t\t\tkey,\n\t\t\t\tvalue as Partial<BreakpointsMap<T, B>>,\n\t\t\t\tslotName,\n\t\t\t);\n\t\t},\n\t);\n};\n\n// Helper function to match compound variants\nconst matchesCompoundVariant = <T extends VariantConfig, B extends string>(\n\tcompound: Omit<CompoundVariantWithSlots<T, string, B>, \"className\" | \"class\">,\n\tprops: Omit<VariantProps<T, B>, \"className\" | \"class\">,\n) => {\n\treturn Object.entries(compound).every(([key, value]) => {\n\t\tconst propValue = props[key as keyof typeof props];\n\t\t// Direct comparison first, then try string conversion for boolean handling\n\t\treturn propValue === value || propValue === String(value);\n\t});\n};\n\n// Helper function to extract class value from compound variant class prop\nconst getCompoundVariantSlotClass = <S extends string>(\n\tclassValue: CompoundVariantClassValue<S> | undefined,\n\tslotName: string,\n): string | undefined => {\n\tif (!classValue) return undefined;\n\n\tif (typeof classValue === \"object\" && classValue[slotName as S]) {\n\t\treturn normalizeClassValue(classValue[slotName as S]);\n\t}\n\n\tif (typeof classValue === \"string\") {\n\t\treturn classValue;\n\t}\n\n\treturn undefined;\n};\n\nconst createSlotFunction =\n\t<T extends VariantConfig, B extends string>(\n\t\tslotConfig: SlotConfig,\n\t\tvariants: T | undefined,\n\t\tcompoundVariants: CompoundVariantWithSlots<T, string, B>[] | undefined,\n\t\tonComplete: ((classes: string) => string) | undefined,\n\t\tslotName: string,\n\t) =>\n\t(\n\t\t{\n\t\t\tclassName,\n\t\t\tclass: classFromProps,\n\t\t\t...props\n\t\t}: VariantProps<T, B> = {} as VariantProps<T, B>,\n\t) => {\n\t\tconst responsiveClasses = processVariantProps(props, variants, slotName);\n\n\t\tconst compoundClasses = compoundVariants?.map(\n\t\t\t({\n\t\t\t\tclass: classFromCompound,\n\t\t\t\tclassName: classNameFromCompound,\n\t\t\t\t...compound\n\t\t\t}) => {\n\t\t\t\tif (matchesCompoundVariant(compound, props)) {\n\t\t\t\t\treturn [\n\t\t\t\t\t\tgetCompoundVariantSlotClass(classFromCompound, slotName),\n\t\t\t\t\t\tgetCompoundVariantSlotClass(classNameFromCompound, slotName),\n\t\t\t\t\t];\n\t\t\t\t}\n\t\t\t\treturn undefined;\n\t\t\t},\n\t\t);\n\n\t\tconst classes = clsx(\n\t\t\tslotConfig,\n\t\t\tresponsiveClasses,\n\t\t\tcompoundClasses,\n\t\t\tclassName,\n\t\t\tclassFromProps,\n\t\t);\n\t\treturn onComplete ? onComplete(classes) : classes;\n\t};\n\n// Function overloads for rcv\nexport function rcv<\n\tT extends VariantConfig = Record<never, VariantValue>,\n\tS extends Record<string, SlotConfig> = Record<string, SlotConfig>,\n\tB extends string = DefaultBreakpoints,\n>(config: {\n\tslots: S;\n\tvariants?: T;\n\tcompoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];\n\tonComplete?: (classes: string) => string;\n}): () => {\n\t[K in keyof S]: (props?: VariantProps<T, B>) => string;\n};\n\nexport function rcv<\n\tT extends VariantConfig = Record<never, VariantValue>,\n\tB extends string = DefaultBreakpoints,\n>(config: {\n\tbase: string;\n\tvariants?: T;\n\tcompoundVariants?: Partial<VariantProps<T, B>>[];\n\tonComplete?: (classes: string) => string;\n}): (props?: VariantProps<T, B>) => string;\n\nexport function rcv<\n\tT extends VariantConfig = Record<never, VariantValue>,\n\tS extends Record<string, SlotConfig> = Record<string, SlotConfig>,\n\tB extends string = DefaultBreakpoints,\n>(\n\tconfig:\n\t\t| ResponsiveClassesConfig<T, B>\n\t\t| {\n\t\t\t\tslots: S;\n\t\t\t\tvariants?: T;\n\t\t\t\tcompoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];\n\t\t\t\tonComplete?: (classes: string) => string;\n\t\t  },\n) {\n\t// Check if config is a slots config\n\tif (isSlotsConfig(config)) {\n\t\tconst { slots, variants, compoundVariants, onComplete } = config;\n\t\treturn () => {\n\t\t\tconst slotFunctions = {} as {\n\t\t\t\t[K in keyof S]: (props?: VariantProps<T, B>) => string;\n\t\t\t};\n\n\t\t\t// Create slot functions for each slot - ensure all slots are always present\n\t\t\tfor (const [slotName, slotConfig] of Object.entries(slots)) {\n\t\t\t\tconst slotFunction = createSlotFunction<T, B>(\n\t\t\t\t\tslotConfig,\n\t\t\t\t\tvariants,\n\t\t\t\t\tcompoundVariants,\n\t\t\t\t\tonComplete,\n\t\t\t\t\tslotName,\n\t\t\t\t);\n\n\t\t\t\tslotFunctions[slotName as keyof S] = slotFunction;\n\t\t\t}\n\n\t\t\treturn slotFunctions;\n\t\t};\n\t}\n\n\t// If config is not a slots config, create a base function\n\tconst { base, variants, compoundVariants, onComplete } = config;\n\treturn (\n\t\t{\n\t\t\tclassName,\n\t\t\tclass: classFromProps,\n\t\t\t...props\n\t\t}: VariantProps<T, B> = {} as VariantProps<T, B>,\n\t) => {\n\t\tconst responsiveClasses = processVariantProps(props, variants);\n\n\t\tconst compoundClasses = compoundVariants?.map(\n\t\t\t({ className: compoundClassName, ...compound }) => {\n\t\t\t\tif (\n\t\t\t\t\tmatchesCompoundVariant(\n\t\t\t\t\t\tcompound as Omit<\n\t\t\t\t\t\t\tCompoundVariantWithSlots<T, string, B>,\n\t\t\t\t\t\t\t\"className\" | \"class\"\n\t\t\t\t\t\t>,\n\t\t\t\t\t\tprops,\n\t\t\t\t\t)\n\t\t\t\t) {\n\t\t\t\t\treturn compoundClassName;\n\t\t\t\t}\n\t\t\t\treturn undefined;\n\t\t\t},\n\t\t);\n\n\t\tconst classes = clsx(\n\t\t\tbase,\n\t\t\tresponsiveClasses,\n\t\t\tcompoundClasses,\n\t\t\tclassName,\n\t\t\tclassFromProps,\n\t\t);\n\t\treturn onComplete ? onComplete(classes) : classes;\n\t};\n}\n\n/**\n * Creates a custom rcv function with custom breakpoints and an optional onComplete callback\n *\n * @template B - The custom breakpoints type\n * @param breakpoints - Optional array of custom breakpoint names\n * @param onComplete - Optional callback function that receives the generated classes and returns the final classes\n * @returns A function that creates rcv with custom breakpoints\n *\n * @example\n * const customRcv = createRcv(['mobile', 'tablet', 'desktop']);\n *\n * const getButtonVariants = customRcv({\n *   base: \"px-4 py-2 rounded\",\n *   variants: {\n *     intent: {\n *       primary: \"bg-blue-500 text-white\",\n *       secondary: \"bg-gray-200 text-gray-800\"\n *     }\n *   }\n * });\n *\n * // Usage with custom breakpoints:\n * getButtonVariants({ intent: { initial: \"primary\", mobile: \"secondary\", desktop: \"primary\" } })\n */\n\nexport const createRcv = <B extends string>(\n\t_breakpoints?: readonly B[],\n\tonComplete?: (classes: string) => string,\n) => {\n\tfunction customRcv<\n\t\tT extends VariantConfig = Record<never, VariantValue>,\n\t\tS extends Record<string, SlotConfig> = Record<string, SlotConfig>,\n\t>(config: {\n\t\tslots: S;\n\t\tvariants?: T;\n\t\tcompoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];\n\t\tonComplete?: (classes: string) => string;\n\t}): () => {\n\t\t[K in keyof S]: (props?: VariantProps<T, B>) => string;\n\t};\n\n\tfunction customRcv<\n\t\tT extends VariantConfig = Record<never, VariantValue>,\n\t>(config: {\n\t\tbase: string;\n\t\tvariants?: T;\n\t\tcompoundVariants?: Partial<VariantProps<T, B>>[];\n\t\tonComplete?: (classes: string) => string;\n\t}): (props?: VariantProps<T, B>) => string;\n\n\tfunction customRcv<\n\t\tT extends VariantConfig = Record<never, VariantValue>,\n\t\tS extends Record<string, SlotConfig> = Record<string, SlotConfig>,\n\t>(\n\t\tconfig:\n\t\t\t| ResponsiveClassesConfig<T, B>\n\t\t\t| {\n\t\t\t\t\tslots: S;\n\t\t\t\t\tvariants?: T;\n\t\t\t\t\tcompoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];\n\t\t\t\t\tonComplete?: (classes: string) => string;\n\t\t\t  },\n\t) {\n\t\tif (isSlotsConfig(config)) {\n\t\t\treturn rcv<T, S, B>({\n\t\t\t\t...config,\n\t\t\t\tonComplete: onComplete || config.onComplete,\n\t\t\t} as {\n\t\t\t\tslots: S;\n\t\t\t\tvariants?: T;\n\t\t\t\tcompoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];\n\t\t\t\tonComplete?: (classes: string) => string;\n\t\t\t});\n\t\t} else {\n\t\t\treturn rcv<T, B>({\n\t\t\t\t...config,\n\t\t\t\tonComplete: onComplete || config.onComplete,\n\t\t\t});\n\t\t}\n\t}\n\n\treturn customRcv;\n};\n"]}
+{"version":3,"file":"index.js","sourceRoot":"/","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC","sourcesContent":["export { mapResponsiveValue } from \"./helpers\";\nexport { createRcv, rcv } from \"./rcv\";\nexport type {\n\tBreakpoints,\n\tBreakpointsMap,\n\tDefaultBreakpoints,\n\tResponsiveValue,\n} from \"./types\";\n"]}

package/dist/rcv.d.ts

@@ -0,0 +1,67 @@
+import type { CompoundVariantWithSlots, DefaultBreakpoints, SlotConfig, VariantConfig, VariantProps, VariantValue } from "./types.js";
+/**
+ * Builds responsive class strings from a config object.
+ *
+ * Pass **`breakpoints`** as a `const` tuple (e.g. `['mobile', 'tablet'] as const`) only when you want
+ * TypeScript to infer custom breakpoint names for responsive props. It is not read at runtime.
+ * Omit it to use the default `sm` / `md` / `lg` / `xl` breakpoints.
+ */
+export declare function rcv<T extends VariantConfig = Record<never, VariantValue>, S extends Record<string, SlotConfig> = Record<string, SlotConfig>, B extends string = DefaultBreakpoints>(config: {
+    slots: S;
+    variants?: T;
+    compoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];
+    breakpoints?: readonly B[];
+    onComplete?: (classes: string) => string;
+}): () => {
+    [K in keyof S]: (props?: VariantProps<T, B>) => string;
+};
+export declare function rcv<T extends VariantConfig = Record<never, VariantValue>, B extends string = DefaultBreakpoints>(config: {
+    base: string;
+    variants?: T;
+    compoundVariants?: Partial<VariantProps<T, B>>[];
+    breakpoints?: readonly B[];
+    onComplete?: (classes: string) => string;
+}): (props?: VariantProps<T, B>) => string;
+/**
+ * Returns an `rcv` that uses custom breakpoint names for typing.
+ *
+ * The first argument is **type-only** (not read at runtime): it lets TypeScript infer `B`.
+ * You can get the same effect with {@link rcv} by passing `breakpoints: ['mobile', 'tablet'] as const` on the config object.
+ *
+ * @template B - The custom breakpoints type
+ * @param breakpoints - Optional tuple of custom breakpoint names (for inference only)
+ * @param onComplete - Optional callback applied to the merged class string
+ * @returns An `rcv` function whose props use `B` for responsive keys
+ *
+ * @example
+ * const customRcv = createRcv(['mobile', 'tablet', 'desktop']);
+ *
+ * const getButtonVariants = customRcv({
+ *   base: "px-4 py-2 rounded",
+ *   variants: {
+ *     intent: {
+ *       primary: "bg-blue-500 text-white",
+ *       secondary: "bg-gray-200 text-gray-800"
+ *     }
+ *   }
+ * });
+ *
+ * // Usage with custom breakpoints:
+ * getButtonVariants({ intent: { initial: "primary", mobile: "secondary", desktop: "primary" } })
+ */
+export declare const createRcv: <B extends string>(_breakpoints?: readonly B[], onComplete?: (classes: string) => string) => {
+    <T extends VariantConfig = Record<never, VariantValue>, S extends Record<string, SlotConfig> = Record<string, import("./types.js").ClassValue>>(config: {
+        slots: S;
+        variants?: T;
+        compoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];
+        breakpoints?: readonly B[];
+        onComplete?: (classes: string) => string;
+    }): () => { [K in keyof S]: (props?: VariantProps<T, B>) => string; };
+    <T extends VariantConfig = Record<never, VariantValue>>(config: {
+        base: string;
+        variants?: T;
+        compoundVariants?: Partial<VariantProps<T, B>>[];
+        breakpoints?: readonly B[];
+        onComplete?: (classes: string) => string;
+    }): (props?: VariantProps<T, B>) => string;
+};

package/dist/rcv.js

@@ -0,0 +1,75 @@
+import { clsx } from "clsx";
+import { createSlotFunction, isSlotsConfig, matchesCompoundVariant, processVariantProps, } from "./helpers.js";
+export function rcv(config) {
+    // Check if config is a slots config
+    if (isSlotsConfig(config)) {
+        const { slots, variants, compoundVariants, onComplete } = config;
+        return () => {
+            const slotFunctions = {};
+            // Create slot functions for each slot - ensure all slots are always present
+            for (const [slotName, slotConfig] of Object.entries(slots)) {
+                const slotFunction = createSlotFunction(slotConfig, variants, compoundVariants, onComplete, slotName);
+                slotFunctions[slotName] = slotFunction;
+            }
+            return slotFunctions;
+        };
+    }
+    // If config is not a slots config, create a base function
+    const { base, variants, compoundVariants, onComplete } = config;
+    return ({ className, class: classFromProps, ...props } = {}) => {
+        const responsiveClasses = processVariantProps(props, variants);
+        const compoundClasses = compoundVariants?.map(({ className: compoundClassName, ...compound }) => {
+            if (matchesCompoundVariant(compound, props)) {
+                return compoundClassName;
+            }
+            return undefined;
+        });
+        const classes = clsx(base, responsiveClasses, compoundClasses, className, classFromProps);
+        return onComplete ? onComplete(classes) : classes;
+    };
+}
+/**
+ * Returns an `rcv` that uses custom breakpoint names for typing.
+ *
+ * The first argument is **type-only** (not read at runtime): it lets TypeScript infer `B`.
+ * You can get the same effect with {@link rcv} by passing `breakpoints: ['mobile', 'tablet'] as const` on the config object.
+ *
+ * @template B - The custom breakpoints type
+ * @param breakpoints - Optional tuple of custom breakpoint names (for inference only)
+ * @param onComplete - Optional callback applied to the merged class string
+ * @returns An `rcv` function whose props use `B` for responsive keys
+ *
+ * @example
+ * const customRcv = createRcv(['mobile', 'tablet', 'desktop']);
+ *
+ * const getButtonVariants = customRcv({
+ *   base: "px-4 py-2 rounded",
+ *   variants: {
+ *     intent: {
+ *       primary: "bg-blue-500 text-white",
+ *       secondary: "bg-gray-200 text-gray-800"
+ *     }
+ *   }
+ * });
+ *
+ * // Usage with custom breakpoints:
+ * getButtonVariants({ intent: { initial: "primary", mobile: "secondary", desktop: "primary" } })
+ */
+export const createRcv = (_breakpoints, onComplete) => {
+    function customRcv(config) {
+        if (isSlotsConfig(config)) {
+            return rcv({
+                ...config,
+                onComplete: onComplete || config.onComplete,
+            });
+        }
+        else {
+            return rcv({
+                ...config,
+                onComplete: onComplete || config.onComplete,
+            });
+        }
+    }
+    return customRcv;
+};
+//# sourceMappingURL=rcv.js.map

package/dist/rcv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rcv.js","sourceRoot":"/","sources":["rcv.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EACN,kBAAkB,EAClB,aAAa,EACb,sBAAsB,EACtB,mBAAmB,GACnB,MAAM,WAAW,CAAC;AA4CnB,MAAM,UAAU,GAAG,CAKlB,MAQI;IAEJ,oCAAoC;IACpC,IAAI,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;QAC3B,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;QACjE,OAAO,GAAG,EAAE;YACX,MAAM,aAAa,GAAG,EAErB,CAAC;YAEF,4EAA4E;YAC5E,KAAK,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC5D,MAAM,YAAY,GAAG,kBAAkB,CACtC,UAAU,EACV,QAAQ,EACR,gBAAgB,EAChB,UAAU,EACV,QAAQ,CACR,CAAC;gBAEF,aAAa,CAAC,QAAmB,CAAC,GAAG,YAAY,CAAC;YACnD,CAAC;YAED,OAAO,aAAa,CAAC;QACtB,CAAC,CAAC;IACH,CAAC;IAED,0DAA0D;IAC1D,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,gBAAgB,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;IAChE,OAAO,CACN,EACC,SAAS,EACT,KAAK,EAAE,cAAc,EACrB,GAAG,KAAK,KACe,EAAwB,EAC/C,EAAE;QACH,MAAM,iBAAiB,GAAG,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QAE/D,MAAM,eAAe,GAAG,gBAAgB,EAAE,GAAG,CAC5C,CAAC,EAAE,SAAS,EAAE,iBAAiB,EAAE,GAAG,QAAQ,EAAE,EAAE,EAAE;YACjD,IACC,sBAAsB,CACrB,QAGC,EACD,KAAK,CACL,EACA,CAAC;gBACF,OAAO,iBAAiB,CAAC;YAC1B,CAAC;YACD,OAAO,SAAS,CAAC;QAClB,CAAC,CACD,CAAC;QAEF,MAAM,OAAO,GAAG,IAAI,CACnB,IAAI,EACJ,iBAAiB,EACjB,eAAe,EACf,SAAS,EACT,cAAc,CACd,CAAC;QACF,OAAO,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;IACnD,CAAC,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,MAAM,CAAC,MAAM,SAAS,GAAG,CACxB,YAA2B,EAC3B,UAAwC,EACvC,EAAE;IAwBH,SAAS,SAAS,CAIjB,MAQI;QAEJ,IAAI,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;YAC3B,OAAO,GAAG,CAAU;gBACnB,GAAG,MAAM;gBACT,UAAU,EAAE,UAAU,IAAI,MAAM,CAAC,UAAU;aAM3C,CAAC,CAAC;QACJ,CAAC;aAAM,CAAC;YACP,OAAO,GAAG,CAAO;gBAChB,GAAG,MAAM;gBACT,UAAU,EAAE,UAAU,IAAI,MAAM,CAAC,UAAU;aAC3C,CAAC,CAAC;QACJ,CAAC;IACF,CAAC;IAED,OAAO,SAAS,CAAC;AAClB,CAAC,CAAC","sourcesContent":["import { clsx } from \"clsx\";\nimport {\n\tcreateSlotFunction,\n\tisSlotsConfig,\n\tmatchesCompoundVariant,\n\tprocessVariantProps,\n} from \"./helpers\";\nimport type {\n\tCompoundVariantWithSlots,\n\tDefaultBreakpoints,\n\tResponsiveClassesConfig,\n\tSlotConfig,\n\tVariantConfig,\n\tVariantProps,\n\tVariantValue,\n} from \"./types\";\n\n/**\n * Builds responsive class strings from a config object.\n *\n * Pass **`breakpoints`** as a `const` tuple (e.g. `['mobile', 'tablet'] as const`) only when you want\n * TypeScript to infer custom breakpoint names for responsive props. It is not read at runtime.\n * Omit it to use the default `sm` / `md` / `lg` / `xl` breakpoints.\n */\n// Function overloads for rcv\nexport function rcv<\n\tT extends VariantConfig = Record<never, VariantValue>,\n\tS extends Record<string, SlotConfig> = Record<string, SlotConfig>,\n\tB extends string = DefaultBreakpoints,\n>(config: {\n\tslots: S;\n\tvariants?: T;\n\tcompoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];\n\tbreakpoints?: readonly B[];\n\tonComplete?: (classes: string) => string;\n}): () => {\n\t[K in keyof S]: (props?: VariantProps<T, B>) => string;\n};\n\nexport function rcv<\n\tT extends VariantConfig = Record<never, VariantValue>,\n\tB extends string = DefaultBreakpoints,\n>(config: {\n\tbase: string;\n\tvariants?: T;\n\tcompoundVariants?: Partial<VariantProps<T, B>>[];\n\tbreakpoints?: readonly B[];\n\tonComplete?: (classes: string) => string;\n}): (props?: VariantProps<T, B>) => string;\n\nexport function rcv<\n\tT extends VariantConfig = Record<never, VariantValue>,\n\tS extends Record<string, SlotConfig> = Record<string, SlotConfig>,\n\tB extends string = DefaultBreakpoints,\n>(\n\tconfig:\n\t\t| ResponsiveClassesConfig<T, B>\n\t\t| {\n\t\t\t\tslots: S;\n\t\t\t\tvariants?: T;\n\t\t\t\tcompoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];\n\t\t\t\tbreakpoints?: readonly B[];\n\t\t\t\tonComplete?: (classes: string) => string;\n\t\t  },\n) {\n\t// Check if config is a slots config\n\tif (isSlotsConfig(config)) {\n\t\tconst { slots, variants, compoundVariants, onComplete } = config;\n\t\treturn () => {\n\t\t\tconst slotFunctions = {} as {\n\t\t\t\t[K in keyof S]: (props?: VariantProps<T, B>) => string;\n\t\t\t};\n\n\t\t\t// Create slot functions for each slot - ensure all slots are always present\n\t\t\tfor (const [slotName, slotConfig] of Object.entries(slots)) {\n\t\t\t\tconst slotFunction = createSlotFunction<T, B>(\n\t\t\t\t\tslotConfig,\n\t\t\t\t\tvariants,\n\t\t\t\t\tcompoundVariants,\n\t\t\t\t\tonComplete,\n\t\t\t\t\tslotName,\n\t\t\t\t);\n\n\t\t\t\tslotFunctions[slotName as keyof S] = slotFunction;\n\t\t\t}\n\n\t\t\treturn slotFunctions;\n\t\t};\n\t}\n\n\t// If config is not a slots config, create a base function\n\tconst { base, variants, compoundVariants, onComplete } = config;\n\treturn (\n\t\t{\n\t\t\tclassName,\n\t\t\tclass: classFromProps,\n\t\t\t...props\n\t\t}: VariantProps<T, B> = {} as VariantProps<T, B>,\n\t) => {\n\t\tconst responsiveClasses = processVariantProps(props, variants);\n\n\t\tconst compoundClasses = compoundVariants?.map(\n\t\t\t({ className: compoundClassName, ...compound }) => {\n\t\t\t\tif (\n\t\t\t\t\tmatchesCompoundVariant(\n\t\t\t\t\t\tcompound as Omit<\n\t\t\t\t\t\t\tCompoundVariantWithSlots<T, string, B>,\n\t\t\t\t\t\t\t\"className\" | \"class\"\n\t\t\t\t\t\t>,\n\t\t\t\t\t\tprops,\n\t\t\t\t\t)\n\t\t\t\t) {\n\t\t\t\t\treturn compoundClassName;\n\t\t\t\t}\n\t\t\t\treturn undefined;\n\t\t\t},\n\t\t);\n\n\t\tconst classes = clsx(\n\t\t\tbase,\n\t\t\tresponsiveClasses,\n\t\t\tcompoundClasses,\n\t\t\tclassName,\n\t\t\tclassFromProps,\n\t\t);\n\t\treturn onComplete ? onComplete(classes) : classes;\n\t};\n}\n\n/**\n * Returns an `rcv` that uses custom breakpoint names for typing.\n *\n * The first argument is **type-only** (not read at runtime): it lets TypeScript infer `B`.\n * You can get the same effect with {@link rcv} by passing `breakpoints: ['mobile', 'tablet'] as const` on the config object.\n *\n * @template B - The custom breakpoints type\n * @param breakpoints - Optional tuple of custom breakpoint names (for inference only)\n * @param onComplete - Optional callback applied to the merged class string\n * @returns An `rcv` function whose props use `B` for responsive keys\n *\n * @example\n * const customRcv = createRcv(['mobile', 'tablet', 'desktop']);\n *\n * const getButtonVariants = customRcv({\n *   base: \"px-4 py-2 rounded\",\n *   variants: {\n *     intent: {\n *       primary: \"bg-blue-500 text-white\",\n *       secondary: \"bg-gray-200 text-gray-800\"\n *     }\n *   }\n * });\n *\n * // Usage with custom breakpoints:\n * getButtonVariants({ intent: { initial: \"primary\", mobile: \"secondary\", desktop: \"primary\" } })\n */\n\nexport const createRcv = <B extends string>(\n\t_breakpoints?: readonly B[],\n\tonComplete?: (classes: string) => string,\n) => {\n\tfunction customRcv<\n\t\tT extends VariantConfig = Record<never, VariantValue>,\n\t\tS extends Record<string, SlotConfig> = Record<string, SlotConfig>,\n\t>(config: {\n\t\tslots: S;\n\t\tvariants?: T;\n\t\tcompoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];\n\t\tbreakpoints?: readonly B[];\n\t\tonComplete?: (classes: string) => string;\n\t}): () => {\n\t\t[K in keyof S]: (props?: VariantProps<T, B>) => string;\n\t};\n\n\tfunction customRcv<\n\t\tT extends VariantConfig = Record<never, VariantValue>,\n\t>(config: {\n\t\tbase: string;\n\t\tvariants?: T;\n\t\tcompoundVariants?: Partial<VariantProps<T, B>>[];\n\t\tbreakpoints?: readonly B[];\n\t\tonComplete?: (classes: string) => string;\n\t}): (props?: VariantProps<T, B>) => string;\n\n\tfunction customRcv<\n\t\tT extends VariantConfig = Record<never, VariantValue>,\n\t\tS extends Record<string, SlotConfig> = Record<string, SlotConfig>,\n\t>(\n\t\tconfig:\n\t\t\t| ResponsiveClassesConfig<T, B>\n\t\t\t| {\n\t\t\t\t\tslots: S;\n\t\t\t\t\tvariants?: T;\n\t\t\t\t\tcompoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];\n\t\t\t\t\tbreakpoints?: readonly B[];\n\t\t\t\t\tonComplete?: (classes: string) => string;\n\t\t\t  },\n\t) {\n\t\tif (isSlotsConfig(config)) {\n\t\t\treturn rcv<T, S, B>({\n\t\t\t\t...config,\n\t\t\t\tonComplete: onComplete || config.onComplete,\n\t\t\t} as {\n\t\t\t\tslots: S;\n\t\t\t\tvariants?: T;\n\t\t\t\tcompoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];\n\t\t\t\tonComplete?: (classes: string) => string;\n\t\t\t});\n\t\t} else {\n\t\t\treturn rcv<T, B>({\n\t\t\t\t...config,\n\t\t\t\tonComplete: onComplete || config.onComplete,\n\t\t\t});\n\t\t}\n\t}\n\n\treturn customRcv;\n};\n"]}

package/dist/types.d.ts

@@ -0,0 +1,50 @@
+export type DefaultBreakpoints = "sm" | "md" | "lg" | "xl";
+export type Breakpoints = DefaultBreakpoints;
+export type BreakpointsMap<V, B extends string = DefaultBreakpoints> = {
+    initial: V;
+} & Partial<{
+    [breakpoint in B]: V;
+}>;
+export type ResponsiveValue<T, B extends string = DefaultBreakpoints> = T | BreakpointsMap<T, B>;
+type ClassValue = string | ReadonlyArray<string>;
+type ValueType = ClassValue | Record<string, ClassValue>;
+type VariantValue = Record<string, ValueType>;
+type VariantConfig = Record<string, VariantValue>;
+type StringBoolean = "true" | "false";
+type BooleanVariant = Partial<Record<StringBoolean, ClassValue | Record<string, ClassValue>>>;
+type VariantPropValue<T, B extends string> = T extends BooleanVariant ? ResponsiveValue<boolean, B> | undefined : T extends Record<string, unknown> ? ResponsiveValue<keyof T, B> : never;
+type VariantPropsBase<T extends VariantConfig, B extends string> = {
+    [K in keyof T]?: VariantPropValue<T[K], B>;
+};
+type VariantProps<T extends VariantConfig, B extends string> = VariantPropsBase<T, B> & {
+    className?: string;
+    class?: string;
+};
+type SlotConfig = ClassValue;
+type SlotsConfig<S extends Record<string, SlotConfig>> = S;
+type CompoundVariantClassValue<S extends string> = string | Partial<Record<S, ClassValue>>;
+type CompoundVariantWithSlots<T extends VariantConfig, S extends string, B extends string> = Partial<Omit<VariantProps<T, B>, "class" | "className">> & {
+    class?: CompoundVariantClassValue<S>;
+    className?: CompoundVariantClassValue<S>;
+};
+/**
+ * Optional tuple of breakpoint names, used only so TypeScript can infer `B`.
+ * It is not read at runtime; omit it to use {@link DefaultBreakpoints}.
+ */
+type BreakpointsInference<B extends string> = readonly B[];
+type ResponsiveClassesConfigBase<T extends VariantConfig, B extends string> = {
+    base: string;
+    variants?: T;
+    compoundVariants?: Partial<VariantProps<T, B>>[];
+    breakpoints?: BreakpointsInference<B>;
+    onComplete?: (classes: string) => string;
+};
+type ResponsiveClassesConfigSlots<T extends VariantConfig, S extends Record<string, SlotConfig>, B extends string> = {
+    slots: SlotsConfig<S>;
+    variants?: T;
+    compoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];
+    breakpoints?: BreakpointsInference<B>;
+    onComplete?: (classes: string) => string;
+};
+type ResponsiveClassesConfig<T extends VariantConfig, B extends string> = ResponsiveClassesConfigBase<T, B> | ResponsiveClassesConfigSlots<T, Record<string, SlotConfig>, B>;
+export type { ClassValue, CompoundVariantClassValue, CompoundVariantWithSlots, ResponsiveClassesConfig, ResponsiveClassesConfigSlots, SlotConfig, SlotsConfig, VariantConfig, VariantProps, VariantPropValue, VariantValue, };

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"/","sources":["types.ts"],"names":[],"mappings":"","sourcesContent":["export type DefaultBreakpoints = \"sm\" | \"md\" | \"lg\" | \"xl\";\nexport type Breakpoints = DefaultBreakpoints;\n\nexport type BreakpointsMap<V, B extends string = DefaultBreakpoints> = {\n\tinitial: V;\n} & Partial<{\n\t[breakpoint in B]: V;\n}>;\n\nexport type ResponsiveValue<T, B extends string = DefaultBreakpoints> =\n\t| T\n\t| BreakpointsMap<T, B>;\n\ntype ClassValue = string | ReadonlyArray<string>;\n\ntype ValueType = ClassValue | Record<string, ClassValue>;\n\ntype VariantValue = Record<string, ValueType>;\ntype VariantConfig = Record<string, VariantValue>;\n\ntype StringBoolean = \"true\" | \"false\";\ntype BooleanVariant = Partial<\n\tRecord<StringBoolean, ClassValue | Record<string, ClassValue>>\n>;\n\ntype VariantPropValue<T, B extends string> = T extends BooleanVariant\n\t? ResponsiveValue<boolean, B> | undefined\n\t: T extends Record<string, unknown>\n\t\t? ResponsiveValue<keyof T, B>\n\t\t: never;\n\ntype VariantPropsBase<T extends VariantConfig, B extends string> = {\n\t[K in keyof T]?: VariantPropValue<T[K], B>;\n};\n\ntype VariantProps<T extends VariantConfig, B extends string> = VariantPropsBase<\n\tT,\n\tB\n> & {\n\tclassName?: string;\n\tclass?: string;\n};\n\n// Slot configuration types\ntype SlotConfig = ClassValue;\n\ntype SlotsConfig<S extends Record<string, SlotConfig>> = S;\n\ntype CompoundVariantClassValue<S extends string> =\n\t| string\n\t| Partial<Record<S, ClassValue>>;\n\ntype CompoundVariantWithSlots<\n\tT extends VariantConfig,\n\tS extends string,\n\tB extends string,\n> = Partial<Omit<VariantProps<T, B>, \"class\" | \"className\">> & {\n\tclass?: CompoundVariantClassValue<S>;\n\tclassName?: CompoundVariantClassValue<S>;\n};\n\n/**\n * Optional tuple of breakpoint names, used only so TypeScript can infer `B`.\n * It is not read at runtime; omit it to use {@link DefaultBreakpoints}.\n */\ntype BreakpointsInference<B extends string> = readonly B[];\n\ntype ResponsiveClassesConfigBase<T extends VariantConfig, B extends string> = {\n\tbase: string;\n\tvariants?: T;\n\tcompoundVariants?: Partial<VariantProps<T, B>>[];\n\tbreakpoints?: BreakpointsInference<B>;\n\tonComplete?: (classes: string) => string;\n};\n\ntype ResponsiveClassesConfigSlots<\n\tT extends VariantConfig,\n\tS extends Record<string, SlotConfig>,\n\tB extends string,\n> = {\n\tslots: SlotsConfig<S>;\n\tvariants?: T;\n\tcompoundVariants?: CompoundVariantWithSlots<T, keyof S & string, B>[];\n\tbreakpoints?: BreakpointsInference<B>;\n\tonComplete?: (classes: string) => string;\n};\n\ntype ResponsiveClassesConfig<T extends VariantConfig, B extends string> =\n\t| ResponsiveClassesConfigBase<T, B>\n\t| ResponsiveClassesConfigSlots<T, Record<string, SlotConfig>, B>;\n\nexport type {\n\tClassValue,\n\tCompoundVariantClassValue,\n\tCompoundVariantWithSlots,\n\tResponsiveClassesConfig,\n\tResponsiveClassesConfigSlots,\n\tSlotConfig,\n\tSlotsConfig,\n\tVariantConfig,\n\tVariantProps,\n\tVariantPropValue,\n\tVariantValue,\n};\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "responsive-class-variants",
-	"version": "1.3.1",
+	"version": "1.4.0",
 	"description": "rcv helps you create responsive class variants",
 	"main": "dist/index.js",
 	"type": "module",
@@ -20,7 +20,7 @@
 		"tailwindcss"
 	],
 	"scripts": {
-		"build": "tsc",
+		"build": "tsc && tsc-alias -f",
 		"test": "vitest",
 		"test:ci": "vitest run",
 		"lint": "biome check .",
@@ -28,14 +28,15 @@
 	},
 	"author": "Benedikt Sperl",
 	"license": "ISC",
-	"packageManager": "pnpm@9.14.2+sha512.6e2baf77d06b9362294152c851c4f278ede37ab1eba3a55fda317a4a17b209f4dbb973fb250a77abc463a341fcb1f17f17cfa24091c4eb319cda0d9b84278387",
+	"packageManager": "pnpm@10.30.1",
 	"dependencies": {
 		"clsx": "^2.0.0"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.0.6",
-		"lefthook": "^1.11.14",
-		"typescript": "^5.8.3",
-		"vitest": "^3.2.4"
+		"@biomejs/biome": "2.4.15",
+		"lefthook": "^2.1.8",
+		"tsc-alias": "^1.8.17",
+		"typescript": "^6.0.3",
+		"vitest": "^4.1.7"
 	}
 }