@yaredfall/class-variants 0.0.1

package/build/chunk-3RDDXOQ3.js

@@ -0,0 +1,17 @@
+// 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)]));
+}
+
+export {
+  getKeys,
+  getEntries,
+  getVariantsOptions
+};
+//# sourceMappingURL=chunk-3RDDXOQ3.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["import { 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 Entries<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 (Entries<O>[keyof Entries<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"],"mappings":";AAEO,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;","names":[]}

package/build/chunk-DMATMZGE.js

@@ -0,0 +1,39 @@
+import {
+  getEntries,
+  getKeys
+} from "./chunk-3RDDXOQ3.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-DMATMZGE.js.map

package/build/chunk-DMATMZGE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { ClassValue, clsx } from \"clsx\";\r\nimport { Prettify } from \"ts-essentials\";\r\nimport { getEntries, getKeys } from \"./utils\";\r\n\r\nexport type VariantProps<Component extends CVReturn<CVVariantsSchema>> = Prettify<Omit<Parameters<Component>[0], \"class\">>;\r\n\r\nexport type CVVariantsSchema = Record<string, Record<string, ClassValue>>;\r\n\r\nexport type WithClassProp<T extends Record<string, unknown>> = 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\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}\r\n\r\nexport type CVVariantProps<V extends CVVariantsSchema> = WithClassProp<{ [K in keyof V]?: keyof V[K] }>;\r\n\r\nexport type CVReturn<V extends CVVariantsSchema> = (props: CVVariantProps<V>) => 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>(config: CVConfig<V>, options?: CVOptions): CVReturn<V>;\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;AAoC1B,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,MAAM,KAA2B;AAEvD,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/index.cjs

@@ -0,0 +1,68 @@
+"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
+});
+//# sourceMappingURL=index.cjs.map

package/build/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/utils.ts"],"sourcesContent":["import { ClassValue, clsx } from \"clsx\";\r\nimport { Prettify } from \"ts-essentials\";\r\nimport { getEntries, getKeys } from \"./utils\";\r\n\r\nexport type VariantProps<Component extends CVReturn<CVVariantsSchema>> = Prettify<Omit<Parameters<Component>[0], \"class\">>;\r\n\r\nexport type CVVariantsSchema = Record<string, Record<string, ClassValue>>;\r\n\r\nexport type WithClassProp<T extends Record<string, unknown>> = 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\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}\r\n\r\nexport type CVVariantProps<V extends CVVariantsSchema> = WithClassProp<{ [K in keyof V]?: keyof V[K] }>;\r\n\r\nexport type CVReturn<V extends CVVariantsSchema> = (props: CVVariantProps<V>) => 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>(config: CVConfig<V>, options?: CVOptions): CVReturn<V>;\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 { 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 Entries<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 (Entries<O>[keyof Entries<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"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiC;;;ACE1B,SAAS,QAA2C,KAAQ;AAC/D,SAAO,OAAO,KAAK,GAAG;AAC1B;AAGO,SAAS,WAA8C,KAAQ;AAClE,SAAO,OAAO,QAAQ,GAAG;AAC7B;;;AD2BO,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,MAAM,KAA2B;AAEvD,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/index.d.cts

@@ -0,0 +1,32 @@
+import { ClassValue } from 'clsx';
+import { Prettify } from 'ts-essentials';
+
+type VariantProps<Component extends CVReturn<CVVariantsSchema>> = Prettify<Omit<Parameters<Component>[0], "class">>;
+type CVVariantsSchema = Record<string, Record<string, ClassValue>>;
+type WithClassProp<T extends Record<string, unknown>> = 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> {
+    baseClass?: ClassValue;
+    variants?: V;
+    compoundVariants?: CVCompoundVariantsSchema<NoInfer<V>> | ((variants: NoInfer<V>) => CVCompoundVariantsSchema<NoInfer<V>>);
+    defaultVariant?: Partial<{
+        [K in keyof V]?: keyof V[K];
+    }>;
+}
+type CVVariantProps<V extends CVVariantsSchema> = WithClassProp<{
+    [K in keyof V]?: keyof V[K];
+}>;
+type CVReturn<V extends CVVariantsSchema> = (props: CVVariantProps<V>) => string;
+interface CVOptions {
+    merge?: (...args: ClassValue[]) => string;
+}
+interface CV {
+    <V extends CVVariantsSchema>(config: CVConfig<V>, options?: CVOptions): CVReturn<V>;
+}
+declare const cv: CV;
+
+export { type CV, type CVCompoundVariantsSchema, type CVConfig, type CVOptions, type CVReturn, type CVVariantProps, type CVVariantsSchema, type VariantProps, type WithClassProp, cv };

package/build/index.d.ts

@@ -0,0 +1,32 @@
+import { ClassValue } from 'clsx';
+import { Prettify } from 'ts-essentials';
+
+type VariantProps<Component extends CVReturn<CVVariantsSchema>> = Prettify<Omit<Parameters<Component>[0], "class">>;
+type CVVariantsSchema = Record<string, Record<string, ClassValue>>;
+type WithClassProp<T extends Record<string, unknown>> = 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> {
+    baseClass?: ClassValue;
+    variants?: V;
+    compoundVariants?: CVCompoundVariantsSchema<NoInfer<V>> | ((variants: NoInfer<V>) => CVCompoundVariantsSchema<NoInfer<V>>);
+    defaultVariant?: Partial<{
+        [K in keyof V]?: keyof V[K];
+    }>;
+}
+type CVVariantProps<V extends CVVariantsSchema> = WithClassProp<{
+    [K in keyof V]?: keyof V[K];
+}>;
+type CVReturn<V extends CVVariantsSchema> = (props: CVVariantProps<V>) => string;
+interface CVOptions {
+    merge?: (...args: ClassValue[]) => string;
+}
+interface CV {
+    <V extends CVVariantsSchema>(config: CVConfig<V>, options?: CVOptions): CVReturn<V>;
+}
+declare const cv: CV;
+
+export { type CV, type CVCompoundVariantsSchema, type CVConfig, type CVOptions, type CVReturn, type CVVariantProps, type CVVariantsSchema, type VariantProps, type WithClassProp, cv };

package/build/index.js

@@ -0,0 +1,8 @@
+import {
+  cv
+} from "./chunk-DMATMZGE.js";
+import "./chunk-3RDDXOQ3.js";
+export {
+  cv
+};
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/build/utils.cjs

@@ -0,0 +1,43 @@
+"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
+});
+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)]));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getEntries,
+  getKeys,
+  getVariantsOptions
+});
+//# sourceMappingURL=utils.cjs.map

package/build/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["import { 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 Entries<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 (Entries<O>[keyof Entries<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"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEO,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;","names":[]}

package/build/utils.d.cts

@@ -0,0 +1,12 @@
+import { CVVariantsSchema } from './index.cjs';
+import 'clsx';
+import 'ts-essentials';
+
+declare function getKeys<O extends Record<string, unknown>>(obj: O): (keyof O)[];
+type Entries<O extends Record<string, unknown>> = {
+    [K in keyof O]: [K, O[K]];
+};
+declare function getEntries<O extends Record<string, unknown>>(obj: O): (Entries<O>[keyof Entries<O>])[];
+declare function getVariantsOptions<V extends CVVariantsSchema>(variants: V): { [K in keyof V]: (keyof V[K])[]; };
+
+export { getEntries, getKeys, getVariantsOptions };

package/build/utils.d.ts

@@ -0,0 +1,12 @@
+import { CVVariantsSchema } from './index.js';
+import 'clsx';
+import 'ts-essentials';
+
+declare function getKeys<O extends Record<string, unknown>>(obj: O): (keyof O)[];
+type Entries<O extends Record<string, unknown>> = {
+    [K in keyof O]: [K, O[K]];
+};
+declare function getEntries<O extends Record<string, unknown>>(obj: O): (Entries<O>[keyof Entries<O>])[];
+declare function getVariantsOptions<V extends CVVariantsSchema>(variants: V): { [K in keyof V]: (keyof V[K])[]; };
+
+export { getEntries, getKeys, getVariantsOptions };

package/build/utils.js

@@ -0,0 +1,11 @@
+import {
+  getEntries,
+  getKeys,
+  getVariantsOptions
+} from "./chunk-3RDDXOQ3.js";
+export {
+  getEntries,
+  getKeys,
+  getVariantsOptions
+};
+//# sourceMappingURL=utils.js.map

package/build/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/build/vue.cjs

@@ -0,0 +1,88 @@
+"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
+});
+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);
+}
+
+// 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
+var cvWithProps = (config) => {
+  const getClass = cv(config);
+  if (typeof config === "undefined") {
+    return { getClass, props: {} };
+  }
+  const props = Object.fromEntries(
+    Object.keys(config).map((key) => [
+      key,
+      {
+        type: String,
+        default: config.defaultVariant?.[key]
+      }
+    ])
+  );
+  return { getClass, props };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cvWithProps
+});
+//# sourceMappingURL=vue.cjs.map

package/build/vue.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/vue.ts","../src/index.ts","../src/utils.ts"],"sourcesContent":["import { cv, CVConfig, CVReturn, CVVariantsSchema } from \".\";\r\nimport { Prettify } from \"ts-essentials\";\r\nimport { type Prop } from \"vue\";\r\n\r\ntype PropsDeclaration<V extends CVVariantsSchema> = Prettify<{ [K in keyof V]: Prop<keyof V[K]> }>;\r\n\r\nexport interface CVWithPropsReturn<V extends CVVariantsSchema> {\r\n    getClass: CVReturn<V>;\r\n    props: PropsDeclaration<V>;\r\n}\r\n\r\nexport interface CVWithProps {\r\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type\r\n    <V extends CVVariantsSchema>(config: CVConfig<V>): CVWithPropsReturn<V>;\r\n}\r\n\r\nexport const cvWithProps = ((config) => {\r\n    const getClass = cv(config);\r\n\r\n    if (typeof config === \"undefined\") {\r\n        return { getClass, props: {} };\r\n    }\r\n\r\n    const props = Object.fromEntries(\r\n        Object.keys(config).map(key => [\r\n            key,\r\n            {\r\n                type: String,\r\n                default: config.defaultVariant?.[key],\r\n            },\r\n        ]),\r\n    );\r\n\r\n    return { getClass, props };\r\n}) as CVWithProps;\r\n","import { ClassValue, clsx } from \"clsx\";\r\nimport { Prettify } from \"ts-essentials\";\r\nimport { getEntries, getKeys } from \"./utils\";\r\n\r\nexport type VariantProps<Component extends CVReturn<CVVariantsSchema>> = Prettify<Omit<Parameters<Component>[0], \"class\">>;\r\n\r\nexport type CVVariantsSchema = Record<string, Record<string, ClassValue>>;\r\n\r\nexport type WithClassProp<T extends Record<string, unknown>> = 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\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}\r\n\r\nexport type CVVariantProps<V extends CVVariantsSchema> = WithClassProp<{ [K in keyof V]?: keyof V[K] }>;\r\n\r\nexport type CVReturn<V extends CVVariantsSchema> = (props: CVVariantProps<V>) => 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>(config: CVConfig<V>, options?: CVOptions): CVReturn<V>;\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 { 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 Entries<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 (Entries<O>[keyof Entries<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"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,kBAAiC;;;ACE1B,SAAS,QAA2C,KAAQ;AAC/D,SAAO,OAAO,KAAK,GAAG;AAC1B;AAGO,SAAS,WAA8C,KAAQ;AAClE,SAAO,OAAO,QAAQ,GAAG;AAC7B;;;AD2BO,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,MAAM,KAA2B;AAEvD,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;;;AD1DO,IAAM,cAAe,CAAC,WAAW;AACpC,QAAM,WAAW,GAAG,MAAM;AAE1B,MAAI,OAAO,WAAW,aAAa;AAC/B,WAAO,EAAE,UAAU,OAAO,CAAC,EAAE;AAAA,EACjC;AAEA,QAAM,QAAQ,OAAO;AAAA,IACjB,OAAO,KAAK,MAAM,EAAE,IAAI,SAAO;AAAA,MAC3B;AAAA,MACA;AAAA,QACI,MAAM;AAAA,QACN,SAAS,OAAO,iBAAiB,GAAG;AAAA,MACxC;AAAA,IACJ,CAAC;AAAA,EACL;AAEA,SAAO,EAAE,UAAU,MAAM;AAC7B;","names":[]}

package/build/vue.d.cts

@@ -0,0 +1,18 @@
+import { CVVariantsSchema, CVReturn, CVConfig } from './index.cjs';
+import { Prettify } from 'ts-essentials';
+import { Prop } from 'vue';
+import 'clsx';
+
+type PropsDeclaration<V extends CVVariantsSchema> = Prettify<{
+    [K in keyof V]: Prop<keyof V[K]>;
+}>;
+interface CVWithPropsReturn<V extends CVVariantsSchema> {
+    getClass: CVReturn<V>;
+    props: PropsDeclaration<V>;
+}
+interface CVWithProps {
+    <V extends CVVariantsSchema>(config: CVConfig<V>): CVWithPropsReturn<V>;
+}
+declare const cvWithProps: CVWithProps;
+
+export { type CVWithProps, type CVWithPropsReturn, cvWithProps };

package/build/vue.d.ts

@@ -0,0 +1,18 @@
+import { CVVariantsSchema, CVReturn, CVConfig } from './index.js';
+import { Prettify } from 'ts-essentials';
+import { Prop } from 'vue';
+import 'clsx';
+
+type PropsDeclaration<V extends CVVariantsSchema> = Prettify<{
+    [K in keyof V]: Prop<keyof V[K]>;
+}>;
+interface CVWithPropsReturn<V extends CVVariantsSchema> {
+    getClass: CVReturn<V>;
+    props: PropsDeclaration<V>;
+}
+interface CVWithProps {
+    <V extends CVVariantsSchema>(config: CVConfig<V>): CVWithPropsReturn<V>;
+}
+declare const cvWithProps: CVWithProps;
+
+export { type CVWithProps, type CVWithPropsReturn, cvWithProps };

package/build/vue.js

@@ -0,0 +1,26 @@
+import {
+  cv
+} from "./chunk-DMATMZGE.js";
+import "./chunk-3RDDXOQ3.js";
+
+// src/vue.ts
+var cvWithProps = (config) => {
+  const getClass = cv(config);
+  if (typeof config === "undefined") {
+    return { getClass, props: {} };
+  }
+  const props = Object.fromEntries(
+    Object.keys(config).map((key) => [
+      key,
+      {
+        type: String,
+        default: config.defaultVariant?.[key]
+      }
+    ])
+  );
+  return { getClass, props };
+};
+export {
+  cvWithProps
+};
+//# sourceMappingURL=vue.js.map

package/build/vue.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/vue.ts"],"sourcesContent":["import { cv, CVConfig, CVReturn, CVVariantsSchema } from \".\";\r\nimport { Prettify } from \"ts-essentials\";\r\nimport { type Prop } from \"vue\";\r\n\r\ntype PropsDeclaration<V extends CVVariantsSchema> = Prettify<{ [K in keyof V]: Prop<keyof V[K]> }>;\r\n\r\nexport interface CVWithPropsReturn<V extends CVVariantsSchema> {\r\n    getClass: CVReturn<V>;\r\n    props: PropsDeclaration<V>;\r\n}\r\n\r\nexport interface CVWithProps {\r\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type\r\n    <V extends CVVariantsSchema>(config: CVConfig<V>): CVWithPropsReturn<V>;\r\n}\r\n\r\nexport const cvWithProps = ((config) => {\r\n    const getClass = cv(config);\r\n\r\n    if (typeof config === \"undefined\") {\r\n        return { getClass, props: {} };\r\n    }\r\n\r\n    const props = Object.fromEntries(\r\n        Object.keys(config).map(key => [\r\n            key,\r\n            {\r\n                type: String,\r\n                default: config.defaultVariant?.[key],\r\n            },\r\n        ]),\r\n    );\r\n\r\n    return { getClass, props };\r\n}) as CVWithProps;\r\n"],"mappings":";;;;;;AAgBO,IAAM,cAAe,CAAC,WAAW;AACpC,QAAM,WAAW,GAAG,MAAM;AAE1B,MAAI,OAAO,WAAW,aAAa;AAC/B,WAAO,EAAE,UAAU,OAAO,CAAC,EAAE;AAAA,EACjC;AAEA,QAAM,QAAQ,OAAO;AAAA,IACjB,OAAO,KAAK,MAAM,EAAE,IAAI,SAAO;AAAA,MAC3B;AAAA,MACA;AAAA,QACI,MAAM;AAAA,QACN,SAAS,OAAO,iBAAiB,GAAG;AAAA,MACxC;AAAA,IACJ,CAAC;AAAA,EACL;AAEA,SAAO,EAAE,UAAU,MAAM;AAC7B;","names":[]}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@yaredfall/class-variants",
+  "author": "yaredfall",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.0.1",
+  "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"
+      }
+    },
+    "./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"
+  },
+  "scripts": {
+    "build": "tsc && tsup"
+  },
+  "devDependencies": {
+    "tsup": "^8.1.0",
+    "typescript": "^5.2.2",
+    "vue": "^3.4.29"
+  },
+  "dependencies": {
+    "clsx": "^2.1.1"
+  }
+}

package/src/index.ts

@@ -0,0 +1,75 @@
+import { ClassValue, clsx } from "clsx";
+import { Prettify } from "ts-essentials";
+import { getEntries, getKeys } from "./utils";
+
+export type VariantProps<Component extends CVReturn<CVVariantsSchema>> = Prettify<Omit<Parameters<Component>[0], "class">>;
+
+export type CVVariantsSchema = Record<string, Record<string, ClassValue>>;
+
+export type WithClassProp<T extends Record<string, unknown>> = 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> {
+    baseClass?: ClassValue;
+    variants?: V;
+    compoundVariants?: CVCompoundVariantsSchema<NoInfer<V>> | ((variants: NoInfer<V>) => CVCompoundVariantsSchema<NoInfer<V>>);
+    defaultVariant?: Partial<{ [K in keyof V]?: keyof V[K] }>;
+}
+
+export type CVVariantProps<V extends CVVariantsSchema> = WithClassProp<{ [K in keyof V]?: keyof V[K] }>;
+
+export type CVReturn<V extends CVVariantsSchema> = (props: CVVariantProps<V>) => string;
+
+export interface CVOptions {
+    merge?: (...args: ClassValue[]) => string;
+}
+
+export interface CV {
+    // eslint-disable-next-line @typescript-eslint/prefer-function-type
+    <V extends CVVariantsSchema>(config: CVConfig<V>, options?: CVOptions): CVReturn<V>;
+}
+
+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

@@ -0,0 +1,14 @@
+import { CVVariantsSchema } from ".";
+
+export function getKeys<O extends Record<string, unknown>>(obj: O) {
+    return Object.keys(obj) as (keyof O)[];
+}
+
+type Entries<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 (Entries<O>[keyof Entries<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])[] };
+}

package/src/vue.ts

@@ -0,0 +1,35 @@
+import { cv, CVConfig, CVReturn, CVVariantsSchema } from ".";
+import { Prettify } from "ts-essentials";
+import { type Prop } from "vue";
+
+type PropsDeclaration<V extends CVVariantsSchema> = Prettify<{ [K in keyof V]: Prop<keyof V[K]> }>;
+
+export interface CVWithPropsReturn<V extends CVVariantsSchema> {
+    getClass: CVReturn<V>;
+    props: PropsDeclaration<V>;
+}
+
+export interface CVWithProps {
+    // eslint-disable-next-line @typescript-eslint/prefer-function-type
+    <V extends CVVariantsSchema>(config: CVConfig<V>): CVWithPropsReturn<V>;
+}
+
+export const cvWithProps = ((config) => {
+    const getClass = cv(config);
+
+    if (typeof config === "undefined") {
+        return { getClass, props: {} };
+    }
+
+    const props = Object.fromEntries(
+        Object.keys(config).map(key => [
+            key,
+            {
+                type: String,
+                default: config.defaultVariant?.[key],
+            },
+        ]),
+    );
+
+    return { getClass, props };
+}) as CVWithProps;

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "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

@@ -0,0 +1,13 @@
+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,
+    },
+);