@yaredfall/class-variants 0.0.8 → 0.1.1

package/build/chunk-3XL4COYB.js

@@ -0,0 +1,2 @@
+import{a as C,b as c,c as m}from"./chunk-BV75ULQK.js";import{clsx as v}from"clsx";var U=(a,x={})=>{let h=x.merge??v,{variants:e,defaultVariant:r,base:k}=a,V=e?C(e):[],l=e?m(e):{},f=r??{},R=e?typeof a.compoundVariants=="function"?a.compoundVariants({variants:e,keys:V,options:l,defaults:f}):a.compoundVariants:void 0;return Object.assign(s=>{let g=e?V.map(t=>{let i=s?.[t],d=r?.[t],o=i?.toString()||d?.toString();return o?e[t][o]:void 0}):void 0,O=R?.reduce((t,{class:i,className:d,...o})=>(c(o).every(([u,n])=>{let _=r?.[u],p=s?.[u];if(typeof n=="object"&&"__token"in n){if(n.__token===S.__token)return p!==void 0;if(n.__token===W.__token)return p===void 0}let y=p??_;return Array.isArray(n)?n.some(P=>y===P):y===n})&&t.push(i,d),t),new Array);return h(k,g,O,s?.class,s?.className)},{keys:V,options:l,defaults:f})},S={__token:"OnlyWhenDefined"},W={__token:"OnlyWhenUndefined"};export{U as a,S as b,W as c};
+//# sourceMappingURL=chunk-3XL4COYB.js.map

package/build/chunk-3XL4COYB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { ClassValue, clsx } from \"clsx\";\r\nimport { MarkRequired, Prettify, StrictExclude, Opaque } from \"ts-essentials\";\r\nimport { getEntries, getKeys, getVariantsOptions, KeysOf, VariantOptions } from \"./utils\";\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nexport type VariantProps<CVR extends (args?: any) => string> = Prettify<\r\n    Omit<NonNullable<StrictExclude<Parameters<CVR>[0], void>>, \"class\" | \"className\">\r\n>;\r\n\r\ntype ClassProp =\r\n    | { class?: ClassValue; className?: never }\r\n    | { class?: never; className?: ClassValue };\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nexport type WithClassProp<T extends Record<string, any>> = T & ClassProp;\r\n\r\ntype BooleanStringToBoolean<T> = T extends \"true\" | \"false\" ? boolean : T;\r\n\r\nexport type CVVariantsSchema = Record<string, Record<string, ClassValue>>;\r\n\r\nexport type CVVariant<V extends CVVariantsSchema> = {\r\n    [K in keyof V]?: BooleanStringToBoolean<keyof V[K]>;\r\n};\r\nexport type CVCompoundVariant<V extends CVVariantsSchema> = WithClassProp<{\r\n    [K in keyof V]?:\r\n        | BooleanStringToBoolean<keyof V[K]>\r\n        | BooleanStringToBoolean<keyof V[K]>[]\r\n        | CVToken;\r\n}>;\r\n\r\nexport type CVCompoundVariantsSchema<V extends CVVariantsSchema> = CVCompoundVariant<V>[];\r\n\r\nexport interface CVConfig<V extends CVVariantsSchema, R extends keyof V> {\r\n    base?: ClassValue;\r\n    variants?: V;\r\n    compoundVariants?:\r\n        | CVCompoundVariantsSchema<V>\r\n        | ((arg: {\r\n              variants: V;\r\n              keys: KeysOf<V>;\r\n              options: VariantOptions<V>;\r\n              defaults: CVVariant<V>;\r\n          }) => CVCompoundVariantsSchema<V>);\r\n    defaultVariant?: CVVariant<V>;\r\n    requiredProps?: R[];\r\n}\r\nexport interface CVOptions {\r\n    merge?: (...args: ClassValue[]) => string;\r\n}\r\n\r\ntype CVReturnProps<V extends CVVariantsSchema, R extends keyof V = never> =\r\n    | Prettify<WithClassProp<MarkRequired<CVVariant<V>, R>>>\r\n    | ([R] extends [never] ? void : never);\r\nexport interface CVReturn<V extends CVVariantsSchema, R extends keyof V = never> {\r\n    (props: CVReturnProps<V, R>): string;\r\n    keys: KeysOf<V>;\r\n    options: VariantOptions<V>;\r\n    defaults: CVVariant<V>;\r\n}\r\n\r\nexport interface CV {\r\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type\r\n    <V extends CVVariantsSchema, R extends keyof V = never>(\r\n        config: CVConfig<V, R>,\r\n        cvOptions?: CVOptions,\r\n    ): CVReturn<V, R>;\r\n}\r\n\r\nexport const cv: CV = (config, cvOptions = {}) => {\r\n    const merge = cvOptions.merge ?? clsx;\r\n\r\n    const { variants, defaultVariant, base } = config;\r\n\r\n    type ResolvedV = NonNullable<typeof variants>;\r\n\r\n    const keys = variants ? getKeys(variants) : [];\r\n    const options = variants ? getVariantsOptions(variants) : ({} as VariantOptions<ResolvedV>);\r\n    const defaults = defaultVariant ?? ({} as CVVariant<ResolvedV>);\r\n\r\n    const compoundVariants = variants\r\n        ? typeof config.compoundVariants === \"function\"\r\n            ? config.compoundVariants({ variants, keys, options, defaults })\r\n            : config.compoundVariants\r\n        : undefined;\r\n\r\n    const getVariant = <V extends ResolvedV, R extends keyof V = never>(\r\n        props: CVReturnProps<V, R>,\r\n    ) => {\r\n        const variantClassNames = variants\r\n            ? keys.map((variant) => {\r\n                  const variantProp = props?.[variant];\r\n                  const defaultVariantProp = defaultVariant?.[variant];\r\n\r\n                  const variantKey = variantProp?.toString() || defaultVariantProp?.toString();\r\n\r\n                  return variantKey ? variants[variant][variantKey] : undefined;\r\n              })\r\n            : undefined;\r\n\r\n        const compoundVariantClassNames = compoundVariants?.reduce(\r\n            (acc, { class: cvClass, className: cvClassName, ...cvConfig }) => {\r\n                const shouldApplyCompoundVariant = getEntries(cvConfig).every(\r\n                    ([cvKey, cvSelector]) => {\r\n                        const defaultsSelector =\r\n                            defaultVariant?.[cvKey as keyof typeof defaultVariant];\r\n                        const propsSelector = props?.[cvKey as keyof typeof props];\r\n\r\n                        if (typeof cvSelector === \"object\" && \"__token\" in cvSelector) {\r\n                            if (cvSelector.__token === onlyWhenDefined.__token) {\r\n                                return propsSelector !== undefined;\r\n                            } else if (cvSelector.__token === onlyWhenUndefined.__token) {\r\n                                return propsSelector === undefined;\r\n                            }\r\n                        }\r\n\r\n                        const selector = propsSelector ?? defaultsSelector;\r\n\r\n                        return Array.isArray(cvSelector)\r\n                            ? cvSelector.some((cvSelector) => selector === cvSelector)\r\n                            : selector === cvSelector;\r\n                    },\r\n                );\r\n\r\n                if (shouldApplyCompoundVariant) acc.push(cvClass, cvClassName);\r\n                return acc;\r\n            },\r\n            new Array<ClassValue>(),\r\n        );\r\n\r\n        return merge(\r\n            base,\r\n            variantClassNames,\r\n            compoundVariantClassNames,\r\n            props?.class,\r\n            props?.className,\r\n        );\r\n    };\r\n\r\n    return Object.assign(getVariant, { keys, options, defaults });\r\n};\r\n\r\ntype OnlyWhenDefined = Opaque<{ __token: string }, \"OnlyWhenDefined\">;\r\ntype OnlyWhenUndefined = Opaque<{ __token: string }, \"OnlyWhenUndefined\">;\r\n\r\ntype CVToken = OnlyWhenDefined | OnlyWhenUndefined;\r\n\r\n/** Apply compound variant only if prop **is** specified */\r\nexport const onlyWhenDefined = { __token: \"OnlyWhenDefined\" } as OnlyWhenDefined;\r\n/** Apply compound variant only if prop **is not** specified */\r\nexport const onlyWhenUndefined = { __token: \"OnlyWhenUndefined\" } as OnlyWhenUndefined;\r\n"],"mappings":"sDAAA,OAAqB,QAAAA,MAAY,OAoE1B,IAAMC,EAAS,CAACC,EAAQC,EAAY,CAAC,IAAM,CAC9C,IAAMC,EAAQD,EAAU,OAASE,EAE3B,CAAE,SAAAC,EAAU,eAAAC,EAAgB,KAAAC,CAAK,EAAIN,EAIrCO,EAAOH,EAAWI,EAAQJ,CAAQ,EAAI,CAAC,EACvCK,EAAUL,EAAWM,EAAmBN,CAAQ,EAAK,CAAC,EACtDO,EAAWN,GAAmB,CAAC,EAE/BO,EAAmBR,EACnB,OAAOJ,EAAO,kBAAqB,WAC/BA,EAAO,iBAAiB,CAAE,SAAAI,EAAU,KAAAG,EAAM,QAAAE,EAAS,SAAAE,CAAS,CAAC,EAC7DX,EAAO,iBACX,OAuDN,OAAO,OAAO,OApDVa,GACC,CACD,IAAMC,EAAoBV,EACpBG,EAAK,IAAKQ,GAAY,CAClB,IAAMC,EAAcH,IAAQE,CAAO,EAC7BE,EAAqBZ,IAAiBU,CAAO,EAE7CG,EAAaF,GAAa,SAAS,GAAKC,GAAoB,SAAS,EAE3E,OAAOC,EAAad,EAASW,CAAO,EAAEG,CAAU,EAAI,MACxD,CAAC,EACD,OAEAC,EAA4BP,GAAkB,OAChD,CAACQ,EAAK,CAAE,MAAOC,EAAS,UAAWC,EAAa,GAAGC,CAAS,KACrBC,EAAWD,CAAQ,EAAE,MACpD,CAAC,CAACE,EAAOC,CAAU,IAAM,CACrB,IAAMC,EACFtB,IAAiBoB,CAAoC,EACnDG,EAAgBf,IAAQY,CAA2B,EAEzD,GAAI,OAAOC,GAAe,UAAY,YAAaA,EAAY,CAC3D,GAAIA,EAAW,UAAYG,EAAgB,QACvC,OAAOD,IAAkB,OACtB,GAAIF,EAAW,UAAYI,EAAkB,QAChD,OAAOF,IAAkB,MAEjC,CAEA,IAAMG,EAAWH,GAAiBD,EAElC,OAAO,MAAM,QAAQD,CAAU,EACzBA,EAAW,KAAMA,GAAeK,IAAaL,CAAU,EACvDK,IAAaL,CACvB,CACJ,GAEgCN,EAAI,KAAKC,EAASC,CAAW,EACtDF,GAEX,IAAI,KACR,EAEA,OAAOlB,EACHI,EACAQ,EACAK,EACAN,GAAO,MACPA,GAAO,SACX,CACJ,EAEiC,CAAE,KAAAN,EAAM,QAAAE,EAAS,SAAAE,CAAS,CAAC,CAChE,EAQakB,EAAkB,CAAE,QAAS,iBAAkB,EAE/CC,EAAoB,CAAE,QAAS,mBAAoB","names":["clsx","cv","config","cvOptions","merge","clsx","variants","defaultVariant","base","keys","getKeys","options","getVariantsOptions","defaults","compoundVariants","props","variantClassNames","variant","variantProp","defaultVariantProp","variantKey","compoundVariantClassNames","acc","cvClass","cvClassName","cvConfig","getEntries","cvKey","cvSelector","defaultsSelector","propsSelector","onlyWhenDefined","onlyWhenUndefined","selector"]}

package/build/chunk-BV75ULQK.js

@@ -0,0 +1,2 @@
+function r(e){return Object.keys(e)}function o(e){return Object.entries(e)}function i(e){return Object.fromEntries(o(e).map(([n,t])=>[n,r(t)]))}function s(e){return Object.fromEntries(e)}export{r as a,o as b,i as c,s as d};
+//# sourceMappingURL=chunk-BV75ULQK.js.map

package/build/chunk-BV75ULQK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["import { DeepReadonly, DeepWritable, Prettify, UnionToIntersection } from \"ts-essentials\";\nimport { CVVariantsSchema } from \".\";\n\nexport type KeysOf<O extends Record<string, unknown>> = (keyof O)[];\nexport function getKeys<O extends Record<string, unknown>>(obj: O) {\n    return Object.keys(obj) as KeysOf<O>;\n}\n\nexport type EntriesOf<O extends Record<string, unknown>> = { [K in keyof O]: [K, O[K]] };\nexport function getEntries<O extends Record<string, unknown>>(obj: O) {\n    return Object.entries(obj) as EntriesOf<O>[keyof EntriesOf<O>][];\n}\n\nexport type VariantOptions<V extends CVVariantsSchema> = {\n    [K in keyof V]: KeysOf<V[K]>;\n};\nexport function getVariantsOptions<V extends CVVariantsSchema>(variants: V) {\n    return Object.fromEntries(\n        getEntries(variants).map(([cvKey, cvVal]) => [cvKey, getKeys(cvVal)]),\n    ) as VariantOptions<V>;\n}\n\ntype Entries = [PropertyKey, unknown][] | DeepReadonly<[PropertyKey, unknown][]>;\ntype UnionFromPairs<TArr extends Entries> =\n    DeepWritable<TArr> extends (infer R)[]\n        ? R extends [infer key, infer val]\n            ? { [prop in key & PropertyKey]: val }\n            : never\n        : never;\n\ntype MergeIntersectingObjects<O> = { [K in keyof O]: O[K] };\n\nexport function objectFromEntries<E extends Entries>(entries: E) {\n    return Object.fromEntries(entries) as Prettify<\n        MergeIntersectingObjects<UnionToIntersection<UnionFromPairs<E>>>\n    >;\n}\n"],"mappings":"AAIO,SAASA,EAA2CC,EAAQ,CAC/D,OAAO,OAAO,KAAKA,CAAG,CAC1B,CAGO,SAASC,EAA8CD,EAAQ,CAClE,OAAO,OAAO,QAAQA,CAAG,CAC7B,CAKO,SAASE,EAA+CC,EAAa,CACxE,OAAO,OAAO,YACVF,EAAWE,CAAQ,EAAE,IAAI,CAAC,CAACC,EAAOC,CAAK,IAAM,CAACD,EAAOL,EAAQM,CAAK,CAAC,CAAC,CACxE,CACJ,CAYO,SAASC,EAAqCC,EAAY,CAC7D,OAAO,OAAO,YAAYA,CAAO,CAGrC","names":["getKeys","obj","getEntries","getVariantsOptions","variants","cvKey","cvVal","objectFromEntries","entries"]}

package/build/index-DUG5hPfi.d.cts

@@ -0,0 +1,79 @@
+import { ClassValue } from 'clsx';
+import { Prettify, UnionToIntersection, DeepReadonly, DeepWritable, StrictExclude, MarkRequired, Opaque } from 'ts-essentials';
+
+type KeysOf<O extends Record<string, unknown>> = (keyof O)[];
+declare function getKeys<O extends Record<string, unknown>>(obj: O): KeysOf<O>;
+type EntriesOf<O extends Record<string, unknown>> = {
+    [K in keyof O]: [K, O[K]];
+};
+declare function getEntries<O extends Record<string, unknown>>(obj: O): EntriesOf<O>[keyof EntriesOf<O>][];
+type VariantOptions<V extends CVVariantsSchema> = {
+    [K in keyof V]: KeysOf<V[K]>;
+};
+declare function getVariantsOptions<V extends CVVariantsSchema>(variants: V): VariantOptions<V>;
+type Entries = [PropertyKey, unknown][] | DeepReadonly<[PropertyKey, unknown][]>;
+type UnionFromPairs<TArr extends Entries> = DeepWritable<TArr> extends (infer R)[] ? R extends [infer key, infer val] ? {
+    [prop in key & PropertyKey]: val;
+} : never : never;
+type MergeIntersectingObjects<O> = {
+    [K in keyof O]: O[K];
+};
+declare function objectFromEntries<E extends Entries>(entries: E): Prettify<MergeIntersectingObjects<UnionToIntersection<UnionFromPairs<E>>>>;
+
+type VariantProps<CVR extends (args?: any) => string> = Prettify<Omit<NonNullable<StrictExclude<Parameters<CVR>[0], void>>, "class" | "className">>;
+type ClassProp = {
+    class?: ClassValue;
+    className?: never;
+} | {
+    class?: never;
+    className?: ClassValue;
+};
+type WithClassProp<T extends Record<string, any>> = T & ClassProp;
+type BooleanStringToBoolean<T> = T extends "true" | "false" ? boolean : T;
+type CVVariantsSchema = Record<string, Record<string, ClassValue>>;
+type CVVariant<V extends CVVariantsSchema> = {
+    [K in keyof V]?: BooleanStringToBoolean<keyof V[K]>;
+};
+type CVCompoundVariant<V extends CVVariantsSchema> = WithClassProp<{
+    [K in keyof V]?: BooleanStringToBoolean<keyof V[K]> | BooleanStringToBoolean<keyof V[K]>[] | CVToken;
+}>;
+type CVCompoundVariantsSchema<V extends CVVariantsSchema> = CVCompoundVariant<V>[];
+interface CVConfig<V extends CVVariantsSchema, R extends keyof V> {
+    base?: ClassValue;
+    variants?: V;
+    compoundVariants?: CVCompoundVariantsSchema<V> | ((arg: {
+        variants: V;
+        keys: KeysOf<V>;
+        options: VariantOptions<V>;
+        defaults: CVVariant<V>;
+    }) => CVCompoundVariantsSchema<V>);
+    defaultVariant?: CVVariant<V>;
+    requiredProps?: R[];
+}
+interface CVOptions {
+    merge?: (...args: ClassValue[]) => string;
+}
+type CVReturnProps<V extends CVVariantsSchema, R extends keyof V = never> = Prettify<WithClassProp<MarkRequired<CVVariant<V>, R>>> | ([R] extends [never] ? void : never);
+interface CVReturn<V extends CVVariantsSchema, R extends keyof V = never> {
+    (props: CVReturnProps<V, R>): string;
+    keys: KeysOf<V>;
+    options: VariantOptions<V>;
+    defaults: CVVariant<V>;
+}
+interface CV {
+    <V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>, cvOptions?: CVOptions): CVReturn<V, R>;
+}
+declare const cv: CV;
+type OnlyWhenDefined = Opaque<{
+    __token: string;
+}, "OnlyWhenDefined">;
+type OnlyWhenUndefined = Opaque<{
+    __token: string;
+}, "OnlyWhenUndefined">;
+type CVToken = OnlyWhenDefined | OnlyWhenUndefined;
+/** Apply compound variant only if prop **is** specified */
+declare const onlyWhenDefined: OnlyWhenDefined;
+/** Apply compound variant only if prop **is not** specified */
+declare const onlyWhenUndefined: OnlyWhenUndefined;
+
+export { type CVVariantsSchema as C, type EntriesOf as E, type KeysOf as K, type VariantOptions as V, type WithClassProp as W, type CVReturn as a, type CVConfig as b, type CVOptions as c, getEntries as d, getVariantsOptions as e, type VariantProps as f, getKeys as g, type CVVariant as h, type CVCompoundVariant as i, type CVCompoundVariantsSchema as j, type CV as k, cv as l, onlyWhenDefined as m, onlyWhenUndefined as n, objectFromEntries as o };

package/build/index-DUG5hPfi.d.ts

@@ -0,0 +1,79 @@
+import { ClassValue } from 'clsx';
+import { Prettify, UnionToIntersection, DeepReadonly, DeepWritable, StrictExclude, MarkRequired, Opaque } from 'ts-essentials';
+
+type KeysOf<O extends Record<string, unknown>> = (keyof O)[];
+declare function getKeys<O extends Record<string, unknown>>(obj: O): KeysOf<O>;
+type EntriesOf<O extends Record<string, unknown>> = {
+    [K in keyof O]: [K, O[K]];
+};
+declare function getEntries<O extends Record<string, unknown>>(obj: O): EntriesOf<O>[keyof EntriesOf<O>][];
+type VariantOptions<V extends CVVariantsSchema> = {
+    [K in keyof V]: KeysOf<V[K]>;
+};
+declare function getVariantsOptions<V extends CVVariantsSchema>(variants: V): VariantOptions<V>;
+type Entries = [PropertyKey, unknown][] | DeepReadonly<[PropertyKey, unknown][]>;
+type UnionFromPairs<TArr extends Entries> = DeepWritable<TArr> extends (infer R)[] ? R extends [infer key, infer val] ? {
+    [prop in key & PropertyKey]: val;
+} : never : never;
+type MergeIntersectingObjects<O> = {
+    [K in keyof O]: O[K];
+};
+declare function objectFromEntries<E extends Entries>(entries: E): Prettify<MergeIntersectingObjects<UnionToIntersection<UnionFromPairs<E>>>>;
+
+type VariantProps<CVR extends (args?: any) => string> = Prettify<Omit<NonNullable<StrictExclude<Parameters<CVR>[0], void>>, "class" | "className">>;
+type ClassProp = {
+    class?: ClassValue;
+    className?: never;
+} | {
+    class?: never;
+    className?: ClassValue;
+};
+type WithClassProp<T extends Record<string, any>> = T & ClassProp;
+type BooleanStringToBoolean<T> = T extends "true" | "false" ? boolean : T;
+type CVVariantsSchema = Record<string, Record<string, ClassValue>>;
+type CVVariant<V extends CVVariantsSchema> = {
+    [K in keyof V]?: BooleanStringToBoolean<keyof V[K]>;
+};
+type CVCompoundVariant<V extends CVVariantsSchema> = WithClassProp<{
+    [K in keyof V]?: BooleanStringToBoolean<keyof V[K]> | BooleanStringToBoolean<keyof V[K]>[] | CVToken;
+}>;
+type CVCompoundVariantsSchema<V extends CVVariantsSchema> = CVCompoundVariant<V>[];
+interface CVConfig<V extends CVVariantsSchema, R extends keyof V> {
+    base?: ClassValue;
+    variants?: V;
+    compoundVariants?: CVCompoundVariantsSchema<V> | ((arg: {
+        variants: V;
+        keys: KeysOf<V>;
+        options: VariantOptions<V>;
+        defaults: CVVariant<V>;
+    }) => CVCompoundVariantsSchema<V>);
+    defaultVariant?: CVVariant<V>;
+    requiredProps?: R[];
+}
+interface CVOptions {
+    merge?: (...args: ClassValue[]) => string;
+}
+type CVReturnProps<V extends CVVariantsSchema, R extends keyof V = never> = Prettify<WithClassProp<MarkRequired<CVVariant<V>, R>>> | ([R] extends [never] ? void : never);
+interface CVReturn<V extends CVVariantsSchema, R extends keyof V = never> {
+    (props: CVReturnProps<V, R>): string;
+    keys: KeysOf<V>;
+    options: VariantOptions<V>;
+    defaults: CVVariant<V>;
+}
+interface CV {
+    <V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>, cvOptions?: CVOptions): CVReturn<V, R>;
+}
+declare const cv: CV;
+type OnlyWhenDefined = Opaque<{
+    __token: string;
+}, "OnlyWhenDefined">;
+type OnlyWhenUndefined = Opaque<{
+    __token: string;
+}, "OnlyWhenUndefined">;
+type CVToken = OnlyWhenDefined | OnlyWhenUndefined;
+/** Apply compound variant only if prop **is** specified */
+declare const onlyWhenDefined: OnlyWhenDefined;
+/** Apply compound variant only if prop **is not** specified */
+declare const onlyWhenUndefined: OnlyWhenUndefined;
+
+export { type CVVariantsSchema as C, type EntriesOf as E, type KeysOf as K, type VariantOptions as V, type WithClassProp as W, type CVReturn as a, type CVConfig as b, type CVOptions as c, getEntries as d, getVariantsOptions as e, type VariantProps as f, getKeys as g, type CVVariant as h, type CVCompoundVariant as i, type CVCompoundVariantsSchema as j, type CV as k, cv as l, onlyWhenDefined as m, onlyWhenUndefined as n, objectFromEntries as o };

package/build/index.cjs

@@ -1,68 +1,2 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  cv: () => cv
-});
-module.exports = __toCommonJS(src_exports);
-var import_clsx = require("clsx");
-
-// src/utils.ts
-function getKeys(obj) {
-  return Object.keys(obj);
-}
-function getEntries(obj) {
-  return Object.entries(obj);
-}
-
-// src/index.ts
-var cv = (config, options = {}) => {
-  const { variants, defaultVariant, baseClass } = config;
-  const merge = options.merge ?? import_clsx.clsx;
-  if (variants == null) return (props) => merge(baseClass, props?.class);
-  const compoundVariants = typeof config.compoundVariants === "function" ? config.compoundVariants(variants) : config.compoundVariants;
-  return (props) => {
-    const variantClassNames = getKeys(variants).map((variant) => {
-      const variantProp = props?.[variant];
-      const defaultVariantProp = defaultVariant?.[variant];
-      const variantKey = variantProp || defaultVariantProp;
-      return variants[variant][variantKey];
-    });
-    const compoundVariantClassNames = compoundVariants?.reduce((acc, { class: cvClass, ...cvConfig }) => {
-      const shouldApplyCompoundVariant = getEntries(cvConfig).every(([cvKey, cvSelector]) => {
-        const defaultsSelector = defaultVariant?.[cvKey];
-        const propsSelector = props?.[cvKey];
-        if (cvSelector === true) return propsSelector !== void 0;
-        else if (cvSelector === false) return propsSelector === void 0;
-        const selector = propsSelector ?? defaultsSelector;
-        return Array.isArray(cvSelector) ? cvSelector.includes(selector) : selector === cvSelector;
-      });
-      if (shouldApplyCompoundVariant) acc.push(cvClass);
-      return acc;
-    }, new Array());
-    return merge(config?.baseClass, variantClassNames, compoundVariantClassNames, props?.class);
-  };
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  cv
-});
+"use strict";var l=Object.defineProperty;var b=Object.getOwnPropertyDescriptor;var E=Object.getOwnPropertyNames;var T=Object.prototype.hasOwnProperty;var N=(e,n)=>{for(var s in n)l(e,s,{get:n[s],enumerable:!0})},D=(e,n,s,t)=>{if(n&&typeof n=="object"||typeof n=="function")for(let r of E(n))!T.call(e,r)&&r!==s&&l(e,r,{get:()=>n[r],enumerable:!(t=b(n,r))||t.enumerable});return e};var U=e=>D(l({},"__esModule",{value:!0}),e);var B={};N(B,{cv:()=>j,onlyWhenDefined:()=>R,onlyWhenUndefined:()=>h});module.exports=U(B);var g=require("clsx");function u(e){return Object.keys(e)}function c(e){return Object.entries(e)}function k(e){return Object.fromEntries(c(e).map(([n,s])=>[n,u(s)]))}var j=(e,n={})=>{let s=n.merge??g.clsx,{variants:t,defaultVariant:r,base:K}=e,p=t?u(t):[],C=t?k(t):{},m=r??{},P=t?typeof e.compoundVariants=="function"?e.compoundVariants({variants:t,keys:p,options:C,defaults:m}):e.compoundVariants:void 0;return Object.assign(i=>{let v=t?p.map(o=>{let d=i?.[o],y=r?.[o],V=d?.toString()||y?.toString();return V?t[o][V]:void 0}):void 0,S=P?.reduce((o,{class:d,className:y,...V})=>(c(V).every(([O,a])=>{let _=r?.[O],f=i?.[O];if(typeof a=="object"&&"__token"in a){if(a.__token===R.__token)return f!==void 0;if(a.__token===h.__token)return f===void 0}let x=f??_;return Array.isArray(a)?a.some(W=>x===W):x===a})&&o.push(d,y),o),new Array);return s(K,v,S,i?.class,i?.className)},{keys:p,options:C,defaults:m})},R={__token:"OnlyWhenDefined"},h={__token:"OnlyWhenUndefined"};0&&(module.exports={cv,onlyWhenDefined,onlyWhenUndefined});
 //# sourceMappingURL=index.cjs.map

package/build/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/utils.ts"],"sourcesContent":["import { ClassValue, clsx } from \"clsx\";\r\nimport { MarkRequired, Prettify } from \"ts-essentials\";\r\nimport { getEntries, getKeys } from \"./utils\";\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nexport type VariantProps<CVR extends (args?: any) => string> = Prettify<Omit<NonNullable<Exclude<Parameters<CVR>[0], void>>, \"class\">>;\r\n\r\nexport type CVVariantsSchema = Record<string, Record<string, ClassValue>>;\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nexport type WithClassProp<T extends Record<string, any>> = T & {\r\n    class?: ClassValue;\r\n};\r\n\r\nexport type CVCompoundVariantsSchema<V extends CVVariantsSchema> = WithClassProp<{\r\n    [K in keyof V]?: (keyof V[K] & string) | (keyof V[K])[] | boolean\r\n}>[];\r\n\r\nexport interface CVConfig<V extends CVVariantsSchema, R extends keyof V> {\r\n    baseClass?: ClassValue;\r\n    variants?: V;\r\n    compoundVariants?: CVCompoundVariantsSchema<NoInfer<V>> | ((variants: NoInfer<V>) => CVCompoundVariantsSchema<NoInfer<V>>);\r\n    defaultVariant?: Partial<{ [K in keyof V]?: keyof V[K] }>;\r\n    requiredProps?: R[];\r\n}\r\n\r\nexport type CVVariantProps<V extends CVVariantsSchema, R extends (keyof V)> =\r\nWithClassProp<MarkRequired<{ [K in keyof V]?: keyof V[K] }, R>>;\r\n\r\nexport type CVReturn<V extends CVVariantsSchema, R extends keyof V = never> = (props: Prettify<CVVariantProps<V, R>> | ([R] extends [never] ? void : never)) => string;\r\n\r\nexport interface CVOptions {\r\n    merge?: (...args: ClassValue[]) => string;\r\n}\r\n\r\nexport interface CV {\r\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type\r\n    <V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>, options?: CVOptions): CVReturn<V, R>;\r\n}\r\n\r\nexport const cv: CV = (config, options = {}) => {\r\n    const { variants, defaultVariant, baseClass } = config;\r\n\r\n    const merge = options.merge ?? clsx;\r\n\r\n    if (variants == null) return props => merge(baseClass, props?.class);\r\n\r\n    const compoundVariants = typeof config.compoundVariants === \"function\" ? config.compoundVariants(variants) : config.compoundVariants;\r\n\r\n    return (props) => {\r\n        const variantClassNames = getKeys(variants).map((variant) => {\r\n            const variantProp = props?.[variant];\r\n            const defaultVariantProp = defaultVariant?.[variant];\r\n\r\n            const variantKey = (variantProp || defaultVariantProp) as keyof (typeof variants)[typeof variant];\r\n\r\n            return variants[variant][variantKey];\r\n        });\r\n\r\n        const compoundVariantClassNames = compoundVariants?.reduce((acc, { class: cvClass, ...cvConfig }) => {\r\n            const shouldApplyCompoundVariant = getEntries(cvConfig).every(([cvKey, cvSelector]) => {\r\n                const defaultsSelector = defaultVariant?.[cvKey as keyof typeof defaultVariant];\r\n                const propsSelector = props?.[cvKey as keyof typeof props];\r\n\r\n                if (cvSelector === true) return propsSelector !== undefined; // only when prop is defined\r\n                else if (cvSelector === false) return propsSelector === undefined; // only when prop is not defined\r\n\r\n                const selector = propsSelector ?? defaultsSelector;\r\n\r\n                return Array.isArray(cvSelector) ? cvSelector.includes(selector as string) : selector === cvSelector;\r\n            });\r\n\r\n            if (shouldApplyCompoundVariant) acc.push(cvClass);\r\n            return acc;\r\n        }, new Array<ClassValue>());\r\n\r\n        return merge(config?.baseClass, variantClassNames, compoundVariantClassNames, props?.class);\r\n    };\r\n};\r\n","import { DeepReadonly, DeepWritable, Prettify, UnionToIntersection } from \"ts-essentials\";\r\nimport { CVVariantsSchema } from \".\";\r\n\r\nexport function getKeys<O extends Record<string, unknown>>(obj: O) {\r\n    return Object.keys(obj) as (keyof O)[];\r\n}\r\n\r\ntype EntriesOf<O extends Record<string, unknown>> = { [K in keyof O]: [K, O[K]] };\r\nexport function getEntries<O extends Record<string, unknown>>(obj: O) {\r\n    return Object.entries(obj) as (EntriesOf<O>[keyof EntriesOf<O>])[];\r\n}\r\n\r\nexport function getVariantsOptions<V extends CVVariantsSchema>(variants: V) {\r\n    return Object.fromEntries(getEntries(variants).map(([cvKey, cvVal]) => [cvKey, getKeys(cvVal)])) as { [K in keyof V]: (keyof V[K])[] };\r\n}\r\n\r\ntype Entries = [PropertyKey, unknown][] | DeepReadonly<[PropertyKey, unknown][]>;\r\ntype UnionFromPairs<TArr extends Entries> =\r\n    DeepWritable<TArr> extends (infer R)[] ? R extends [infer key, infer val] ? { [prop in key & PropertyKey]: val } : never : never;\r\n\r\ntype MergeIntersectingObjects<O> = { [K in keyof O]: O[K] };\r\n\r\nexport function objectFromEntries<E extends Entries>(entries: E) {\r\n    return Object.fromEntries(entries) as Prettify<MergeIntersectingObjects<UnionToIntersection<UnionFromPairs<E>>>>;\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiC;;;ACG1B,SAAS,QAA2C,KAAQ;AAC/D,SAAO,OAAO,KAAK,GAAG;AAC1B;AAGO,SAAS,WAA8C,KAAQ;AAClE,SAAO,OAAO,QAAQ,GAAG;AAC7B;;;AD8BO,IAAM,KAAS,CAAC,QAAQ,UAAU,CAAC,MAAM;AAC5C,QAAM,EAAE,UAAU,gBAAgB,UAAU,IAAI;AAEhD,QAAM,QAAQ,QAAQ,SAAS;AAE/B,MAAI,YAAY,KAAM,QAAO,WAAS,MAAM,WAAW,OAAO,KAAK;AAEnE,QAAM,mBAAmB,OAAO,OAAO,qBAAqB,aAAa,OAAO,iBAAiB,QAAQ,IAAI,OAAO;AAEpH,SAAO,CAAC,UAAU;AACd,UAAM,oBAAoB,QAAQ,QAAQ,EAAE,IAAI,CAAC,YAAY;AACzD,YAAM,cAAc,QAAQ,OAAO;AACnC,YAAM,qBAAqB,iBAAiB,OAAO;AAEnD,YAAM,aAAc,eAAe;AAEnC,aAAO,SAAS,OAAO,EAAE,UAAU;AAAA,IACvC,CAAC;AAED,UAAM,4BAA4B,kBAAkB,OAAO,CAAC,KAAK,EAAE,OAAO,SAAS,GAAG,SAAS,MAAM;AACjG,YAAM,6BAA6B,WAAW,QAAQ,EAAE,MAAM,CAAC,CAAC,OAAO,UAAU,MAAM;AACnF,cAAM,mBAAmB,iBAAiB,KAAoC;AAC9E,cAAM,gBAAgB,QAAQ,KAA2B;AAEzD,YAAI,eAAe,KAAM,QAAO,kBAAkB;AAAA,iBACzC,eAAe,MAAO,QAAO,kBAAkB;AAExD,cAAM,WAAW,iBAAiB;AAElC,eAAO,MAAM,QAAQ,UAAU,IAAI,WAAW,SAAS,QAAkB,IAAI,aAAa;AAAA,MAC9F,CAAC;AAED,UAAI,2BAA4B,KAAI,KAAK,OAAO;AAChD,aAAO;AAAA,IACX,GAAG,IAAI,MAAkB,CAAC;AAE1B,WAAO,MAAM,QAAQ,WAAW,mBAAmB,2BAA2B,OAAO,KAAK;AAAA,EAC9F;AACJ;","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/utils.ts"],"sourcesContent":["import { ClassValue, clsx } from \"clsx\";\r\nimport { MarkRequired, Prettify, StrictExclude, Opaque } from \"ts-essentials\";\r\nimport { getEntries, getKeys, getVariantsOptions, KeysOf, VariantOptions } from \"./utils\";\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nexport type VariantProps<CVR extends (args?: any) => string> = Prettify<\r\n    Omit<NonNullable<StrictExclude<Parameters<CVR>[0], void>>, \"class\" | \"className\">\r\n>;\r\n\r\ntype ClassProp =\r\n    | { class?: ClassValue; className?: never }\r\n    | { class?: never; className?: ClassValue };\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nexport type WithClassProp<T extends Record<string, any>> = T & ClassProp;\r\n\r\ntype BooleanStringToBoolean<T> = T extends \"true\" | \"false\" ? boolean : T;\r\n\r\nexport type CVVariantsSchema = Record<string, Record<string, ClassValue>>;\r\n\r\nexport type CVVariant<V extends CVVariantsSchema> = {\r\n    [K in keyof V]?: BooleanStringToBoolean<keyof V[K]>;\r\n};\r\nexport type CVCompoundVariant<V extends CVVariantsSchema> = WithClassProp<{\r\n    [K in keyof V]?:\r\n        | BooleanStringToBoolean<keyof V[K]>\r\n        | BooleanStringToBoolean<keyof V[K]>[]\r\n        | CVToken;\r\n}>;\r\n\r\nexport type CVCompoundVariantsSchema<V extends CVVariantsSchema> = CVCompoundVariant<V>[];\r\n\r\nexport interface CVConfig<V extends CVVariantsSchema, R extends keyof V> {\r\n    base?: ClassValue;\r\n    variants?: V;\r\n    compoundVariants?:\r\n        | CVCompoundVariantsSchema<V>\r\n        | ((arg: {\r\n              variants: V;\r\n              keys: KeysOf<V>;\r\n              options: VariantOptions<V>;\r\n              defaults: CVVariant<V>;\r\n          }) => CVCompoundVariantsSchema<V>);\r\n    defaultVariant?: CVVariant<V>;\r\n    requiredProps?: R[];\r\n}\r\nexport interface CVOptions {\r\n    merge?: (...args: ClassValue[]) => string;\r\n}\r\n\r\ntype CVReturnProps<V extends CVVariantsSchema, R extends keyof V = never> =\r\n    | Prettify<WithClassProp<MarkRequired<CVVariant<V>, R>>>\r\n    | ([R] extends [never] ? void : never);\r\nexport interface CVReturn<V extends CVVariantsSchema, R extends keyof V = never> {\r\n    (props: CVReturnProps<V, R>): string;\r\n    keys: KeysOf<V>;\r\n    options: VariantOptions<V>;\r\n    defaults: CVVariant<V>;\r\n}\r\n\r\nexport interface CV {\r\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type\r\n    <V extends CVVariantsSchema, R extends keyof V = never>(\r\n        config: CVConfig<V, R>,\r\n        cvOptions?: CVOptions,\r\n    ): CVReturn<V, R>;\r\n}\r\n\r\nexport const cv: CV = (config, cvOptions = {}) => {\r\n    const merge = cvOptions.merge ?? clsx;\r\n\r\n    const { variants, defaultVariant, base } = config;\r\n\r\n    type ResolvedV = NonNullable<typeof variants>;\r\n\r\n    const keys = variants ? getKeys(variants) : [];\r\n    const options = variants ? getVariantsOptions(variants) : ({} as VariantOptions<ResolvedV>);\r\n    const defaults = defaultVariant ?? ({} as CVVariant<ResolvedV>);\r\n\r\n    const compoundVariants = variants\r\n        ? typeof config.compoundVariants === \"function\"\r\n            ? config.compoundVariants({ variants, keys, options, defaults })\r\n            : config.compoundVariants\r\n        : undefined;\r\n\r\n    const getVariant = <V extends ResolvedV, R extends keyof V = never>(\r\n        props: CVReturnProps<V, R>,\r\n    ) => {\r\n        const variantClassNames = variants\r\n            ? keys.map((variant) => {\r\n                  const variantProp = props?.[variant];\r\n                  const defaultVariantProp = defaultVariant?.[variant];\r\n\r\n                  const variantKey = variantProp?.toString() || defaultVariantProp?.toString();\r\n\r\n                  return variantKey ? variants[variant][variantKey] : undefined;\r\n              })\r\n            : undefined;\r\n\r\n        const compoundVariantClassNames = compoundVariants?.reduce(\r\n            (acc, { class: cvClass, className: cvClassName, ...cvConfig }) => {\r\n                const shouldApplyCompoundVariant = getEntries(cvConfig).every(\r\n                    ([cvKey, cvSelector]) => {\r\n                        const defaultsSelector =\r\n                            defaultVariant?.[cvKey as keyof typeof defaultVariant];\r\n                        const propsSelector = props?.[cvKey as keyof typeof props];\r\n\r\n                        if (typeof cvSelector === \"object\" && \"__token\" in cvSelector) {\r\n                            if (cvSelector.__token === onlyWhenDefined.__token) {\r\n                                return propsSelector !== undefined;\r\n                            } else if (cvSelector.__token === onlyWhenUndefined.__token) {\r\n                                return propsSelector === undefined;\r\n                            }\r\n                        }\r\n\r\n                        const selector = propsSelector ?? defaultsSelector;\r\n\r\n                        return Array.isArray(cvSelector)\r\n                            ? cvSelector.some((cvSelector) => selector === cvSelector)\r\n                            : selector === cvSelector;\r\n                    },\r\n                );\r\n\r\n                if (shouldApplyCompoundVariant) acc.push(cvClass, cvClassName);\r\n                return acc;\r\n            },\r\n            new Array<ClassValue>(),\r\n        );\r\n\r\n        return merge(\r\n            base,\r\n            variantClassNames,\r\n            compoundVariantClassNames,\r\n            props?.class,\r\n            props?.className,\r\n        );\r\n    };\r\n\r\n    return Object.assign(getVariant, { keys, options, defaults });\r\n};\r\n\r\ntype OnlyWhenDefined = Opaque<{ __token: string }, \"OnlyWhenDefined\">;\r\ntype OnlyWhenUndefined = Opaque<{ __token: string }, \"OnlyWhenUndefined\">;\r\n\r\ntype CVToken = OnlyWhenDefined | OnlyWhenUndefined;\r\n\r\n/** Apply compound variant only if prop **is** specified */\r\nexport const onlyWhenDefined = { __token: \"OnlyWhenDefined\" } as OnlyWhenDefined;\r\n/** Apply compound variant only if prop **is not** specified */\r\nexport const onlyWhenUndefined = { __token: \"OnlyWhenUndefined\" } as OnlyWhenUndefined;\r\n","import { DeepReadonly, DeepWritable, Prettify, UnionToIntersection } from \"ts-essentials\";\nimport { CVVariantsSchema } from \".\";\n\nexport type KeysOf<O extends Record<string, unknown>> = (keyof O)[];\nexport function getKeys<O extends Record<string, unknown>>(obj: O) {\n    return Object.keys(obj) as KeysOf<O>;\n}\n\nexport type EntriesOf<O extends Record<string, unknown>> = { [K in keyof O]: [K, O[K]] };\nexport function getEntries<O extends Record<string, unknown>>(obj: O) {\n    return Object.entries(obj) as EntriesOf<O>[keyof EntriesOf<O>][];\n}\n\nexport type VariantOptions<V extends CVVariantsSchema> = {\n    [K in keyof V]: KeysOf<V[K]>;\n};\nexport function getVariantsOptions<V extends CVVariantsSchema>(variants: V) {\n    return Object.fromEntries(\n        getEntries(variants).map(([cvKey, cvVal]) => [cvKey, getKeys(cvVal)]),\n    ) as VariantOptions<V>;\n}\n\ntype Entries = [PropertyKey, unknown][] | DeepReadonly<[PropertyKey, unknown][]>;\ntype UnionFromPairs<TArr extends Entries> =\n    DeepWritable<TArr> extends (infer R)[]\n        ? R extends [infer key, infer val]\n            ? { [prop in key & PropertyKey]: val }\n            : never\n        : never;\n\ntype MergeIntersectingObjects<O> = { [K in keyof O]: O[K] };\n\nexport function objectFromEntries<E extends Entries>(entries: E) {\n    return Object.fromEntries(entries) as Prettify<\n        MergeIntersectingObjects<UnionToIntersection<UnionFromPairs<E>>>\n    >;\n}\n"],"mappings":"yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,QAAAE,EAAA,oBAAAC,EAAA,sBAAAC,IAAA,eAAAC,EAAAL,GAAA,IAAAM,EAAiC,gBCI1B,SAASC,EAA2CC,EAAQ,CAC/D,OAAO,OAAO,KAAKA,CAAG,CAC1B,CAGO,SAASC,EAA8CD,EAAQ,CAClE,OAAO,OAAO,QAAQA,CAAG,CAC7B,CAKO,SAASE,EAA+CC,EAAa,CACxE,OAAO,OAAO,YACVF,EAAWE,CAAQ,EAAE,IAAI,CAAC,CAACC,EAAOC,CAAK,IAAM,CAACD,EAAOL,EAAQM,CAAK,CAAC,CAAC,CACxE,CACJ,CDgDO,IAAMC,EAAS,CAACC,EAAQC,EAAY,CAAC,IAAM,CAC9C,IAAMC,EAAQD,EAAU,OAAS,OAE3B,CAAE,SAAAE,EAAU,eAAAC,EAAgB,KAAAC,CAAK,EAAIL,EAIrCM,EAAOH,EAAWI,EAAQJ,CAAQ,EAAI,CAAC,EACvCK,EAAUL,EAAWM,EAAmBN,CAAQ,EAAK,CAAC,EACtDO,EAAWN,GAAmB,CAAC,EAE/BO,EAAmBR,EACnB,OAAOH,EAAO,kBAAqB,WAC/BA,EAAO,iBAAiB,CAAE,SAAAG,EAAU,KAAAG,EAAM,QAAAE,EAAS,SAAAE,CAAS,CAAC,EAC7DV,EAAO,iBACX,OAuDN,OAAO,OAAO,OApDVY,GACC,CACD,IAAMC,EAAoBV,EACpBG,EAAK,IAAKQ,GAAY,CAClB,IAAMC,EAAcH,IAAQE,CAAO,EAC7BE,EAAqBZ,IAAiBU,CAAO,EAE7CG,EAAaF,GAAa,SAAS,GAAKC,GAAoB,SAAS,EAE3E,OAAOC,EAAad,EAASW,CAAO,EAAEG,CAAU,EAAI,MACxD,CAAC,EACD,OAEAC,EAA4BP,GAAkB,OAChD,CAACQ,EAAK,CAAE,MAAOC,EAAS,UAAWC,EAAa,GAAGC,CAAS,KACrBC,EAAWD,CAAQ,EAAE,MACpD,CAAC,CAACE,EAAOC,CAAU,IAAM,CACrB,IAAMC,EACFtB,IAAiBoB,CAAoC,EACnDG,EAAgBf,IAAQY,CAA2B,EAEzD,GAAI,OAAOC,GAAe,UAAY,YAAaA,EAAY,CAC3D,GAAIA,EAAW,UAAYG,EAAgB,QACvC,OAAOD,IAAkB,OACtB,GAAIF,EAAW,UAAYI,EAAkB,QAChD,OAAOF,IAAkB,MAEjC,CAEA,IAAMG,EAAWH,GAAiBD,EAElC,OAAO,MAAM,QAAQD,CAAU,EACzBA,EAAW,KAAMA,GAAeK,IAAaL,CAAU,EACvDK,IAAaL,CACvB,CACJ,GAEgCN,EAAI,KAAKC,EAASC,CAAW,EACtDF,GAEX,IAAI,KACR,EAEA,OAAOjB,EACHG,EACAQ,EACAK,EACAN,GAAO,MACPA,GAAO,SACX,CACJ,EAEiC,CAAE,KAAAN,EAAM,QAAAE,EAAS,SAAAE,CAAS,CAAC,CAChE,EAQakB,EAAkB,CAAE,QAAS,iBAAkB,EAE/CC,EAAoB,CAAE,QAAS,mBAAoB","names":["src_exports","__export","cv","onlyWhenDefined","onlyWhenUndefined","__toCommonJS","import_clsx","getKeys","obj","getEntries","getVariantsOptions","variants","cvKey","cvVal","cv","config","cvOptions","merge","variants","defaultVariant","base","keys","getKeys","options","getVariantsOptions","defaults","compoundVariants","props","variantClassNames","variant","variantProp","defaultVariantProp","variantKey","compoundVariantClassNames","acc","cvClass","cvClassName","cvConfig","getEntries","cvKey","cvSelector","defaultsSelector","propsSelector","onlyWhenDefined","onlyWhenUndefined","selector"]}

package/build/index.d.cts

@@ -1,33 +1,3 @@
-import { ClassValue } from 'clsx';
-import { Prettify, MarkRequired } from 'ts-essentials';
-
-type VariantProps<CVR extends (args?: any) => string> = Prettify<Omit<NonNullable<Exclude<Parameters<CVR>[0], void>>, "class">>;
-type CVVariantsSchema = Record<string, Record<string, ClassValue>>;
-type WithClassProp<T extends Record<string, any>> = T & {
-    class?: ClassValue;
-};
-type CVCompoundVariantsSchema<V extends CVVariantsSchema> = WithClassProp<{
-    [K in keyof V]?: (keyof V[K] & string) | (keyof V[K])[] | boolean;
-}>[];
-interface CVConfig<V extends CVVariantsSchema, R extends keyof V> {
-    baseClass?: ClassValue;
-    variants?: V;
-    compoundVariants?: CVCompoundVariantsSchema<NoInfer<V>> | ((variants: NoInfer<V>) => CVCompoundVariantsSchema<NoInfer<V>>);
-    defaultVariant?: Partial<{
-        [K in keyof V]?: keyof V[K];
-    }>;
-    requiredProps?: R[];
-}
-type CVVariantProps<V extends CVVariantsSchema, R extends (keyof V)> = WithClassProp<MarkRequired<{
-    [K in keyof V]?: keyof V[K];
-}, R>>;
-type CVReturn<V extends CVVariantsSchema, R extends keyof V = never> = (props: Prettify<CVVariantProps<V, R>> | ([R] extends [never] ? void : never)) => string;
-interface CVOptions {
-    merge?: (...args: ClassValue[]) => string;
-}
-interface CV {
-    <V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>, options?: CVOptions): CVReturn<V, R>;
-}
-declare const cv: CV;
-
-export { type CV, type CVCompoundVariantsSchema, type CVConfig, type CVOptions, type CVReturn, type CVVariantProps, type CVVariantsSchema, type VariantProps, type WithClassProp, cv };
+import 'clsx';
+import 'ts-essentials';
+export { k as CV, i as CVCompoundVariant, j as CVCompoundVariantsSchema, b as CVConfig, c as CVOptions, a as CVReturn, h as CVVariant, C as CVVariantsSchema, f as VariantProps, W as WithClassProp, l as cv, m as onlyWhenDefined, n as onlyWhenUndefined } from './index-DUG5hPfi.cjs';

package/build/index.d.ts

@@ -1,33 +1,3 @@
-import { ClassValue } from 'clsx';
-import { Prettify, MarkRequired } from 'ts-essentials';
-
-type VariantProps<CVR extends (args?: any) => string> = Prettify<Omit<NonNullable<Exclude<Parameters<CVR>[0], void>>, "class">>;
-type CVVariantsSchema = Record<string, Record<string, ClassValue>>;
-type WithClassProp<T extends Record<string, any>> = T & {
-    class?: ClassValue;
-};
-type CVCompoundVariantsSchema<V extends CVVariantsSchema> = WithClassProp<{
-    [K in keyof V]?: (keyof V[K] & string) | (keyof V[K])[] | boolean;
-}>[];
-interface CVConfig<V extends CVVariantsSchema, R extends keyof V> {
-    baseClass?: ClassValue;
-    variants?: V;
-    compoundVariants?: CVCompoundVariantsSchema<NoInfer<V>> | ((variants: NoInfer<V>) => CVCompoundVariantsSchema<NoInfer<V>>);
-    defaultVariant?: Partial<{
-        [K in keyof V]?: keyof V[K];
-    }>;
-    requiredProps?: R[];
-}
-type CVVariantProps<V extends CVVariantsSchema, R extends (keyof V)> = WithClassProp<MarkRequired<{
-    [K in keyof V]?: keyof V[K];
-}, R>>;
-type CVReturn<V extends CVVariantsSchema, R extends keyof V = never> = (props: Prettify<CVVariantProps<V, R>> | ([R] extends [never] ? void : never)) => string;
-interface CVOptions {
-    merge?: (...args: ClassValue[]) => string;
-}
-interface CV {
-    <V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>, options?: CVOptions): CVReturn<V, R>;
-}
-declare const cv: CV;
-
-export { type CV, type CVCompoundVariantsSchema, type CVConfig, type CVOptions, type CVReturn, type CVVariantProps, type CVVariantsSchema, type VariantProps, type WithClassProp, cv };
+import 'clsx';
+import 'ts-essentials';
+export { k as CV, i as CVCompoundVariant, j as CVCompoundVariantsSchema, b as CVConfig, c as CVOptions, a as CVReturn, h as CVVariant, C as CVVariantsSchema, f as VariantProps, W as WithClassProp, l as cv, m as onlyWhenDefined, n as onlyWhenUndefined } from './index-DUG5hPfi.js';

package/build/index.js

@@ -1,8 +1,2 @@
-import {
-  cv
-} from "./chunk-5UWIPH6K.js";
-import "./chunk-AQSN2Y5C.js";
-export {
-  cv
-};
+import{a,b,c}from"./chunk-3XL4COYB.js";import"./chunk-BV75ULQK.js";export{a as cv,b as onlyWhenDefined,c as onlyWhenUndefined};
 //# sourceMappingURL=index.js.map

package/build/utils.cjs

@@ -1,48 +1,2 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/utils.ts
-var utils_exports = {};
-__export(utils_exports, {
-  getEntries: () => getEntries,
-  getKeys: () => getKeys,
-  getVariantsOptions: () => getVariantsOptions,
-  objectFromEntries: () => objectFromEntries
-});
-module.exports = __toCommonJS(utils_exports);
-function getKeys(obj) {
-  return Object.keys(obj);
-}
-function getEntries(obj) {
-  return Object.entries(obj);
-}
-function getVariantsOptions(variants) {
-  return Object.fromEntries(getEntries(variants).map(([cvKey, cvVal]) => [cvKey, getKeys(cvVal)]));
-}
-function objectFromEntries(entries) {
-  return Object.fromEntries(entries);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getEntries,
-  getKeys,
-  getVariantsOptions,
-  objectFromEntries
-});
+"use strict";var o=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var y=Object.prototype.hasOwnProperty;var f=(e,n)=>{for(var t in n)o(e,t,{get:n[t],enumerable:!0})},c=(e,n,t,i)=>{if(n&&typeof n=="object"||typeof n=="function")for(let r of p(n))!y.call(e,r)&&r!==t&&o(e,r,{get:()=>n[r],enumerable:!(i=a(n,r))||i.enumerable});return e};var x=e=>c(o({},"__esModule",{value:!0}),e);var k={};f(k,{getEntries:()=>O,getKeys:()=>s,getVariantsOptions:()=>d,objectFromEntries:()=>V});module.exports=x(k);function s(e){return Object.keys(e)}function O(e){return Object.entries(e)}function d(e){return Object.fromEntries(O(e).map(([n,t])=>[n,s(t)]))}function V(e){return Object.fromEntries(e)}0&&(module.exports={getEntries,getKeys,getVariantsOptions,objectFromEntries});
 //# sourceMappingURL=utils.cjs.map

package/build/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["import { DeepReadonly, DeepWritable, Prettify, UnionToIntersection } from \"ts-essentials\";\r\nimport { CVVariantsSchema } from \".\";\r\n\r\nexport function getKeys<O extends Record<string, unknown>>(obj: O) {\r\n    return Object.keys(obj) as (keyof O)[];\r\n}\r\n\r\ntype EntriesOf<O extends Record<string, unknown>> = { [K in keyof O]: [K, O[K]] };\r\nexport function getEntries<O extends Record<string, unknown>>(obj: O) {\r\n    return Object.entries(obj) as (EntriesOf<O>[keyof EntriesOf<O>])[];\r\n}\r\n\r\nexport function getVariantsOptions<V extends CVVariantsSchema>(variants: V) {\r\n    return Object.fromEntries(getEntries(variants).map(([cvKey, cvVal]) => [cvKey, getKeys(cvVal)])) as { [K in keyof V]: (keyof V[K])[] };\r\n}\r\n\r\ntype Entries = [PropertyKey, unknown][] | DeepReadonly<[PropertyKey, unknown][]>;\r\ntype UnionFromPairs<TArr extends Entries> =\r\n    DeepWritable<TArr> extends (infer R)[] ? R extends [infer key, infer val] ? { [prop in key & PropertyKey]: val } : never : never;\r\n\r\ntype MergeIntersectingObjects<O> = { [K in keyof O]: O[K] };\r\n\r\nexport function objectFromEntries<E extends Entries>(entries: E) {\r\n    return Object.fromEntries(entries) as Prettify<MergeIntersectingObjects<UnionToIntersection<UnionFromPairs<E>>>>;\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,SAAS,QAA2C,KAAQ;AAC/D,SAAO,OAAO,KAAK,GAAG;AAC1B;AAGO,SAAS,WAA8C,KAAQ;AAClE,SAAO,OAAO,QAAQ,GAAG;AAC7B;AAEO,SAAS,mBAA+C,UAAa;AACxE,SAAO,OAAO,YAAY,WAAW,QAAQ,EAAE,IAAI,CAAC,CAAC,OAAO,KAAK,MAAM,CAAC,OAAO,QAAQ,KAAK,CAAC,CAAC,CAAC;AACnG;AAQO,SAAS,kBAAqC,SAAY;AAC7D,SAAO,OAAO,YAAY,OAAO;AACrC;","names":[]}
+{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["import { DeepReadonly, DeepWritable, Prettify, UnionToIntersection } from \"ts-essentials\";\nimport { CVVariantsSchema } from \".\";\n\nexport type KeysOf<O extends Record<string, unknown>> = (keyof O)[];\nexport function getKeys<O extends Record<string, unknown>>(obj: O) {\n    return Object.keys(obj) as KeysOf<O>;\n}\n\nexport type EntriesOf<O extends Record<string, unknown>> = { [K in keyof O]: [K, O[K]] };\nexport function getEntries<O extends Record<string, unknown>>(obj: O) {\n    return Object.entries(obj) as EntriesOf<O>[keyof EntriesOf<O>][];\n}\n\nexport type VariantOptions<V extends CVVariantsSchema> = {\n    [K in keyof V]: KeysOf<V[K]>;\n};\nexport function getVariantsOptions<V extends CVVariantsSchema>(variants: V) {\n    return Object.fromEntries(\n        getEntries(variants).map(([cvKey, cvVal]) => [cvKey, getKeys(cvVal)]),\n    ) as VariantOptions<V>;\n}\n\ntype Entries = [PropertyKey, unknown][] | DeepReadonly<[PropertyKey, unknown][]>;\ntype UnionFromPairs<TArr extends Entries> =\n    DeepWritable<TArr> extends (infer R)[]\n        ? R extends [infer key, infer val]\n            ? { [prop in key & PropertyKey]: val }\n            : never\n        : never;\n\ntype MergeIntersectingObjects<O> = { [K in keyof O]: O[K] };\n\nexport function objectFromEntries<E extends Entries>(entries: E) {\n    return Object.fromEntries(entries) as Prettify<\n        MergeIntersectingObjects<UnionToIntersection<UnionFromPairs<E>>>\n    >;\n}\n"],"mappings":"yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,gBAAAE,EAAA,YAAAC,EAAA,uBAAAC,EAAA,sBAAAC,IAAA,eAAAC,EAAAN,GAIO,SAASG,EAA2CI,EAAQ,CAC/D,OAAO,OAAO,KAAKA,CAAG,CAC1B,CAGO,SAASL,EAA8CK,EAAQ,CAClE,OAAO,OAAO,QAAQA,CAAG,CAC7B,CAKO,SAASH,EAA+CI,EAAa,CACxE,OAAO,OAAO,YACVN,EAAWM,CAAQ,EAAE,IAAI,CAAC,CAACC,EAAOC,CAAK,IAAM,CAACD,EAAON,EAAQO,CAAK,CAAC,CAAC,CACxE,CACJ,CAYO,SAASL,EAAqCM,EAAY,CAC7D,OAAO,OAAO,YAAYA,CAAO,CAGrC","names":["utils_exports","__export","getEntries","getKeys","getVariantsOptions","objectFromEntries","__toCommonJS","obj","variants","cvKey","cvVal","entries"]}

package/build/utils.d.cts

@@ -1,20 +1,3 @@
-import { Prettify, UnionToIntersection, DeepReadonly, DeepWritable } from 'ts-essentials';
-import { CVVariantsSchema } from './index.cjs';
+import 'ts-essentials';
+export { E as EntriesOf, K as KeysOf, V as VariantOptions, d as getEntries, g as getKeys, e as getVariantsOptions, o as objectFromEntries } from './index-DUG5hPfi.cjs';
 import 'clsx';
-
-declare function getKeys<O extends Record<string, unknown>>(obj: O): (keyof O)[];
-type EntriesOf<O extends Record<string, unknown>> = {
-    [K in keyof O]: [K, O[K]];
-};
-declare function getEntries<O extends Record<string, unknown>>(obj: O): (EntriesOf<O>[keyof EntriesOf<O>])[];
-declare function getVariantsOptions<V extends CVVariantsSchema>(variants: V): { [K in keyof V]: (keyof V[K])[]; };
-type Entries = [PropertyKey, unknown][] | DeepReadonly<[PropertyKey, unknown][]>;
-type UnionFromPairs<TArr extends Entries> = DeepWritable<TArr> extends (infer R)[] ? R extends [infer key, infer val] ? {
-    [prop in key & PropertyKey]: val;
-} : never : never;
-type MergeIntersectingObjects<O> = {
-    [K in keyof O]: O[K];
-};
-declare function objectFromEntries<E extends Entries>(entries: E): Prettify<MergeIntersectingObjects<UnionToIntersection<UnionFromPairs<E>>>>;
-
-export { getEntries, getKeys, getVariantsOptions, objectFromEntries };

package/build/utils.d.ts

@@ -1,20 +1,3 @@
-import { Prettify, UnionToIntersection, DeepReadonly, DeepWritable } from 'ts-essentials';
-import { CVVariantsSchema } from './index.js';
+import 'ts-essentials';
+export { E as EntriesOf, K as KeysOf, V as VariantOptions, d as getEntries, g as getKeys, e as getVariantsOptions, o as objectFromEntries } from './index-DUG5hPfi.js';
 import 'clsx';
-
-declare function getKeys<O extends Record<string, unknown>>(obj: O): (keyof O)[];
-type EntriesOf<O extends Record<string, unknown>> = {
-    [K in keyof O]: [K, O[K]];
-};
-declare function getEntries<O extends Record<string, unknown>>(obj: O): (EntriesOf<O>[keyof EntriesOf<O>])[];
-declare function getVariantsOptions<V extends CVVariantsSchema>(variants: V): { [K in keyof V]: (keyof V[K])[]; };
-type Entries = [PropertyKey, unknown][] | DeepReadonly<[PropertyKey, unknown][]>;
-type UnionFromPairs<TArr extends Entries> = DeepWritable<TArr> extends (infer R)[] ? R extends [infer key, infer val] ? {
-    [prop in key & PropertyKey]: val;
-} : never : never;
-type MergeIntersectingObjects<O> = {
-    [K in keyof O]: O[K];
-};
-declare function objectFromEntries<E extends Entries>(entries: E): Prettify<MergeIntersectingObjects<UnionToIntersection<UnionFromPairs<E>>>>;
-
-export { getEntries, getKeys, getVariantsOptions, objectFromEntries };

package/build/utils.js

@@ -1,13 +1,2 @@
-import {
-  getEntries,
-  getKeys,
-  getVariantsOptions,
-  objectFromEntries
-} from "./chunk-AQSN2Y5C.js";
-export {
-  getEntries,
-  getKeys,
-  getVariantsOptions,
-  objectFromEntries
-};
+import{a,b,c,d}from"./chunk-BV75ULQK.js";export{b as getEntries,a as getKeys,c as getVariantsOptions,d as objectFromEntries};
 //# sourceMappingURL=utils.js.map

package/build/vue.cjs

@@ -1,96 +1,2 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/vue.ts
-var vue_exports = {};
-__export(vue_exports, {
-  cvWithProps: () => cvWithProps,
-  getPropsDeclaration: () => getPropsDeclaration
-});
-module.exports = __toCommonJS(vue_exports);
-
-// src/index.ts
-var import_clsx = require("clsx");
-
-// src/utils.ts
-function getKeys(obj) {
-  return Object.keys(obj);
-}
-function getEntries(obj) {
-  return Object.entries(obj);
-}
-function objectFromEntries(entries) {
-  return Object.fromEntries(entries);
-}
-
-// src/index.ts
-var cv = (config, options = {}) => {
-  const { variants, defaultVariant, baseClass } = config;
-  const merge = options.merge ?? import_clsx.clsx;
-  if (variants == null) return (props) => merge(baseClass, props?.class);
-  const compoundVariants = typeof config.compoundVariants === "function" ? config.compoundVariants(variants) : config.compoundVariants;
-  return (props) => {
-    const variantClassNames = getKeys(variants).map((variant) => {
-      const variantProp = props?.[variant];
-      const defaultVariantProp = defaultVariant?.[variant];
-      const variantKey = variantProp || defaultVariantProp;
-      return variants[variant][variantKey];
-    });
-    const compoundVariantClassNames = compoundVariants?.reduce((acc, { class: cvClass, ...cvConfig }) => {
-      const shouldApplyCompoundVariant = getEntries(cvConfig).every(([cvKey, cvSelector]) => {
-        const defaultsSelector = defaultVariant?.[cvKey];
-        const propsSelector = props?.[cvKey];
-        if (cvSelector === true) return propsSelector !== void 0;
-        else if (cvSelector === false) return propsSelector === void 0;
-        const selector = propsSelector ?? defaultsSelector;
-        return Array.isArray(cvSelector) ? cvSelector.includes(selector) : selector === cvSelector;
-      });
-      if (shouldApplyCompoundVariant) acc.push(cvClass);
-      return acc;
-    }, new Array());
-    return merge(config?.baseClass, variantClassNames, compoundVariantClassNames, props?.class);
-  };
-};
-
-// src/vue.ts
-function getPropsDeclaration(config) {
-  if (typeof config?.variants === "undefined") {
-    return {};
-  }
-  return objectFromEntries(
-    getKeys(config.variants).map((key) => [
-      key,
-      {
-        type: String,
-        required: config.requiredProps?.includes(key)
-      }
-    ])
-  );
-}
-var cvWithProps = (config, options) => {
-  const getClass = cv(config, options);
-  const props = getPropsDeclaration(config);
-  return { getClass, props };
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  cvWithProps,
-  getPropsDeclaration
-});
+"use strict";var c=Object.defineProperty;var E=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var D=Object.prototype.hasOwnProperty;var N=(e,n)=>{for(var r in n)c(e,r,{get:n[r],enumerable:!0})},j=(e,n,r,t)=>{if(n&&typeof n=="object"||typeof n=="function")for(let s of T(n))!D.call(e,s)&&s!==r&&c(e,s,{get:()=>n[s],enumerable:!(t=E(n,s))||t.enumerable});return e};var U=e=>j(c({},"__esModule",{value:!0}),e);var A={};N(A,{cvWithProps:()=>w,getPropsDeclaration:()=>P});module.exports=U(A);var g=require("clsx");function i(e){return Object.keys(e)}function l(e){return Object.entries(e)}function R(e){return Object.fromEntries(l(e).map(([n,r])=>[n,i(r)]))}function k(e){return Object.fromEntries(e)}var h=(e,n={})=>{let r=n.merge??g.clsx,{variants:t,defaultVariant:s,base:v}=e,d=t?i(t):[],C=t?R(t):{},m=s??{},K=t?typeof e.compoundVariants=="function"?e.compoundVariants({variants:t,keys:d,options:C,defaults:m}):e.compoundVariants:void 0;return Object.assign(V=>{let S=t?d.map(a=>{let f=V?.[a],y=s?.[a],p=f?.toString()||y?.toString();return p?t[a][p]:void 0}):void 0,W=K?.reduce((a,{class:f,className:y,...p})=>(l(p).every(([x,o])=>{let _=s?.[x],u=V?.[x];if(typeof o=="object"&&"__token"in o){if(o.__token===q.__token)return u!==void 0;if(o.__token===B.__token)return u===void 0}let O=u??_;return Array.isArray(o)?o.some(b=>O===b):O===o})&&a.push(f,y),a),new Array);return r(v,S,W,V?.class,V?.className)},{keys:d,options:C,defaults:m})},q={__token:"OnlyWhenDefined"},B={__token:"OnlyWhenUndefined"};function P(e){return typeof e?.variants>"u"?{}:k(i(e.variants).map(n=>[n,{type:String,required:e.requiredProps?.includes(n)}]))}var w=(e,n)=>{let r=h(e,n),t=P(e);return{getClass:r,props:t}};0&&(module.exports={cvWithProps,getPropsDeclaration});
 //# sourceMappingURL=vue.cjs.map

package/build/vue.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/vue.ts","../src/index.ts","../src/utils.ts"],"sourcesContent":["import { Prettify } from \"ts-essentials\";\r\nimport { PropType } from \"vue\";\r\nimport { CVConfig, CVOptions, CVReturn, CVVariantsSchema, cv } from \".\";\r\nimport { getKeys, objectFromEntries } from \"./utils\";\r\n\r\ntype PropsDeclaration<V extends CVVariantsSchema, R extends keyof V = never> = Prettify<{ [K in keyof V]: {\r\n    type: PropType<keyof V[K] | (K extends R ? never : undefined)>;\r\n    required: K extends R ? true : false;\r\n} }>;\r\nexport interface CVWithPropsReturn<V extends CVVariantsSchema, R extends keyof V = never> {\r\n    getClass: CVReturn<V, R>;\r\n    props: PropsDeclaration<NoInfer<V>, NoInfer<R>>;\r\n}\r\n\r\nexport interface CVWithProps {\r\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type\r\n    <V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>, options?: CVOptions): CVWithPropsReturn<V, R>;\r\n}\r\n\r\nexport function getPropsDeclaration<V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>) {\r\n    if (typeof config?.variants === \"undefined\") {\r\n        return {};\r\n    }\r\n\r\n    return objectFromEntries(\r\n        getKeys(config.variants).map(key => [\r\n            key,\r\n            {\r\n                type: String,\r\n                required: config.requiredProps?.includes(key as R),\r\n            },\r\n        ] as const),\r\n    );\r\n}\r\n\r\nexport const cvWithProps: CVWithProps = ((config, options) => {\r\n    const getClass = cv(config, options);\r\n    const props = getPropsDeclaration(config);\r\n\r\n    return { getClass, props };\r\n}) as CVWithProps;\r\n","import { ClassValue, clsx } from \"clsx\";\r\nimport { MarkRequired, Prettify } from \"ts-essentials\";\r\nimport { getEntries, getKeys } from \"./utils\";\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nexport type VariantProps<CVR extends (args?: any) => string> = Prettify<Omit<NonNullable<Exclude<Parameters<CVR>[0], void>>, \"class\">>;\r\n\r\nexport type CVVariantsSchema = Record<string, Record<string, ClassValue>>;\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nexport type WithClassProp<T extends Record<string, any>> = T & {\r\n    class?: ClassValue;\r\n};\r\n\r\nexport type CVCompoundVariantsSchema<V extends CVVariantsSchema> = WithClassProp<{\r\n    [K in keyof V]?: (keyof V[K] & string) | (keyof V[K])[] | boolean\r\n}>[];\r\n\r\nexport interface CVConfig<V extends CVVariantsSchema, R extends keyof V> {\r\n    baseClass?: ClassValue;\r\n    variants?: V;\r\n    compoundVariants?: CVCompoundVariantsSchema<NoInfer<V>> | ((variants: NoInfer<V>) => CVCompoundVariantsSchema<NoInfer<V>>);\r\n    defaultVariant?: Partial<{ [K in keyof V]?: keyof V[K] }>;\r\n    requiredProps?: R[];\r\n}\r\n\r\nexport type CVVariantProps<V extends CVVariantsSchema, R extends (keyof V)> =\r\nWithClassProp<MarkRequired<{ [K in keyof V]?: keyof V[K] }, R>>;\r\n\r\nexport type CVReturn<V extends CVVariantsSchema, R extends keyof V = never> = (props: Prettify<CVVariantProps<V, R>> | ([R] extends [never] ? void : never)) => string;\r\n\r\nexport interface CVOptions {\r\n    merge?: (...args: ClassValue[]) => string;\r\n}\r\n\r\nexport interface CV {\r\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type\r\n    <V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>, options?: CVOptions): CVReturn<V, R>;\r\n}\r\n\r\nexport const cv: CV = (config, options = {}) => {\r\n    const { variants, defaultVariant, baseClass } = config;\r\n\r\n    const merge = options.merge ?? clsx;\r\n\r\n    if (variants == null) return props => merge(baseClass, props?.class);\r\n\r\n    const compoundVariants = typeof config.compoundVariants === \"function\" ? config.compoundVariants(variants) : config.compoundVariants;\r\n\r\n    return (props) => {\r\n        const variantClassNames = getKeys(variants).map((variant) => {\r\n            const variantProp = props?.[variant];\r\n            const defaultVariantProp = defaultVariant?.[variant];\r\n\r\n            const variantKey = (variantProp || defaultVariantProp) as keyof (typeof variants)[typeof variant];\r\n\r\n            return variants[variant][variantKey];\r\n        });\r\n\r\n        const compoundVariantClassNames = compoundVariants?.reduce((acc, { class: cvClass, ...cvConfig }) => {\r\n            const shouldApplyCompoundVariant = getEntries(cvConfig).every(([cvKey, cvSelector]) => {\r\n                const defaultsSelector = defaultVariant?.[cvKey as keyof typeof defaultVariant];\r\n                const propsSelector = props?.[cvKey as keyof typeof props];\r\n\r\n                if (cvSelector === true) return propsSelector !== undefined; // only when prop is defined\r\n                else if (cvSelector === false) return propsSelector === undefined; // only when prop is not defined\r\n\r\n                const selector = propsSelector ?? defaultsSelector;\r\n\r\n                return Array.isArray(cvSelector) ? cvSelector.includes(selector as string) : selector === cvSelector;\r\n            });\r\n\r\n            if (shouldApplyCompoundVariant) acc.push(cvClass);\r\n            return acc;\r\n        }, new Array<ClassValue>());\r\n\r\n        return merge(config?.baseClass, variantClassNames, compoundVariantClassNames, props?.class);\r\n    };\r\n};\r\n","import { DeepReadonly, DeepWritable, Prettify, UnionToIntersection } from \"ts-essentials\";\r\nimport { CVVariantsSchema } from \".\";\r\n\r\nexport function getKeys<O extends Record<string, unknown>>(obj: O) {\r\n    return Object.keys(obj) as (keyof O)[];\r\n}\r\n\r\ntype EntriesOf<O extends Record<string, unknown>> = { [K in keyof O]: [K, O[K]] };\r\nexport function getEntries<O extends Record<string, unknown>>(obj: O) {\r\n    return Object.entries(obj) as (EntriesOf<O>[keyof EntriesOf<O>])[];\r\n}\r\n\r\nexport function getVariantsOptions<V extends CVVariantsSchema>(variants: V) {\r\n    return Object.fromEntries(getEntries(variants).map(([cvKey, cvVal]) => [cvKey, getKeys(cvVal)])) as { [K in keyof V]: (keyof V[K])[] };\r\n}\r\n\r\ntype Entries = [PropertyKey, unknown][] | DeepReadonly<[PropertyKey, unknown][]>;\r\ntype UnionFromPairs<TArr extends Entries> =\r\n    DeepWritable<TArr> extends (infer R)[] ? R extends [infer key, infer val] ? { [prop in key & PropertyKey]: val } : never : never;\r\n\r\ntype MergeIntersectingObjects<O> = { [K in keyof O]: O[K] };\r\n\r\nexport function objectFromEntries<E extends Entries>(entries: E) {\r\n    return Object.fromEntries(entries) as Prettify<MergeIntersectingObjects<UnionToIntersection<UnionFromPairs<E>>>>;\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,kBAAiC;;;ACG1B,SAAS,QAA2C,KAAQ;AAC/D,SAAO,OAAO,KAAK,GAAG;AAC1B;AAGO,SAAS,WAA8C,KAAQ;AAClE,SAAO,OAAO,QAAQ,GAAG;AAC7B;AAYO,SAAS,kBAAqC,SAAY;AAC7D,SAAO,OAAO,YAAY,OAAO;AACrC;;;ADgBO,IAAM,KAAS,CAAC,QAAQ,UAAU,CAAC,MAAM;AAC5C,QAAM,EAAE,UAAU,gBAAgB,UAAU,IAAI;AAEhD,QAAM,QAAQ,QAAQ,SAAS;AAE/B,MAAI,YAAY,KAAM,QAAO,WAAS,MAAM,WAAW,OAAO,KAAK;AAEnE,QAAM,mBAAmB,OAAO,OAAO,qBAAqB,aAAa,OAAO,iBAAiB,QAAQ,IAAI,OAAO;AAEpH,SAAO,CAAC,UAAU;AACd,UAAM,oBAAoB,QAAQ,QAAQ,EAAE,IAAI,CAAC,YAAY;AACzD,YAAM,cAAc,QAAQ,OAAO;AACnC,YAAM,qBAAqB,iBAAiB,OAAO;AAEnD,YAAM,aAAc,eAAe;AAEnC,aAAO,SAAS,OAAO,EAAE,UAAU;AAAA,IACvC,CAAC;AAED,UAAM,4BAA4B,kBAAkB,OAAO,CAAC,KAAK,EAAE,OAAO,SAAS,GAAG,SAAS,MAAM;AACjG,YAAM,6BAA6B,WAAW,QAAQ,EAAE,MAAM,CAAC,CAAC,OAAO,UAAU,MAAM;AACnF,cAAM,mBAAmB,iBAAiB,KAAoC;AAC9E,cAAM,gBAAgB,QAAQ,KAA2B;AAEzD,YAAI,eAAe,KAAM,QAAO,kBAAkB;AAAA,iBACzC,eAAe,MAAO,QAAO,kBAAkB;AAExD,cAAM,WAAW,iBAAiB;AAElC,eAAO,MAAM,QAAQ,UAAU,IAAI,WAAW,SAAS,QAAkB,IAAI,aAAa;AAAA,MAC9F,CAAC;AAED,UAAI,2BAA4B,KAAI,KAAK,OAAO;AAChD,aAAO;AAAA,IACX,GAAG,IAAI,MAAkB,CAAC;AAE1B,WAAO,MAAM,QAAQ,WAAW,mBAAmB,2BAA2B,OAAO,KAAK;AAAA,EAC9F;AACJ;;;AD3DO,SAAS,oBAA2E,QAAwB;AAC/G,MAAI,OAAO,QAAQ,aAAa,aAAa;AACzC,WAAO,CAAC;AAAA,EACZ;AAEA,SAAO;AAAA,IACH,QAAQ,OAAO,QAAQ,EAAE,IAAI,SAAO;AAAA,MAChC;AAAA,MACA;AAAA,QACI,MAAM;AAAA,QACN,UAAU,OAAO,eAAe,SAAS,GAAQ;AAAA,MACrD;AAAA,IACJ,CAAU;AAAA,EACd;AACJ;AAEO,IAAM,cAA4B,CAAC,QAAQ,YAAY;AAC1D,QAAM,WAAW,GAAG,QAAQ,OAAO;AACnC,QAAM,QAAQ,oBAAoB,MAAM;AAExC,SAAO,EAAE,UAAU,MAAM;AAC7B;","names":[]}
+{"version":3,"sources":["../src/vue.ts","../src/index.ts","../src/utils.ts"],"sourcesContent":["import { Prettify } from \"ts-essentials\";\nimport { PropType } from \"vue\";\nimport { CVConfig, CVOptions, CVReturn, CVVariantsSchema, cv } from \".\";\nimport { getKeys, objectFromEntries } from \"./utils\";\n\ntype PropsDeclaration<V extends CVVariantsSchema, R extends keyof V = never> = Prettify<{\n    [K in keyof V]: {\n        type: PropType<keyof V[K] | (K extends R ? never : undefined)>;\n        required: K extends R ? true : false;\n    };\n}>;\nexport interface CVWithPropsReturn<V extends CVVariantsSchema, R extends keyof V = never> {\n    getClass: CVReturn<V, R>;\n    props: PropsDeclaration<NoInfer<V>, NoInfer<R>>;\n}\n\nexport interface CVWithProps {\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type\n    <V extends CVVariantsSchema, R extends keyof V = never>(\n        config: CVConfig<V, R>,\n        options?: CVOptions,\n    ): CVWithPropsReturn<V, R>;\n}\n\nexport function getPropsDeclaration<V extends CVVariantsSchema, R extends keyof V = never>(\n    config: CVConfig<V, R>,\n) {\n    if (typeof config?.variants === \"undefined\") {\n        return {};\n    }\n\n    return objectFromEntries(\n        getKeys(config.variants).map(\n            (key) =>\n                [\n                    key,\n                    {\n                        type: String,\n                        required: config.requiredProps?.includes(key as R),\n                    },\n                ] as const,\n        ),\n    );\n}\n\nexport const cvWithProps: CVWithProps = ((config, options) => {\n    const getClass = cv(config, options);\n    const props = getPropsDeclaration(config);\n\n    return { getClass, props };\n}) as CVWithProps;\n","import { ClassValue, clsx } from \"clsx\";\r\nimport { MarkRequired, Prettify, StrictExclude, Opaque } from \"ts-essentials\";\r\nimport { getEntries, getKeys, getVariantsOptions, KeysOf, VariantOptions } from \"./utils\";\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nexport type VariantProps<CVR extends (args?: any) => string> = Prettify<\r\n    Omit<NonNullable<StrictExclude<Parameters<CVR>[0], void>>, \"class\" | \"className\">\r\n>;\r\n\r\ntype ClassProp =\r\n    | { class?: ClassValue; className?: never }\r\n    | { class?: never; className?: ClassValue };\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nexport type WithClassProp<T extends Record<string, any>> = T & ClassProp;\r\n\r\ntype BooleanStringToBoolean<T> = T extends \"true\" | \"false\" ? boolean : T;\r\n\r\nexport type CVVariantsSchema = Record<string, Record<string, ClassValue>>;\r\n\r\nexport type CVVariant<V extends CVVariantsSchema> = {\r\n    [K in keyof V]?: BooleanStringToBoolean<keyof V[K]>;\r\n};\r\nexport type CVCompoundVariant<V extends CVVariantsSchema> = WithClassProp<{\r\n    [K in keyof V]?:\r\n        | BooleanStringToBoolean<keyof V[K]>\r\n        | BooleanStringToBoolean<keyof V[K]>[]\r\n        | CVToken;\r\n}>;\r\n\r\nexport type CVCompoundVariantsSchema<V extends CVVariantsSchema> = CVCompoundVariant<V>[];\r\n\r\nexport interface CVConfig<V extends CVVariantsSchema, R extends keyof V> {\r\n    base?: ClassValue;\r\n    variants?: V;\r\n    compoundVariants?:\r\n        | CVCompoundVariantsSchema<V>\r\n        | ((arg: {\r\n              variants: V;\r\n              keys: KeysOf<V>;\r\n              options: VariantOptions<V>;\r\n              defaults: CVVariant<V>;\r\n          }) => CVCompoundVariantsSchema<V>);\r\n    defaultVariant?: CVVariant<V>;\r\n    requiredProps?: R[];\r\n}\r\nexport interface CVOptions {\r\n    merge?: (...args: ClassValue[]) => string;\r\n}\r\n\r\ntype CVReturnProps<V extends CVVariantsSchema, R extends keyof V = never> =\r\n    | Prettify<WithClassProp<MarkRequired<CVVariant<V>, R>>>\r\n    | ([R] extends [never] ? void : never);\r\nexport interface CVReturn<V extends CVVariantsSchema, R extends keyof V = never> {\r\n    (props: CVReturnProps<V, R>): string;\r\n    keys: KeysOf<V>;\r\n    options: VariantOptions<V>;\r\n    defaults: CVVariant<V>;\r\n}\r\n\r\nexport interface CV {\r\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type\r\n    <V extends CVVariantsSchema, R extends keyof V = never>(\r\n        config: CVConfig<V, R>,\r\n        cvOptions?: CVOptions,\r\n    ): CVReturn<V, R>;\r\n}\r\n\r\nexport const cv: CV = (config, cvOptions = {}) => {\r\n    const merge = cvOptions.merge ?? clsx;\r\n\r\n    const { variants, defaultVariant, base } = config;\r\n\r\n    type ResolvedV = NonNullable<typeof variants>;\r\n\r\n    const keys = variants ? getKeys(variants) : [];\r\n    const options = variants ? getVariantsOptions(variants) : ({} as VariantOptions<ResolvedV>);\r\n    const defaults = defaultVariant ?? ({} as CVVariant<ResolvedV>);\r\n\r\n    const compoundVariants = variants\r\n        ? typeof config.compoundVariants === \"function\"\r\n            ? config.compoundVariants({ variants, keys, options, defaults })\r\n            : config.compoundVariants\r\n        : undefined;\r\n\r\n    const getVariant = <V extends ResolvedV, R extends keyof V = never>(\r\n        props: CVReturnProps<V, R>,\r\n    ) => {\r\n        const variantClassNames = variants\r\n            ? keys.map((variant) => {\r\n                  const variantProp = props?.[variant];\r\n                  const defaultVariantProp = defaultVariant?.[variant];\r\n\r\n                  const variantKey = variantProp?.toString() || defaultVariantProp?.toString();\r\n\r\n                  return variantKey ? variants[variant][variantKey] : undefined;\r\n              })\r\n            : undefined;\r\n\r\n        const compoundVariantClassNames = compoundVariants?.reduce(\r\n            (acc, { class: cvClass, className: cvClassName, ...cvConfig }) => {\r\n                const shouldApplyCompoundVariant = getEntries(cvConfig).every(\r\n                    ([cvKey, cvSelector]) => {\r\n                        const defaultsSelector =\r\n                            defaultVariant?.[cvKey as keyof typeof defaultVariant];\r\n                        const propsSelector = props?.[cvKey as keyof typeof props];\r\n\r\n                        if (typeof cvSelector === \"object\" && \"__token\" in cvSelector) {\r\n                            if (cvSelector.__token === onlyWhenDefined.__token) {\r\n                                return propsSelector !== undefined;\r\n                            } else if (cvSelector.__token === onlyWhenUndefined.__token) {\r\n                                return propsSelector === undefined;\r\n                            }\r\n                        }\r\n\r\n                        const selector = propsSelector ?? defaultsSelector;\r\n\r\n                        return Array.isArray(cvSelector)\r\n                            ? cvSelector.some((cvSelector) => selector === cvSelector)\r\n                            : selector === cvSelector;\r\n                    },\r\n                );\r\n\r\n                if (shouldApplyCompoundVariant) acc.push(cvClass, cvClassName);\r\n                return acc;\r\n            },\r\n            new Array<ClassValue>(),\r\n        );\r\n\r\n        return merge(\r\n            base,\r\n            variantClassNames,\r\n            compoundVariantClassNames,\r\n            props?.class,\r\n            props?.className,\r\n        );\r\n    };\r\n\r\n    return Object.assign(getVariant, { keys, options, defaults });\r\n};\r\n\r\ntype OnlyWhenDefined = Opaque<{ __token: string }, \"OnlyWhenDefined\">;\r\ntype OnlyWhenUndefined = Opaque<{ __token: string }, \"OnlyWhenUndefined\">;\r\n\r\ntype CVToken = OnlyWhenDefined | OnlyWhenUndefined;\r\n\r\n/** Apply compound variant only if prop **is** specified */\r\nexport const onlyWhenDefined = { __token: \"OnlyWhenDefined\" } as OnlyWhenDefined;\r\n/** Apply compound variant only if prop **is not** specified */\r\nexport const onlyWhenUndefined = { __token: \"OnlyWhenUndefined\" } as OnlyWhenUndefined;\r\n","import { DeepReadonly, DeepWritable, Prettify, UnionToIntersection } from \"ts-essentials\";\nimport { CVVariantsSchema } from \".\";\n\nexport type KeysOf<O extends Record<string, unknown>> = (keyof O)[];\nexport function getKeys<O extends Record<string, unknown>>(obj: O) {\n    return Object.keys(obj) as KeysOf<O>;\n}\n\nexport type EntriesOf<O extends Record<string, unknown>> = { [K in keyof O]: [K, O[K]] };\nexport function getEntries<O extends Record<string, unknown>>(obj: O) {\n    return Object.entries(obj) as EntriesOf<O>[keyof EntriesOf<O>][];\n}\n\nexport type VariantOptions<V extends CVVariantsSchema> = {\n    [K in keyof V]: KeysOf<V[K]>;\n};\nexport function getVariantsOptions<V extends CVVariantsSchema>(variants: V) {\n    return Object.fromEntries(\n        getEntries(variants).map(([cvKey, cvVal]) => [cvKey, getKeys(cvVal)]),\n    ) as VariantOptions<V>;\n}\n\ntype Entries = [PropertyKey, unknown][] | DeepReadonly<[PropertyKey, unknown][]>;\ntype UnionFromPairs<TArr extends Entries> =\n    DeepWritable<TArr> extends (infer R)[]\n        ? R extends [infer key, infer val]\n            ? { [prop in key & PropertyKey]: val }\n            : never\n        : never;\n\ntype MergeIntersectingObjects<O> = { [K in keyof O]: O[K] };\n\nexport function objectFromEntries<E extends Entries>(entries: E) {\n    return Object.fromEntries(entries) as Prettify<\n        MergeIntersectingObjects<UnionToIntersection<UnionFromPairs<E>>>\n    >;\n}\n"],"mappings":"yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,iBAAAE,EAAA,wBAAAC,IAAA,eAAAC,EAAAJ,GCAA,IAAAK,EAAiC,gBCI1B,SAASC,EAA2CC,EAAQ,CAC/D,OAAO,OAAO,KAAKA,CAAG,CAC1B,CAGO,SAASC,EAA8CD,EAAQ,CAClE,OAAO,OAAO,QAAQA,CAAG,CAC7B,CAKO,SAASE,EAA+CC,EAAa,CACxE,OAAO,OAAO,YACVF,EAAWE,CAAQ,EAAE,IAAI,CAAC,CAACC,EAAOC,CAAK,IAAM,CAACD,EAAOL,EAAQM,CAAK,CAAC,CAAC,CACxE,CACJ,CAYO,SAASC,EAAqCC,EAAY,CAC7D,OAAO,OAAO,YAAYA,CAAO,CAGrC,CDgCO,IAAMC,EAAS,CAACC,EAAQC,EAAY,CAAC,IAAM,CAC9C,IAAMC,EAAQD,EAAU,OAAS,OAE3B,CAAE,SAAAE,EAAU,eAAAC,EAAgB,KAAAC,CAAK,EAAIL,EAIrCM,EAAOH,EAAWI,EAAQJ,CAAQ,EAAI,CAAC,EACvCK,EAAUL,EAAWM,EAAmBN,CAAQ,EAAK,CAAC,EACtDO,EAAWN,GAAmB,CAAC,EAE/BO,EAAmBR,EACnB,OAAOH,EAAO,kBAAqB,WAC/BA,EAAO,iBAAiB,CAAE,SAAAG,EAAU,KAAAG,EAAM,QAAAE,EAAS,SAAAE,CAAS,CAAC,EAC7DV,EAAO,iBACX,OAuDN,OAAO,OAAO,OApDVY,GACC,CACD,IAAMC,EAAoBV,EACpBG,EAAK,IAAKQ,GAAY,CAClB,IAAMC,EAAcH,IAAQE,CAAO,EAC7BE,EAAqBZ,IAAiBU,CAAO,EAE7CG,EAAaF,GAAa,SAAS,GAAKC,GAAoB,SAAS,EAE3E,OAAOC,EAAad,EAASW,CAAO,EAAEG,CAAU,EAAI,MACxD,CAAC,EACD,OAEAC,EAA4BP,GAAkB,OAChD,CAACQ,EAAK,CAAE,MAAOC,EAAS,UAAWC,EAAa,GAAGC,CAAS,KACrBC,EAAWD,CAAQ,EAAE,MACpD,CAAC,CAACE,EAAOC,CAAU,IAAM,CACrB,IAAMC,EACFtB,IAAiBoB,CAAoC,EACnDG,EAAgBf,IAAQY,CAA2B,EAEzD,GAAI,OAAOC,GAAe,UAAY,YAAaA,EAAY,CAC3D,GAAIA,EAAW,UAAYG,EAAgB,QACvC,OAAOD,IAAkB,OACtB,GAAIF,EAAW,UAAYI,EAAkB,QAChD,OAAOF,IAAkB,MAEjC,CAEA,IAAMG,EAAWH,GAAiBD,EAElC,OAAO,MAAM,QAAQD,CAAU,EACzBA,EAAW,KAAMA,GAAeK,IAAaL,CAAU,EACvDK,IAAaL,CACvB,CACJ,GAEgCN,EAAI,KAAKC,EAASC,CAAW,EACtDF,GAEX,IAAI,KACR,EAEA,OAAOjB,EACHG,EACAQ,EACAK,EACAN,GAAO,MACPA,GAAO,SACX,CACJ,EAEiC,CAAE,KAAAN,EAAM,QAAAE,EAAS,SAAAE,CAAS,CAAC,CAChE,EAQakB,EAAkB,CAAE,QAAS,iBAAkB,EAE/CC,EAAoB,CAAE,QAAS,mBAAoB,ED7HzD,SAASE,EACZC,EACF,CACE,OAAI,OAAOA,GAAQ,SAAa,IACrB,CAAC,EAGLC,EACHC,EAAQF,EAAO,QAAQ,EAAE,IACpBG,GACG,CACIA,EACA,CACI,KAAM,OACN,SAAUH,EAAO,eAAe,SAASG,CAAQ,CACrD,CACJ,CACR,CACJ,CACJ,CAEO,IAAMC,EAA4B,CAACJ,EAAQK,IAAY,CAC1D,IAAMC,EAAWC,EAAGP,EAAQK,CAAO,EAC7BG,EAAQT,EAAoBC,CAAM,EAExC,MAAO,CAAE,SAAAM,EAAU,MAAAE,CAAM,CAC7B","names":["vue_exports","__export","cvWithProps","getPropsDeclaration","__toCommonJS","import_clsx","getKeys","obj","getEntries","getVariantsOptions","variants","cvKey","cvVal","objectFromEntries","entries","cv","config","cvOptions","merge","variants","defaultVariant","base","keys","getKeys","options","getVariantsOptions","defaults","compoundVariants","props","variantClassNames","variant","variantProp","defaultVariantProp","variantKey","compoundVariantClassNames","acc","cvClass","cvClassName","cvConfig","getEntries","cvKey","cvSelector","defaultsSelector","propsSelector","onlyWhenDefined","onlyWhenUndefined","selector","getPropsDeclaration","config","objectFromEntries","getKeys","key","cvWithProps","options","getClass","cv","props"]}

package/build/vue.d.cts

@@ -1,6 +1,6 @@
 import { Prettify } from 'ts-essentials';
 import { PropType } from 'vue';
-import { CVVariantsSchema, CVReturn, CVConfig, CVOptions } from './index.cjs';
+import { C as CVVariantsSchema, a as CVReturn, b as CVConfig, c as CVOptions } from './index-DUG5hPfi.cjs';
 import 'clsx';
 
 type PropsDeclaration<V extends CVVariantsSchema, R extends keyof V = never> = Prettify<{

package/build/vue.d.ts

@@ -1,6 +1,6 @@
 import { Prettify } from 'ts-essentials';
 import { PropType } from 'vue';
-import { CVVariantsSchema, CVReturn, CVConfig, CVOptions } from './index.js';
+import { C as CVVariantsSchema, a as CVReturn, b as CVConfig, c as CVOptions } from './index-DUG5hPfi.js';
 import 'clsx';
 
 type PropsDeclaration<V extends CVVariantsSchema, R extends keyof V = never> = Prettify<{

package/build/vue.js

@@ -1,33 +1,2 @@
-import {
-  cv
-} from "./chunk-5UWIPH6K.js";
-import {
-  getKeys,
-  objectFromEntries
-} from "./chunk-AQSN2Y5C.js";
-
-// src/vue.ts
-function getPropsDeclaration(config) {
-  if (typeof config?.variants === "undefined") {
-    return {};
-  }
-  return objectFromEntries(
-    getKeys(config.variants).map((key) => [
-      key,
-      {
-        type: String,
-        required: config.requiredProps?.includes(key)
-      }
-    ])
-  );
-}
-var cvWithProps = (config, options) => {
-  const getClass = cv(config, options);
-  const props = getPropsDeclaration(config);
-  return { getClass, props };
-};
-export {
-  cvWithProps,
-  getPropsDeclaration
-};
+import{a as o}from"./chunk-3XL4COYB.js";import{a as t,d as n}from"./chunk-BV75ULQK.js";function V(e){return typeof e?.variants>"u"?{}:n(t(e.variants).map(r=>[r,{type:String,required:e.requiredProps?.includes(r)}]))}var R=(e,r)=>{let s=o(e,r),i=V(e);return{getClass:s,props:i}};export{R as cvWithProps,V as getPropsDeclaration};
 //# sourceMappingURL=vue.js.map

package/build/vue.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/vue.ts"],"sourcesContent":["import { Prettify } from \"ts-essentials\";\r\nimport { PropType } from \"vue\";\r\nimport { CVConfig, CVOptions, CVReturn, CVVariantsSchema, cv } from \".\";\r\nimport { getKeys, objectFromEntries } from \"./utils\";\r\n\r\ntype PropsDeclaration<V extends CVVariantsSchema, R extends keyof V = never> = Prettify<{ [K in keyof V]: {\r\n    type: PropType<keyof V[K] | (K extends R ? never : undefined)>;\r\n    required: K extends R ? true : false;\r\n} }>;\r\nexport interface CVWithPropsReturn<V extends CVVariantsSchema, R extends keyof V = never> {\r\n    getClass: CVReturn<V, R>;\r\n    props: PropsDeclaration<NoInfer<V>, NoInfer<R>>;\r\n}\r\n\r\nexport interface CVWithProps {\r\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type\r\n    <V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>, options?: CVOptions): CVWithPropsReturn<V, R>;\r\n}\r\n\r\nexport function getPropsDeclaration<V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>) {\r\n    if (typeof config?.variants === \"undefined\") {\r\n        return {};\r\n    }\r\n\r\n    return objectFromEntries(\r\n        getKeys(config.variants).map(key => [\r\n            key,\r\n            {\r\n                type: String,\r\n                required: config.requiredProps?.includes(key as R),\r\n            },\r\n        ] as const),\r\n    );\r\n}\r\n\r\nexport const cvWithProps: CVWithProps = ((config, options) => {\r\n    const getClass = cv(config, options);\r\n    const props = getPropsDeclaration(config);\r\n\r\n    return { getClass, props };\r\n}) as CVWithProps;\r\n"],"mappings":";;;;;;;;;AAmBO,SAAS,oBAA2E,QAAwB;AAC/G,MAAI,OAAO,QAAQ,aAAa,aAAa;AACzC,WAAO,CAAC;AAAA,EACZ;AAEA,SAAO;AAAA,IACH,QAAQ,OAAO,QAAQ,EAAE,IAAI,SAAO;AAAA,MAChC;AAAA,MACA;AAAA,QACI,MAAM;AAAA,QACN,UAAU,OAAO,eAAe,SAAS,GAAQ;AAAA,MACrD;AAAA,IACJ,CAAU;AAAA,EACd;AACJ;AAEO,IAAM,cAA4B,CAAC,QAAQ,YAAY;AAC1D,QAAM,WAAW,GAAG,QAAQ,OAAO;AACnC,QAAM,QAAQ,oBAAoB,MAAM;AAExC,SAAO,EAAE,UAAU,MAAM;AAC7B;","names":[]}
+{"version":3,"sources":["../src/vue.ts"],"sourcesContent":["import { Prettify } from \"ts-essentials\";\nimport { PropType } from \"vue\";\nimport { CVConfig, CVOptions, CVReturn, CVVariantsSchema, cv } from \".\";\nimport { getKeys, objectFromEntries } from \"./utils\";\n\ntype PropsDeclaration<V extends CVVariantsSchema, R extends keyof V = never> = Prettify<{\n    [K in keyof V]: {\n        type: PropType<keyof V[K] | (K extends R ? never : undefined)>;\n        required: K extends R ? true : false;\n    };\n}>;\nexport interface CVWithPropsReturn<V extends CVVariantsSchema, R extends keyof V = never> {\n    getClass: CVReturn<V, R>;\n    props: PropsDeclaration<NoInfer<V>, NoInfer<R>>;\n}\n\nexport interface CVWithProps {\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type\n    <V extends CVVariantsSchema, R extends keyof V = never>(\n        config: CVConfig<V, R>,\n        options?: CVOptions,\n    ): CVWithPropsReturn<V, R>;\n}\n\nexport function getPropsDeclaration<V extends CVVariantsSchema, R extends keyof V = never>(\n    config: CVConfig<V, R>,\n) {\n    if (typeof config?.variants === \"undefined\") {\n        return {};\n    }\n\n    return objectFromEntries(\n        getKeys(config.variants).map(\n            (key) =>\n                [\n                    key,\n                    {\n                        type: String,\n                        required: config.requiredProps?.includes(key as R),\n                    },\n                ] as const,\n        ),\n    );\n}\n\nexport const cvWithProps: CVWithProps = ((config, options) => {\n    const getClass = cv(config, options);\n    const props = getPropsDeclaration(config);\n\n    return { getClass, props };\n}) as CVWithProps;\n"],"mappings":"uFAwBO,SAASA,EACZC,EACF,CACE,OAAI,OAAOA,GAAQ,SAAa,IACrB,CAAC,EAGLC,EACHC,EAAQF,EAAO,QAAQ,EAAE,IACpBG,GACG,CACIA,EACA,CACI,KAAM,OACN,SAAUH,EAAO,eAAe,SAASG,CAAQ,CACrD,CACJ,CACR,CACJ,CACJ,CAEO,IAAMC,EAA4B,CAACJ,EAAQK,IAAY,CAC1D,IAAMC,EAAWC,EAAGP,EAAQK,CAAO,EAC7BG,EAAQT,EAAoBC,CAAM,EAExC,MAAO,CAAE,SAAAM,EAAU,MAAAE,CAAM,CAC7B","names":["getPropsDeclaration","config","objectFromEntries","getKeys","key","cvWithProps","options","getClass","cv","props"]}

package/package.json

@@ -1,57 +1,61 @@
 {
-  "name": "@yaredfall/class-variants",
-  "author": "yaredfall",
-  "private": false,
-  "publishConfig": {
-    "access": "public"
-  },
-  "version": "0.0.8",
-  "type": "module",
-  "main": "build/index.cjs",
-  "module": "build/index.js",
-  "types": "build/index.d.ts",
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./build/index.d.ts",
-        "default": "./build/index.js"
-      },
-      "require": {
-        "types": "./build/index.d.cts",
-        "default": "./build/index.cjs"
-      }
+    "name": "@yaredfall/class-variants",
+    "author": "yaredfall",
+    "private": false,
+    "publishConfig": {
+        "access": "public"
     },
-    "./utils": {
-      "import": {
-        "types": "./build/utils.d.ts",
-        "default": "./build/utils.js"
-      },
-      "require": {
-        "types": "./build/utils.d.cts",
-        "default": "./build/utils.cjs"
-      }
+    "version": "0.1.1",
+    "type": "module",
+    "files": [
+        "build"
+    ],
+    "main": "build/index.cjs",
+    "module": "build/index.js",
+    "types": "build/index.d.ts",
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./build/index.d.ts",
+                "default": "./build/index.js"
+            },
+            "require": {
+                "types": "./build/index.d.cts",
+                "default": "./build/index.cjs"
+            }
+        },
+        "./utils": {
+            "import": {
+                "types": "./build/utils.d.ts",
+                "default": "./build/utils.js"
+            },
+            "require": {
+                "types": "./build/utils.d.cts",
+                "default": "./build/utils.cjs"
+            }
+        },
+        "./vue": {
+            "import": {
+                "types": "./build/vue.d.ts",
+                "default": "./build/vue.js"
+            },
+            "require": {
+                "types": "./build/vue.d.cts",
+                "default": "./build/vue.cjs"
+            }
+        },
+        "./package.json": "./package.json"
     },
-    "./vue": {
-      "import": {
-        "types": "./build/vue.d.ts",
-        "default": "./build/vue.js"
-      },
-      "require": {
-        "types": "./build/vue.d.cts",
-        "default": "./build/vue.cjs"
-      }
+    "scripts": {
+        "build": "tsc && tsup",
+        "prepack": "npm run build"
     },
-    "./package.json": "./package.json"
-  },
-  "scripts": {
-    "build": "tsc && tsup"
-  },
-  "devDependencies": {
-    "tsup": "^8.1.0",
-    "typescript": "^5.2.2",
-    "vue": "^3.4.29"
-  },
-  "dependencies": {
-    "clsx": "^2.1.1"
-  }
+    "devDependencies": {
+        "tsup": "^8.1.0",
+        "typescript": "^5.2.2",
+        "vue": "^3.4.29"
+    },
+    "dependencies": {
+        "clsx": "^2.1.1"
+    }
 }

package/build/chunk-5UWIPH6K.js

@@ -1,39 +0,0 @@
-import {
-  getEntries,
-  getKeys
-} from "./chunk-AQSN2Y5C.js";
-
-// src/index.ts
-import { clsx } from "clsx";
-var cv = (config, options = {}) => {
-  const { variants, defaultVariant, baseClass } = config;
-  const merge = options.merge ?? clsx;
-  if (variants == null) return (props) => merge(baseClass, props?.class);
-  const compoundVariants = typeof config.compoundVariants === "function" ? config.compoundVariants(variants) : config.compoundVariants;
-  return (props) => {
-    const variantClassNames = getKeys(variants).map((variant) => {
-      const variantProp = props?.[variant];
-      const defaultVariantProp = defaultVariant?.[variant];
-      const variantKey = variantProp || defaultVariantProp;
-      return variants[variant][variantKey];
-    });
-    const compoundVariantClassNames = compoundVariants?.reduce((acc, { class: cvClass, ...cvConfig }) => {
-      const shouldApplyCompoundVariant = getEntries(cvConfig).every(([cvKey, cvSelector]) => {
-        const defaultsSelector = defaultVariant?.[cvKey];
-        const propsSelector = props?.[cvKey];
-        if (cvSelector === true) return propsSelector !== void 0;
-        else if (cvSelector === false) return propsSelector === void 0;
-        const selector = propsSelector ?? defaultsSelector;
-        return Array.isArray(cvSelector) ? cvSelector.includes(selector) : selector === cvSelector;
-      });
-      if (shouldApplyCompoundVariant) acc.push(cvClass);
-      return acc;
-    }, new Array());
-    return merge(config?.baseClass, variantClassNames, compoundVariantClassNames, props?.class);
-  };
-};
-
-export {
-  cv
-};
-//# sourceMappingURL=chunk-5UWIPH6K.js.map

package/build/chunk-5UWIPH6K.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { ClassValue, clsx } from \"clsx\";\r\nimport { MarkRequired, Prettify } from \"ts-essentials\";\r\nimport { getEntries, getKeys } from \"./utils\";\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nexport type VariantProps<CVR extends (args?: any) => string> = Prettify<Omit<NonNullable<Exclude<Parameters<CVR>[0], void>>, \"class\">>;\r\n\r\nexport type CVVariantsSchema = Record<string, Record<string, ClassValue>>;\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nexport type WithClassProp<T extends Record<string, any>> = T & {\r\n    class?: ClassValue;\r\n};\r\n\r\nexport type CVCompoundVariantsSchema<V extends CVVariantsSchema> = WithClassProp<{\r\n    [K in keyof V]?: (keyof V[K] & string) | (keyof V[K])[] | boolean\r\n}>[];\r\n\r\nexport interface CVConfig<V extends CVVariantsSchema, R extends keyof V> {\r\n    baseClass?: ClassValue;\r\n    variants?: V;\r\n    compoundVariants?: CVCompoundVariantsSchema<NoInfer<V>> | ((variants: NoInfer<V>) => CVCompoundVariantsSchema<NoInfer<V>>);\r\n    defaultVariant?: Partial<{ [K in keyof V]?: keyof V[K] }>;\r\n    requiredProps?: R[];\r\n}\r\n\r\nexport type CVVariantProps<V extends CVVariantsSchema, R extends (keyof V)> =\r\nWithClassProp<MarkRequired<{ [K in keyof V]?: keyof V[K] }, R>>;\r\n\r\nexport type CVReturn<V extends CVVariantsSchema, R extends keyof V = never> = (props: Prettify<CVVariantProps<V, R>> | ([R] extends [never] ? void : never)) => string;\r\n\r\nexport interface CVOptions {\r\n    merge?: (...args: ClassValue[]) => string;\r\n}\r\n\r\nexport interface CV {\r\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type\r\n    <V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>, options?: CVOptions): CVReturn<V, R>;\r\n}\r\n\r\nexport const cv: CV = (config, options = {}) => {\r\n    const { variants, defaultVariant, baseClass } = config;\r\n\r\n    const merge = options.merge ?? clsx;\r\n\r\n    if (variants == null) return props => merge(baseClass, props?.class);\r\n\r\n    const compoundVariants = typeof config.compoundVariants === \"function\" ? config.compoundVariants(variants) : config.compoundVariants;\r\n\r\n    return (props) => {\r\n        const variantClassNames = getKeys(variants).map((variant) => {\r\n            const variantProp = props?.[variant];\r\n            const defaultVariantProp = defaultVariant?.[variant];\r\n\r\n            const variantKey = (variantProp || defaultVariantProp) as keyof (typeof variants)[typeof variant];\r\n\r\n            return variants[variant][variantKey];\r\n        });\r\n\r\n        const compoundVariantClassNames = compoundVariants?.reduce((acc, { class: cvClass, ...cvConfig }) => {\r\n            const shouldApplyCompoundVariant = getEntries(cvConfig).every(([cvKey, cvSelector]) => {\r\n                const defaultsSelector = defaultVariant?.[cvKey as keyof typeof defaultVariant];\r\n                const propsSelector = props?.[cvKey as keyof typeof props];\r\n\r\n                if (cvSelector === true) return propsSelector !== undefined; // only when prop is defined\r\n                else if (cvSelector === false) return propsSelector === undefined; // only when prop is not defined\r\n\r\n                const selector = propsSelector ?? defaultsSelector;\r\n\r\n                return Array.isArray(cvSelector) ? cvSelector.includes(selector as string) : selector === cvSelector;\r\n            });\r\n\r\n            if (shouldApplyCompoundVariant) acc.push(cvClass);\r\n            return acc;\r\n        }, new Array<ClassValue>());\r\n\r\n        return merge(config?.baseClass, variantClassNames, compoundVariantClassNames, props?.class);\r\n    };\r\n};\r\n"],"mappings":";;;;;;AAAA,SAAqB,YAAY;AAwC1B,IAAM,KAAS,CAAC,QAAQ,UAAU,CAAC,MAAM;AAC5C,QAAM,EAAE,UAAU,gBAAgB,UAAU,IAAI;AAEhD,QAAM,QAAQ,QAAQ,SAAS;AAE/B,MAAI,YAAY,KAAM,QAAO,WAAS,MAAM,WAAW,OAAO,KAAK;AAEnE,QAAM,mBAAmB,OAAO,OAAO,qBAAqB,aAAa,OAAO,iBAAiB,QAAQ,IAAI,OAAO;AAEpH,SAAO,CAAC,UAAU;AACd,UAAM,oBAAoB,QAAQ,QAAQ,EAAE,IAAI,CAAC,YAAY;AACzD,YAAM,cAAc,QAAQ,OAAO;AACnC,YAAM,qBAAqB,iBAAiB,OAAO;AAEnD,YAAM,aAAc,eAAe;AAEnC,aAAO,SAAS,OAAO,EAAE,UAAU;AAAA,IACvC,CAAC;AAED,UAAM,4BAA4B,kBAAkB,OAAO,CAAC,KAAK,EAAE,OAAO,SAAS,GAAG,SAAS,MAAM;AACjG,YAAM,6BAA6B,WAAW,QAAQ,EAAE,MAAM,CAAC,CAAC,OAAO,UAAU,MAAM;AACnF,cAAM,mBAAmB,iBAAiB,KAAoC;AAC9E,cAAM,gBAAgB,QAAQ,KAA2B;AAEzD,YAAI,eAAe,KAAM,QAAO,kBAAkB;AAAA,iBACzC,eAAe,MAAO,QAAO,kBAAkB;AAExD,cAAM,WAAW,iBAAiB;AAElC,eAAO,MAAM,QAAQ,UAAU,IAAI,WAAW,SAAS,QAAkB,IAAI,aAAa;AAAA,MAC9F,CAAC;AAED,UAAI,2BAA4B,KAAI,KAAK,OAAO;AAChD,aAAO;AAAA,IACX,GAAG,IAAI,MAAkB,CAAC;AAE1B,WAAO,MAAM,QAAQ,WAAW,mBAAmB,2BAA2B,OAAO,KAAK;AAAA,EAC9F;AACJ;","names":[]}

package/build/chunk-AQSN2Y5C.js

@@ -1,21 +0,0 @@
-// src/utils.ts
-function getKeys(obj) {
-  return Object.keys(obj);
-}
-function getEntries(obj) {
-  return Object.entries(obj);
-}
-function getVariantsOptions(variants) {
-  return Object.fromEntries(getEntries(variants).map(([cvKey, cvVal]) => [cvKey, getKeys(cvVal)]));
-}
-function objectFromEntries(entries) {
-  return Object.fromEntries(entries);
-}
-
-export {
-  getKeys,
-  getEntries,
-  getVariantsOptions,
-  objectFromEntries
-};
-//# sourceMappingURL=chunk-AQSN2Y5C.js.map

package/build/chunk-AQSN2Y5C.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["import { DeepReadonly, DeepWritable, Prettify, UnionToIntersection } from \"ts-essentials\";\r\nimport { CVVariantsSchema } from \".\";\r\n\r\nexport function getKeys<O extends Record<string, unknown>>(obj: O) {\r\n    return Object.keys(obj) as (keyof O)[];\r\n}\r\n\r\ntype EntriesOf<O extends Record<string, unknown>> = { [K in keyof O]: [K, O[K]] };\r\nexport function getEntries<O extends Record<string, unknown>>(obj: O) {\r\n    return Object.entries(obj) as (EntriesOf<O>[keyof EntriesOf<O>])[];\r\n}\r\n\r\nexport function getVariantsOptions<V extends CVVariantsSchema>(variants: V) {\r\n    return Object.fromEntries(getEntries(variants).map(([cvKey, cvVal]) => [cvKey, getKeys(cvVal)])) as { [K in keyof V]: (keyof V[K])[] };\r\n}\r\n\r\ntype Entries = [PropertyKey, unknown][] | DeepReadonly<[PropertyKey, unknown][]>;\r\ntype UnionFromPairs<TArr extends Entries> =\r\n    DeepWritable<TArr> extends (infer R)[] ? R extends [infer key, infer val] ? { [prop in key & PropertyKey]: val } : never : never;\r\n\r\ntype MergeIntersectingObjects<O> = { [K in keyof O]: O[K] };\r\n\r\nexport function objectFromEntries<E extends Entries>(entries: E) {\r\n    return Object.fromEntries(entries) as Prettify<MergeIntersectingObjects<UnionToIntersection<UnionFromPairs<E>>>>;\r\n}\r\n"],"mappings":";AAGO,SAAS,QAA2C,KAAQ;AAC/D,SAAO,OAAO,KAAK,GAAG;AAC1B;AAGO,SAAS,WAA8C,KAAQ;AAClE,SAAO,OAAO,QAAQ,GAAG;AAC7B;AAEO,SAAS,mBAA+C,UAAa;AACxE,SAAO,OAAO,YAAY,WAAW,QAAQ,EAAE,IAAI,CAAC,CAAC,OAAO,KAAK,MAAM,CAAC,OAAO,QAAQ,KAAK,CAAC,CAAC,CAAC;AACnG;AAQO,SAAS,kBAAqC,SAAY;AAC7D,SAAO,OAAO,YAAY,OAAO;AACrC;","names":[]}

package/src/index.ts

@@ -1,79 +0,0 @@
-import { ClassValue, clsx } from "clsx";
-import { MarkRequired, Prettify } from "ts-essentials";
-import { getEntries, getKeys } from "./utils";
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type VariantProps<CVR extends (args?: any) => string> = Prettify<Omit<NonNullable<Exclude<Parameters<CVR>[0], void>>, "class">>;
-
-export type CVVariantsSchema = Record<string, Record<string, ClassValue>>;
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type WithClassProp<T extends Record<string, any>> = T & {
-    class?: ClassValue;
-};
-
-export type CVCompoundVariantsSchema<V extends CVVariantsSchema> = WithClassProp<{
-    [K in keyof V]?: (keyof V[K] & string) | (keyof V[K])[] | boolean
-}>[];
-
-export interface CVConfig<V extends CVVariantsSchema, R extends keyof V> {
-    baseClass?: ClassValue;
-    variants?: V;
-    compoundVariants?: CVCompoundVariantsSchema<NoInfer<V>> | ((variants: NoInfer<V>) => CVCompoundVariantsSchema<NoInfer<V>>);
-    defaultVariant?: Partial<{ [K in keyof V]?: keyof V[K] }>;
-    requiredProps?: R[];
-}
-
-export type CVVariantProps<V extends CVVariantsSchema, R extends (keyof V)> =
-WithClassProp<MarkRequired<{ [K in keyof V]?: keyof V[K] }, R>>;
-
-export type CVReturn<V extends CVVariantsSchema, R extends keyof V = never> = (props: Prettify<CVVariantProps<V, R>> | ([R] extends [never] ? void : never)) => string;
-
-export interface CVOptions {
-    merge?: (...args: ClassValue[]) => string;
-}
-
-export interface CV {
-    // eslint-disable-next-line @typescript-eslint/prefer-function-type
-    <V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>, options?: CVOptions): CVReturn<V, R>;
-}
-
-export const cv: CV = (config, options = {}) => {
-    const { variants, defaultVariant, baseClass } = config;
-
-    const merge = options.merge ?? clsx;
-
-    if (variants == null) return props => merge(baseClass, props?.class);
-
-    const compoundVariants = typeof config.compoundVariants === "function" ? config.compoundVariants(variants) : config.compoundVariants;
-
-    return (props) => {
-        const variantClassNames = getKeys(variants).map((variant) => {
-            const variantProp = props?.[variant];
-            const defaultVariantProp = defaultVariant?.[variant];
-
-            const variantKey = (variantProp || defaultVariantProp) as keyof (typeof variants)[typeof variant];
-
-            return variants[variant][variantKey];
-        });
-
-        const compoundVariantClassNames = compoundVariants?.reduce((acc, { class: cvClass, ...cvConfig }) => {
-            const shouldApplyCompoundVariant = getEntries(cvConfig).every(([cvKey, cvSelector]) => {
-                const defaultsSelector = defaultVariant?.[cvKey as keyof typeof defaultVariant];
-                const propsSelector = props?.[cvKey as keyof typeof props];
-
-                if (cvSelector === true) return propsSelector !== undefined; // only when prop is defined
-                else if (cvSelector === false) return propsSelector === undefined; // only when prop is not defined
-
-                const selector = propsSelector ?? defaultsSelector;
-
-                return Array.isArray(cvSelector) ? cvSelector.includes(selector as string) : selector === cvSelector;
-            });
-
-            if (shouldApplyCompoundVariant) acc.push(cvClass);
-            return acc;
-        }, new Array<ClassValue>());
-
-        return merge(config?.baseClass, variantClassNames, compoundVariantClassNames, props?.class);
-    };
-};

package/src/utils.ts

@@ -1,25 +0,0 @@
-import { DeepReadonly, DeepWritable, Prettify, UnionToIntersection } from "ts-essentials";
-import { CVVariantsSchema } from ".";
-
-export function getKeys<O extends Record<string, unknown>>(obj: O) {
-    return Object.keys(obj) as (keyof O)[];
-}
-
-type EntriesOf<O extends Record<string, unknown>> = { [K in keyof O]: [K, O[K]] };
-export function getEntries<O extends Record<string, unknown>>(obj: O) {
-    return Object.entries(obj) as (EntriesOf<O>[keyof EntriesOf<O>])[];
-}
-
-export function getVariantsOptions<V extends CVVariantsSchema>(variants: V) {
-    return Object.fromEntries(getEntries(variants).map(([cvKey, cvVal]) => [cvKey, getKeys(cvVal)])) as { [K in keyof V]: (keyof V[K])[] };
-}
-
-type Entries = [PropertyKey, unknown][] | DeepReadonly<[PropertyKey, unknown][]>;
-type UnionFromPairs<TArr extends Entries> =
-    DeepWritable<TArr> extends (infer R)[] ? R extends [infer key, infer val] ? { [prop in key & PropertyKey]: val } : never : never;
-
-type MergeIntersectingObjects<O> = { [K in keyof O]: O[K] };
-
-export function objectFromEntries<E extends Entries>(entries: E) {
-    return Object.fromEntries(entries) as Prettify<MergeIntersectingObjects<UnionToIntersection<UnionFromPairs<E>>>>;
-}

package/src/vue.ts

@@ -1,41 +0,0 @@
-import { Prettify } from "ts-essentials";
-import { PropType } from "vue";
-import { CVConfig, CVOptions, CVReturn, CVVariantsSchema, cv } from ".";
-import { getKeys, objectFromEntries } from "./utils";
-
-type PropsDeclaration<V extends CVVariantsSchema, R extends keyof V = never> = Prettify<{ [K in keyof V]: {
-    type: PropType<keyof V[K] | (K extends R ? never : undefined)>;
-    required: K extends R ? true : false;
-} }>;
-export interface CVWithPropsReturn<V extends CVVariantsSchema, R extends keyof V = never> {
-    getClass: CVReturn<V, R>;
-    props: PropsDeclaration<NoInfer<V>, NoInfer<R>>;
-}
-
-export interface CVWithProps {
-    // eslint-disable-next-line @typescript-eslint/prefer-function-type
-    <V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>, options?: CVOptions): CVWithPropsReturn<V, R>;
-}
-
-export function getPropsDeclaration<V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>) {
-    if (typeof config?.variants === "undefined") {
-        return {};
-    }
-
-    return objectFromEntries(
-        getKeys(config.variants).map(key => [
-            key,
-            {
-                type: String,
-                required: config.requiredProps?.includes(key as R),
-            },
-        ] as const),
-    );
-}
-
-export const cvWithProps: CVWithProps = ((config, options) => {
-    const getClass = cv(config, options);
-    const props = getPropsDeclaration(config);
-
-    return { getClass, props };
-}) as CVWithProps;

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "useDefineForClassFields": true,
-    "module": "ESNext",
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
-    "skipLibCheck": true,
-
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noEmit": true,
-
-    /* Linting */
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true
-  },
-  "include": ["src"]
-}

package/tsup.config.js

@@ -1,13 +0,0 @@
-import { defineConfig } from "tsup";
-
-export default defineConfig(
-    {
-        entry: ["src/*.ts"],
-        format: ["cjs", "esm"],
-        target: ["chrome91", "firefox90", "edge91", "safari15", "ios15", "opera77"],
-        outDir: "build",
-        dts: true,
-        sourcemap: true,
-        clean: true,
-    },
-);