@yaredfall/class-variants 0.4.0-rc → 0.6.0-rc.1

package/build/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/utils.ts"],"sourcesContent":["import { ClassValue, clsx } from \"clsx\";\nimport {\n    MarkRequired,\n    Opaque,\n    Prettify,\n    type RequiredKeys,\n    type UnionToIntersection,\n} from \"ts-essentials\";\nimport {\n    getEntries,\n    getKeys,\n    getVariantsOptions,\n    KeysOf,\n    VariantOptions as VariantMap,\n} from \"./utils\";\n\ntype ClassProp =\n    | { class?: ClassValue; className?: never }\n    | { class?: never; className?: ClassValue };\n\nexport type WithClassProp<T extends object> = T & ClassProp;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type VariantProps<CVR extends (props?: any) => string> = Prettify<\n    Omit<\n        UnionToIntersection<Exclude<Parameters<CVR>[0], void | null | undefined>>,\n        \"class\" | \"className\"\n    >\n>;\n\ntype BooleanStringToBoolean<T> = T extends \"true\" | \"false\" ? boolean : T;\n\nexport type CVVariantsSchema = Record<string, Record<string | number, ClassValue>>;\n\nexport type CVVariant<V extends CVVariantsSchema> = {\n    [K in keyof V]?: BooleanStringToBoolean<keyof V[K]>;\n};\nexport type CVCompoundVariant<V extends CVVariantsSchema> = WithClassProp<{\n    [K in keyof V]?:\n        | BooleanStringToBoolean<keyof V[K]>\n        | BooleanStringToBoolean<keyof V[K]>[]\n        | CVToken;\n}>;\n\nexport type CVCompoundVariantsSchema<V extends CVVariantsSchema> = CVCompoundVariant<V>[];\n\nexport interface CVConfig<V extends CVVariantsSchema, R extends keyof V> {\n    base?: ClassValue;\n    variants?: V;\n    compoundVariants?:\n        | CVCompoundVariantsSchema<V>\n        | ((arg: CVUtils<V, R>) => CVCompoundVariantsSchema<V>);\n    defaultVariants?: CVVariant<V>;\n    requiredVariants?: Record<R, boolean>;\n}\nexport interface CVOptions {\n    merge?: (...args: ClassValue[]) => string;\n}\n\ntype CVReturnProps<V extends CVVariantsSchema, R extends keyof V = never> =\n    | WithClassProp<MarkRequired<CVVariant<V>, R>>\n    | ([R] extends [never] ? void : never);\n\nexport interface CVUtils<V extends CVVariantsSchema, R extends keyof V = never> {\n    variants: V;\n    variantKeys: KeysOf<V>;\n    variantMap: VariantMap<V>;\n    defaultVariants: CVVariant<V>;\n    requiredVariants: Record<R, boolean>;\n}\nexport interface CVReturn<V extends CVVariantsSchema, R extends keyof V = never>\n    extends CVUtils<V, R> {\n    (props: CVReturnProps<V, R>): string;\n}\n\nexport interface CV {\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        cvOptions?: CVOptions,\n    ): CVReturn<V, R>;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype CVComposeReturnProps<T extends (props?: any) => string> =\n    | WithClassProp<VariantProps<T>>\n    | (RequiredKeys<VariantProps<T>> extends never ? void : never);\nexport interface CVCompose {\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type, @typescript-eslint/no-explicit-any\n    <T extends ((props?: any) => string)[]>(\n        ...components: T\n    ): (props: CVComposeReturnProps<T[number]>) => string;\n}\n\nexport function defineCV(options: CVOptions = {}) {\n    const cn = options.merge ?? clsx;\n\n    const cv: CV = (config) => {\n        const { base, variants, defaultVariants, requiredVariants } = config;\n\n        type ResolvedV = NonNullable<typeof variants>;\n\n        const utils = {\n            variants: variants ?? ({} as ResolvedV),\n            variantKeys: variants ? getKeys(variants) : [],\n            variantMap: variants ? getVariantsOptions(variants) : ({} as VariantMap<ResolvedV>),\n            defaultVariants: defaultVariants ?? ({} as CVVariant<ResolvedV>),\n            requiredVariants: requiredVariants ?? ({} as Record<keyof ResolvedV, boolean>),\n        };\n\n        const compoundVariants = variants\n            ? typeof config.compoundVariants === \"function\"\n                ? config.compoundVariants(utils)\n                : config.compoundVariants\n            : undefined;\n\n        const getVariant = <V extends ResolvedV, R extends keyof V = never>(\n            props: CVReturnProps<V, R>,\n        ) => {\n            const variantClassNames = variants\n                ? utils.variantKeys.map((variant) => {\n                      const variantProp = props?.[variant];\n                      const defaults = defaultVariants?.[variant];\n\n                      const variantKey = variantProp?.toString() || defaults?.toString();\n\n                      return variantKey ? variants[variant][variantKey] : undefined;\n                  })\n                : undefined;\n\n            const compoundVariantClassNames = compoundVariants?.reduce(\n                (acc, { class: cvClass, className: cvClassName, ...cvConfig }) => {\n                    const shouldApplyCompoundVariant = getEntries(cvConfig).every(\n                        ([cvKey, cvSelector]) => {\n                            const defaultsSelector =\n                                defaultVariants?.[cvKey as keyof typeof defaultVariants];\n                            const propsSelector = props?.[cvKey as keyof typeof props];\n\n                            if (typeof cvSelector === \"object\" && \"__token\" in cvSelector) {\n                                if (cvSelector.__token === onlyWhenDefined.__token) {\n                                    return propsSelector !== undefined;\n                                } else if (cvSelector.__token === onlyWhenUndefined.__token) {\n                                    return propsSelector === undefined;\n                                }\n                            }\n\n                            const selector = propsSelector ?? defaultsSelector;\n\n                            return Array.isArray(cvSelector)\n                                ? cvSelector.some((cvSelector) => selector === cvSelector)\n                                : selector === cvSelector;\n                        },\n                    );\n\n                    if (shouldApplyCompoundVariant) acc.push(cvClass, cvClassName);\n                    return acc;\n                },\n                new Array<ClassValue>(),\n            );\n\n            return cn(\n                base,\n                variantClassNames,\n                compoundVariantClassNames,\n                props?.class,\n                props?.className,\n            );\n        };\n\n        return Object.assign(getVariant, utils);\n    };\n\n    const compose: CVCompose =\n        (...components) =>\n        (props) => {\n            const propsWithoutClass = { ...props, class: undefined, className: undefined };\n\n            return cn(\n                components.map((component) => component(propsWithoutClass)),\n                props?.class,\n                props?.className,\n            );\n        };\n\n    return { cn, cv, compose };\n}\n\nexport const { cn, cv, compose } = defineCV();\n\ntype OnlyWhenDefined = Opaque<{ __token: string }, \"OnlyWhenDefined\">;\ntype OnlyWhenUndefined = Opaque<{ __token: string }, \"OnlyWhenUndefined\">;\n\ntype CVToken = OnlyWhenDefined | OnlyWhenUndefined;\n\n/** Apply compound variant only if prop **is** specified */\nexport const onlyWhenDefined = { __token: \"OnlyWhenDefined\" } as OnlyWhenDefined;\n/** Apply compound variant only if prop **is not** specified */\nexport const onlyWhenUndefined = { __token: \"OnlyWhenUndefined\" } as OnlyWhenUndefined;\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            ? Record<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,YAAAC,EAAA,OAAAC,EAAA,aAAAC,EAAA,oBAAAC,EAAA,sBAAAC,IAAA,eAAAC,EAAAR,GAAA,IAAAS,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,CD0EO,SAASC,EAASC,EAAqB,CAAC,EAAG,CAC9C,IAAMC,EAAKD,EAAQ,OAAS,OAyF5B,MAAO,CAAE,GAAAC,EAAI,GAvFGC,GAAW,CACvB,GAAM,CAAE,KAAAC,EAAM,SAAAC,EAAU,gBAAAC,EAAiB,iBAAAC,CAAiB,EAAIJ,EAIxDK,EAAQ,CACV,SAAUH,GAAa,CAAC,EACxB,YAAaA,EAAWI,EAAQJ,CAAQ,EAAI,CAAC,EAC7C,WAAYA,EAAWK,EAAmBL,CAAQ,EAAK,CAAC,EACxD,gBAAiBC,GAAoB,CAAC,EACtC,iBAAkBC,GAAqB,CAAC,CAC5C,EAEMI,EAAmBN,EACnB,OAAOF,EAAO,kBAAqB,WAC/BA,EAAO,iBAAiBK,CAAK,EAC7BL,EAAO,iBACX,OAuDN,OAAO,OAAO,OApDVS,GACC,CACD,IAAMC,EAAoBR,EACpBG,EAAM,YAAY,IAAKM,GAAY,CAC/B,IAAMC,EAAcH,IAAQE,CAAO,EAC7BE,EAAWV,IAAkBQ,CAAO,EAEpCG,EAAaF,GAAa,SAAS,GAAKC,GAAU,SAAS,EAEjE,OAAOC,EAAaZ,EAASS,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,EACFpB,IAAkBkB,CAAqC,EACrDG,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,EACHE,EACAS,EACAK,EACAN,GAAO,MACPA,GAAO,SACX,CACJ,EAEiCJ,CAAK,CAC1C,EAciB,QAXb,IAAIuB,IACHnB,GAAU,CACP,IAAMoB,EAAoB,CAAE,GAAGpB,EAAO,MAAO,OAAW,UAAW,MAAU,EAE7E,OAAOV,EACH6B,EAAW,IAAKE,GAAcA,EAAUD,CAAiB,CAAC,EAC1DpB,GAAO,MACPA,GAAO,SACX,CACJ,CAEqB,CAC7B,CAEO,GAAM,CAAE,GAAAV,EAAI,GAAAgC,EAAI,QAAAC,CAAQ,EAAInC,EAAS,EAQ/B4B,EAAkB,CAAE,QAAS,iBAAkB,EAE/CC,EAAoB,CAAE,QAAS,mBAAoB","names":["index_exports","__export","cn","compose","cv","defineCV","onlyWhenDefined","onlyWhenUndefined","__toCommonJS","import_clsx","getKeys","obj","getEntries","getVariantsOptions","variants","cvKey","cvVal","defineCV","options","cn","config","base","variants","defaultVariants","requiredVariants","utils","getKeys","getVariantsOptions","compoundVariants","props","variantClassNames","variant","variantProp","defaults","variantKey","compoundVariantClassNames","acc","cvClass","cvClassName","cvConfig","getEntries","cvKey","cvSelector","defaultsSelector","propsSelector","onlyWhenDefined","onlyWhenUndefined","selector","components","propsWithoutClass","component","cv","compose"]}
+{"version":3,"sources":["../src/index.ts","../src/tokens.ts","../src/cn.ts","../src/utils.ts","../src/cv.ts","../src/extend.ts","../src/define.ts"],"sourcesContent":["import type { CN } from \"./cn\";\r\nimport type {\r\n    CV,\r\n    CVCompoundVariant,\r\n    CVCompoundVariantsSchema,\r\n    CVReturn,\r\n    CVVariant,\r\n    CVVariantsSchema,\r\n    VariantProps,\r\n} from \"./cv\";\r\nimport { type CVToken, onlyWhenDefined, onlyWhenUndefined } from \"./tokens\";\r\nimport { defineCV } from \"./define\";\r\nimport type { CVUtils } from \"./utils\";\r\n\r\nexport const { cn, cv, extend } = defineCV();\r\n\r\nexport { defineCV, onlyWhenDefined, onlyWhenUndefined };\r\nexport type {\r\n    CN,\r\n    CV,\r\n    CVUtils,\r\n    CVReturn,\r\n    VariantProps,\r\n    CVVariantsSchema,\r\n    CVCompoundVariantsSchema,\r\n    CVVariant,\r\n    CVCompoundVariant,\r\n    CVToken,\r\n};\r\n","import type { Opaque } from \"ts-essentials\";\r\nimport type { CVPropsValue } from \"./cv\";\r\n\r\ntype OnlyWhenDefined = Opaque<{ __token: string }, \"OnlyWhenDefined\">;\r\ntype OnlyWhenUndefined = Opaque<{ __token: string }, \"OnlyWhenUndefined\">;\r\n\r\nexport type 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\r\nexport function isCVToken(token: unknown): token is CVToken {\r\n    return token ? typeof token === \"object\" && \"__token\" in token : false;\r\n}\r\nfunction isSpecificCVToken<TReference extends CVToken>(token: CVToken, reference: TReference): token is TReference {\r\n    return token.__token === reference.__token;\r\n}\r\n\r\nexport function shouldApplySelectorByToken(token: CVToken, selector: CVPropsValue) {\r\n    if (isSpecificCVToken(token, onlyWhenDefined)) return selector !== undefined;\r\n    else if (isSpecificCVToken(token, onlyWhenUndefined)) return selector === undefined;\r\n\r\n    return false;\r\n}\r\n","import clsx, { type ClassValue } from \"clsx\";\r\n\r\nexport interface CNOptions {\r\n    merge?: (className: string) => string;\r\n}\r\n\r\nexport interface CN {\r\n    (...inputs: ClassValue[]): string;\r\n}\r\n\r\nexport function _cn({ merge = (className) => className }: CNOptions): CN {\r\n    return (...inputs) => merge(clsx(...inputs));\r\n}\r\n","// import type { DeepReadonly, DeepWritable, Prettify, UnionToIntersection } from \"ts-essentials\";\r\nimport type { Prettify } from \"ts-essentials\";\r\nimport type { BooleanStringToBoolean, CVConfig, CVReturnProps, CVVariantKey, CVVariantsSchema } from \"./cv\";\r\n\r\nexport function getKeys<O extends Record<string, unknown>>(obj: O) {\r\n    return Object.keys(obj) as (keyof O & CVVariantKey)[];\r\n}\r\n\r\nexport type 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 type VariantMap<V extends CVVariantsSchema> = {\r\n    [K in keyof V]: BooleanStringToBoolean<keyof V[K] & CVVariantKey>[];\r\n};\r\nexport function getVariantMap<V extends CVVariantsSchema>(variants: V) {\r\n    return Object.fromEntries(getEntries(variants).map(([cvKey, cvVal]) => [cvKey, getKeys(cvVal)])) as VariantMap<V>;\r\n}\r\n\r\nexport function splitProps<TProps>(props: TProps, shouldSplit: (key: keyof TProps) => boolean) {\r\n    const splittedProps = {} as Partial<Record<keyof TProps, unknown>>;\r\n    const otherProps = {} as Partial<Record<keyof TProps, unknown>>;\r\n    if (!props) return [splittedProps, otherProps] as const;\r\n    for (const propKey in props) {\r\n        const key = propKey as keyof TProps;\r\n        if (shouldSplit(key)) splittedProps[key] = props[key];\r\n        else otherProps[key] = props[key];\r\n    }\r\n    return [splittedProps, otherProps] as const;\r\n}\r\n\r\nexport interface CVUtils<V extends CVVariantsSchema> {\r\n    variantKeys: (keyof V & string)[];\r\n    variantMap: Prettify<VariantMap<V>>;\r\n    splitVariantProps: <TProps extends CVReturnProps<V>>(\r\n        props?: TProps,\r\n    ) => [CVReturnProps<V>, Prettify<Omit<TProps, keyof CVReturnProps<V>>>];\r\n    getVariantProps: (props?: CVReturnProps<V>) => Exclude<CVReturnProps<V>, void>;\r\n}\r\n\r\nexport function cvUtils<V extends CVVariantsSchema>(config: CVConfig<V>): CVUtils<V> {\r\n    const variantKeys = getKeys(config.variants);\r\n    const variantMap = getVariantMap(config.variants);\r\n    const splitVariantProps = (props?: CVReturnProps<V>) => splitProps(props, (key) => key in variantMap);\r\n    const getVariantProps = (props?: CVReturnProps<V>) => ({ ...config.defaultVariants, ...props });\r\n\r\n    return { variantKeys, variantMap, splitVariantProps, getVariantProps } as CVUtils<V>;\r\n}\r\n","import type { ClassValue } from \"clsx\";\r\nimport type { ArrayOrSingle } from \"ts-essentials\";\r\nimport { type CN } from \"./cn\";\r\nimport { isCVToken, shouldApplySelectorByToken, type CVToken } from \"./tokens\";\r\nimport { cvUtils, type CVUtils } from \"./utils\";\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nexport type VariantProps<CVR extends (props?: any) => string> = CVR extends CVReturn<infer V> ? CVProps<V> : never;\r\n\r\nexport type BooleanStringToBoolean<T> = T extends \"true\" | \"false\" ? boolean : T;\r\n\r\nexport type CVVariantKey = string | number;\r\n\r\nexport type CVVariantSchema = Record<CVVariantKey, ClassValue>;\r\nexport type CVVariantsSchema = Record<string, CVVariantSchema>;\r\n\r\nexport type CVVariant<V extends CVVariantsSchema> = {\r\n    [K in keyof V]?: BooleanStringToBoolean<keyof V[K] & CVVariantKey>;\r\n};\r\n\r\nexport type CVProps<V extends CVVariantsSchema> = CVVariant<V>;\r\n\r\nexport type CVCompoundVariant<V extends CVVariantsSchema> = {\r\n    [K in keyof V]?: ArrayOrSingle<BooleanStringToBoolean<keyof V[K] & CVVariantKey>> | CVToken;\r\n} & { class: ClassValue };\r\n\r\nexport type CVCompoundVariantsSchema<V extends CVVariantsSchema> = CVCompoundVariant<V>[];\r\nexport type CVCompoundVariantsSchemaFunction<V extends CVVariantsSchema> = (\r\n    utils: CVUtils<V>,\r\n) => CVCompoundVariantsSchema<V>;\r\n\r\nexport interface CVConfig<V extends CVVariantsSchema> {\r\n    base: ClassValue;\r\n    variants: V;\r\n    compoundVariants: CVCompoundVariantsSchema<V> | CVCompoundVariantsSchemaFunction<V>;\r\n    defaultVariants: CVVariant<V>;\r\n}\r\n\r\nexport interface ResolvedCVConfig<V extends CVVariantsSchema> extends CVConfig<V> {\r\n    compoundVariants: CVCompoundVariantsSchema<V>;\r\n}\r\n\r\nexport type CVReturnProps<V extends CVVariantsSchema> = CVProps<V>;\r\n\r\nexport interface CVReturn<V extends CVVariantsSchema> extends CVUtils<V> {\r\n    (props?: CVReturnProps<V>, additionalClassName?: ClassValue): string;\r\n    config: ResolvedCVConfig<V>;\r\n}\r\n\r\nexport interface CV {\r\n    <V extends CVVariantsSchema>(config: Partial<CVConfig<V>>): CVReturn<V>;\r\n}\r\n\r\ninterface CVOptions {\r\n    cn: CN;\r\n}\r\nexport function _cv(options: CVOptions): CV {\r\n    return <V extends CVVariantsSchema>(config: Partial<CVConfig<V>>) => {\r\n        const [resolvedConfig, utils] = resolveConfig(config);\r\n\r\n        const { base, variants, compoundVariants, defaultVariants } = resolvedConfig;\r\n\r\n        const getVariantsClassNames = (props?: CVReturnProps<V>) => {\r\n            const defaultedProps = utils.getVariantProps(props);\r\n\r\n            const classNames = new Array<ClassValue>();\r\n            for (const key in variants) {\r\n                const variant = defaultedProps[key]?.toString();\r\n                if (variant) classNames.push(variants?.[key]?.[variant]);\r\n            }\r\n            return classNames;\r\n        };\r\n\r\n        const getCompoundVariantsClassNames = (props?: CVReturnProps<V>) => {\r\n            return compoundVariants?.reduce((acc, compoundVariant) => {\r\n                if (shouldApplyCompoundVariant(props, compoundVariant, defaultVariants))\r\n                    acc.push(compoundVariant.class);\r\n                return acc;\r\n            }, new Array<ClassValue>());\r\n        };\r\n\r\n        const getVariant = (props?: CVReturnProps<V>, additionalClassName?: ClassValue) => {\r\n            const variantClassNames = getVariantsClassNames(props);\r\n\r\n            const compoundVariantClassNames = getCompoundVariantsClassNames(props);\r\n\r\n            return options.cn(base, variantClassNames, compoundVariantClassNames, additionalClassName);\r\n        };\r\n\r\n        return Object.assign(Object.assign(getVariant, utils), { config: resolvedConfig });\r\n    };\r\n}\r\n\r\nfunction shouldApplyCompoundVariant<V extends CVVariantsSchema>(\r\n    props: CVReturnProps<V> | undefined,\r\n    matcher: CVCompoundVariant<V>,\r\n    defaults: CVVariant<V> | undefined,\r\n) {\r\n    return Object.keys(matcher).every((cvKey) => {\r\n        if (cvKey === \"class\") return true;\r\n\r\n        const cvSelector = matcher[cvKey];\r\n\r\n        const defaultsSelector = defaults?.[cvKey as keyof typeof defaults];\r\n        const propsSelector = props?.[cvKey as keyof typeof props];\r\n\r\n        if (isCVToken(cvSelector)) return shouldApplySelectorByToken(cvSelector, propsSelector);\r\n\r\n        const selector = propsSelector ?? defaultsSelector;\r\n\r\n        return Array.isArray(cvSelector)\r\n            ? cvSelector.some((cvSelector) => compareSelectors(selector, cvSelector))\r\n            : compareSelectors(selector, cvSelector);\r\n    });\r\n}\r\n\r\nexport type CVPropsValue = CVVariantKey | boolean | undefined;\r\nfunction compareSelectors(selector1: CVPropsValue, selector2: CVPropsValue) {\r\n    return selector1?.toString() === selector2?.toString();\r\n}\r\n\r\nexport function resolveConfig<V extends CVVariantsSchema>(\r\n    config: Partial<CVConfig<V>>,\r\n): [ResolvedCVConfig<V>, CVUtils<V>] {\r\n    const defaultedConfig = {\r\n        variants: {},\r\n        compoundVariants: [],\r\n        defaultVariants: {},\r\n        ...config,\r\n    } as CVConfig<V>;\r\n\r\n    const utils = cvUtils(defaultedConfig);\r\n\r\n    return [\r\n        Object.assign(defaultedConfig, {\r\n            compoundVariants: resolveCompoundVariants(defaultedConfig.compoundVariants, utils),\r\n        }),\r\n        utils,\r\n    ] as const;\r\n}\r\n\r\nexport function resolveCompoundVariants<V extends CVVariantsSchema>(\r\n    compoundVariants: CVConfig<V>[\"compoundVariants\"],\r\n    utils: CVUtils<V>,\r\n) {\r\n    return typeof compoundVariants === \"function\" ? compoundVariants(utils) : compoundVariants;\r\n}\r\n","import type { ClassValue } from \"clsx\";\r\nimport type { Merge, Prettify } from \"ts-essentials\";\r\nimport type { CN } from \"./cn\";\r\nimport {\r\n    resolveCompoundVariants,\r\n    type CV,\r\n    type CVCompoundVariantsSchema,\r\n    type CVCompoundVariantsSchemaFunction,\r\n    type CVConfig,\r\n    type CVReturn,\r\n    type CVVariant,\r\n    type CVVariantSchema,\r\n    type CVVariantsSchema,\r\n} from \"./cv\";\r\n\r\ntype MergeVariant<V1 extends CVVariantSchema, V2 extends CVVariantSchema> = Prettify<\r\n    Record<keyof V1 | keyof V2, ClassValue>\r\n>;\r\ntype MergeVariantsSchemas<V1 extends CVVariantsSchema, V2 extends CVVariantsSchema> = Merge<\r\n    V1 & V2,\r\n    {\r\n        [K in keyof V1 & keyof V2]: MergeVariant<V1[K], V2[K]>;\r\n    }\r\n>;\r\n\r\ninterface CVExtendOptions {\r\n    cn: CN;\r\n    cv: CV;\r\n}\r\nexport function _extend({ cn, cv }: CVExtendOptions) {\r\n    const extendVariants = <V extends CVVariantsSchema, NewV extends CVVariantsSchema>(\r\n        variants: V,\r\n        newVariants?: NewV,\r\n    ) => {\r\n        const extendedVariants: CVVariantsSchema = structuredClone(variants);\r\n        for (const key in newVariants) {\r\n            extendedVariants[key] ??= {};\r\n            for (const variant in newVariants[key]) {\r\n                extendedVariants[key][variant] = cn(variants[key]?.[variant], newVariants[key][variant]);\r\n            }\r\n        }\r\n        return extendedVariants as MergeVariantsSchemas<V, NewV>;\r\n    };\r\n\r\n    return <V extends CVVariantsSchema, NewV extends CVVariantsSchema | (V & {})>(\r\n        component: CVReturn<V>,\r\n        newConfig: {\r\n            base?: ClassValue;\r\n            variants?: NewV;\r\n            compoundVariants?:\r\n                | CVCompoundVariantsSchema<MergeVariantsSchemas<V, NewV>>\r\n                | CVCompoundVariantsSchemaFunction<MergeVariantsSchemas<V, NewV>>;\r\n            defaultVariants?: CVVariant<MergeVariantsSchemas<V, NewV>>;\r\n        },\r\n    ) => {\r\n        const { config } = component;\r\n\r\n        return cv({\r\n            base: cn(config.base, newConfig.base),\r\n            variants: extendVariants(config.variants, newConfig.variants),\r\n            compoundVariants: (utils) =>\r\n                resolveCompoundVariants(config.compoundVariants, component).concat(\r\n                    resolveCompoundVariants(newConfig.compoundVariants ?? [], utils),\r\n                ),\r\n            defaultVariants: { ...config.defaultVariants, ...newConfig.defaultVariants },\r\n        } as CVConfig<MergeVariantsSchemas<V, NewV>>);\r\n    };\r\n}\r\n","import { _cn, type CNOptions } from \"./cn\";\r\nimport { _cv } from \"./cv\";\r\nimport { _extend } from \"./extend\";\r\n\r\nexport interface DefineCVOptions extends CNOptions {}\r\n\r\nexport function defineCV({ merge }: DefineCVOptions = {}) {\r\n    const cn = _cn({ merge });\r\n\r\n    const cv = _cv({ cn });\r\n\r\n    const extend = _extend({ cn, cv });\r\n\r\n    return { cn, cv, extend } as const;\r\n}\r\n"],"mappings":"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","names":["index_exports","__export","cn","cv","defineCV","extend","onlyWhenDefined","onlyWhenUndefined","__toCommonJS","onlyWhenDefined","onlyWhenUndefined","isCVToken","token","isSpecificCVToken","reference","shouldApplySelectorByToken","selector","import_clsx","_cn","merge","className","inputs","clsx","getKeys","obj","getEntries","getVariantMap","variants","cvKey","cvVal","splitProps","props","shouldSplit","splittedProps","otherProps","propKey","key","cvUtils","config","variantKeys","variantMap","_cv","options","config","resolvedConfig","utils","resolveConfig","base","variants","compoundVariants","defaultVariants","getVariantsClassNames","props","defaultedProps","classNames","key","variant","getCompoundVariantsClassNames","acc","compoundVariant","shouldApplyCompoundVariant","additionalClassName","variantClassNames","compoundVariantClassNames","matcher","defaults","cvKey","cvSelector","defaultsSelector","propsSelector","isCVToken","shouldApplySelectorByToken","selector","compareSelectors","selector1","selector2","defaultedConfig","cvUtils","resolveCompoundVariants","_extend","cn","cv","extendVariants","variants","newVariants","extendedVariants","key","variant","component","newConfig","config","utils","resolveCompoundVariants","defineCV","merge","cn","_cn","cv","_cv","extend","_extend","cn","cv","extend","defineCV"]}

package/build/index.d.cts

@@ -1,3 +1,17 @@
-import 'clsx';
-import 'ts-essentials';
-export { l as CV, m as CVCompose, i as CVCompoundVariant, j as CVCompoundVariantsSchema, b as CVConfig, c as CVOptions, a as CVReturn, k as CVUtils, h as CVVariant, C as CVVariantsSchema, f as VariantProps, W as WithClassProp, p as cn, r as compose, q as cv, n as defineCV, s as onlyWhenDefined, t as onlyWhenUndefined } from './index-w3SZ98rX.cjs';
+import { C as CV, a as CVVariantsSchema, b as CVReturn, c as CVCompoundVariantsSchema, e as CVCompoundVariantsSchemaFunction, f as CVVariant } from './cv-gIK0IznJ.cjs';
+export { i as CVCompoundVariant, j as CVToken, h as CVUtils, V as VariantProps, o as onlyWhenDefined, g as onlyWhenUndefined } from './cv-gIK0IznJ.cjs';
+import * as ts_essentials from 'ts-essentials';
+import * as clsx from 'clsx';
+import { CN } from './cn.cjs';
+export { defineCV } from './define.cjs';
+
+declare const cn: CN;
+declare const cv: CV;
+declare const extend: <V extends CVVariantsSchema, NewV extends CVVariantsSchema | (V & {})>(component: CVReturn<V>, newConfig: {
+    base?: clsx.ClassValue;
+    variants?: NewV;
+    compoundVariants?: CVCompoundVariantsSchema<ts_essentials.Prettify<Omit<V & NewV, keyof V & keyof NewV> & { [K in keyof V & keyof NewV]: ts_essentials.Prettify<Record<keyof V[K] | keyof NewV[K], clsx.ClassValue>>; }>> | CVCompoundVariantsSchemaFunction<ts_essentials.Prettify<Omit<V & NewV, keyof V & keyof NewV> & { [K in keyof V & keyof NewV]: ts_essentials.Prettify<Record<keyof V[K] | keyof NewV[K], clsx.ClassValue>>; }>>;
+    defaultVariants?: CVVariant<ts_essentials.Prettify<Omit<V & NewV, keyof V & keyof NewV> & { [K in keyof V & keyof NewV]: ts_essentials.Prettify<Record<keyof V[K] | keyof NewV[K], clsx.ClassValue>>; }>>;
+}) => CVReturn<ts_essentials.Prettify<Omit<V & NewV, keyof V & keyof NewV> & { [K in keyof V & keyof NewV]: ts_essentials.Prettify<Record<keyof V[K] | keyof NewV[K], clsx.ClassValue>>; }>>;
+
+export { CN, CV, CVCompoundVariantsSchema, CVReturn, CVVariant, CVVariantsSchema, cn, cv, extend };

package/build/index.d.ts

@@ -1,3 +1,17 @@
-import 'clsx';
-import 'ts-essentials';
-export { l as CV, m as CVCompose, i as CVCompoundVariant, j as CVCompoundVariantsSchema, b as CVConfig, c as CVOptions, a as CVReturn, k as CVUtils, h as CVVariant, C as CVVariantsSchema, f as VariantProps, W as WithClassProp, p as cn, r as compose, q as cv, n as defineCV, s as onlyWhenDefined, t as onlyWhenUndefined } from './index-w3SZ98rX.js';
+import { C as CV, a as CVVariantsSchema, b as CVReturn, c as CVCompoundVariantsSchema, e as CVCompoundVariantsSchemaFunction, f as CVVariant } from './cv--G8-bDtP.js';
+export { i as CVCompoundVariant, j as CVToken, h as CVUtils, V as VariantProps, o as onlyWhenDefined, g as onlyWhenUndefined } from './cv--G8-bDtP.js';
+import * as ts_essentials from 'ts-essentials';
+import * as clsx from 'clsx';
+import { CN } from './cn.js';
+export { defineCV } from './define.js';
+
+declare const cn: CN;
+declare const cv: CV;
+declare const extend: <V extends CVVariantsSchema, NewV extends CVVariantsSchema | (V & {})>(component: CVReturn<V>, newConfig: {
+    base?: clsx.ClassValue;
+    variants?: NewV;
+    compoundVariants?: CVCompoundVariantsSchema<ts_essentials.Prettify<Omit<V & NewV, keyof V & keyof NewV> & { [K in keyof V & keyof NewV]: ts_essentials.Prettify<Record<keyof V[K] | keyof NewV[K], clsx.ClassValue>>; }>> | CVCompoundVariantsSchemaFunction<ts_essentials.Prettify<Omit<V & NewV, keyof V & keyof NewV> & { [K in keyof V & keyof NewV]: ts_essentials.Prettify<Record<keyof V[K] | keyof NewV[K], clsx.ClassValue>>; }>>;
+    defaultVariants?: CVVariant<ts_essentials.Prettify<Omit<V & NewV, keyof V & keyof NewV> & { [K in keyof V & keyof NewV]: ts_essentials.Prettify<Record<keyof V[K] | keyof NewV[K], clsx.ClassValue>>; }>>;
+}) => CVReturn<ts_essentials.Prettify<Omit<V & NewV, keyof V & keyof NewV> & { [K in keyof V & keyof NewV]: ts_essentials.Prettify<Record<keyof V[K] | keyof NewV[K], clsx.ClassValue>>; }>>;
+
+export { CN, CV, CVCompoundVariantsSchema, CVReturn, CVVariant, CVVariantsSchema, cn, cv, extend };

package/build/index.js

@@ -1,2 +1,2 @@
-import{a,b,c,d,e,f}from"./chunk-IW3RSJHX.js";import"./chunk-4HS2U3AJ.js";export{b as cn,d as compose,c as cv,a as defineCV,e as onlyWhenDefined,f as onlyWhenUndefined};
+import{a as n}from"./chunk-AQKDS5WX.js";import"./chunk-FIET564E.js";import"./chunk-UUT6STP6.js";import"./chunk-XWAQU5O6.js";import{a as t,b as o}from"./chunk-IMTFPGTY.js";import"./chunk-77XW3WZ4.js";var{cn:e,cv:a,extend:C}=n();export{e as cn,a as cv,n as defineCV,C as extend,t as onlyWhenDefined,o as onlyWhenUndefined};
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type { CN } from \"./cn\";\r\nimport type {\r\n    CV,\r\n    CVCompoundVariant,\r\n    CVCompoundVariantsSchema,\r\n    CVReturn,\r\n    CVVariant,\r\n    CVVariantsSchema,\r\n    VariantProps,\r\n} from \"./cv\";\r\nimport { type CVToken, onlyWhenDefined, onlyWhenUndefined } from \"./tokens\";\r\nimport { defineCV } from \"./define\";\r\nimport type { CVUtils } from \"./utils\";\r\n\r\nexport const { cn, cv, extend } = defineCV();\r\n\r\nexport { defineCV, onlyWhenDefined, onlyWhenUndefined };\r\nexport type {\r\n    CN,\r\n    CV,\r\n    CVUtils,\r\n    CVReturn,\r\n    VariantProps,\r\n    CVVariantsSchema,\r\n    CVCompoundVariantsSchema,\r\n    CVVariant,\r\n    CVCompoundVariant,\r\n    CVToken,\r\n};\r\n"],"mappings":"uMAcO,GAAM,CAAE,GAAAA,EAAI,GAAAC,EAAI,OAAAC,CAAO,EAAIC,EAAS","names":["cn","cv","extend","defineCV"]}

package/build/tokens.cjs

@@ -0,0 +1,2 @@
+"use strict";var i=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var s=Object.getOwnPropertyNames;var y=Object.prototype.hasOwnProperty;var u=(e,n)=>{for(var t in n)i(e,t,{get:n[t],enumerable:!0})},k=(e,n,t,f)=>{if(n&&typeof n=="object"||typeof n=="function")for(let o of s(n))!y.call(e,o)&&o!==t&&i(e,o,{get:()=>n[o],enumerable:!(f=l(n,o))||f.enumerable});return e};var _=e=>k(i({},"__esModule",{value:!0}),e);var c={};u(c,{isCVToken:()=>h,onlyWhenDefined:()=>d,onlyWhenUndefined:()=>p,shouldApplySelectorByToken:()=>O});module.exports=_(c);var d={__token:"OnlyWhenDefined"},p={__token:"OnlyWhenUndefined"};function h(e){return e?typeof e=="object"&&"__token"in e:!1}function r(e,n){return e.__token===n.__token}function O(e,n){return r(e,d)?n!==void 0:r(e,p)?n===void 0:!1}0&&(module.exports={isCVToken,onlyWhenDefined,onlyWhenUndefined,shouldApplySelectorByToken});
+//# sourceMappingURL=tokens.cjs.map

package/build/tokens.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tokens.ts"],"sourcesContent":["import type { Opaque } from \"ts-essentials\";\r\nimport type { CVPropsValue } from \"./cv\";\r\n\r\ntype OnlyWhenDefined = Opaque<{ __token: string }, \"OnlyWhenDefined\">;\r\ntype OnlyWhenUndefined = Opaque<{ __token: string }, \"OnlyWhenUndefined\">;\r\n\r\nexport type 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\r\nexport function isCVToken(token: unknown): token is CVToken {\r\n    return token ? typeof token === \"object\" && \"__token\" in token : false;\r\n}\r\nfunction isSpecificCVToken<TReference extends CVToken>(token: CVToken, reference: TReference): token is TReference {\r\n    return token.__token === reference.__token;\r\n}\r\n\r\nexport function shouldApplySelectorByToken(token: CVToken, selector: CVPropsValue) {\r\n    if (isSpecificCVToken(token, onlyWhenDefined)) return selector !== undefined;\r\n    else if (isSpecificCVToken(token, onlyWhenUndefined)) return selector === undefined;\r\n\r\n    return false;\r\n}\r\n"],"mappings":"yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,eAAAE,EAAA,oBAAAC,EAAA,sBAAAC,EAAA,+BAAAC,IAAA,eAAAC,EAAAN,GASO,IAAMG,EAAkB,CAAE,QAAS,iBAAkB,EAE/CC,EAAoB,CAAE,QAAS,mBAAoB,EAEzD,SAASF,EAAUK,EAAkC,CACxD,OAAOA,EAAQ,OAAOA,GAAU,UAAY,YAAaA,EAAQ,EACrE,CACA,SAASC,EAA8CD,EAAgBE,EAA4C,CAC/G,OAAOF,EAAM,UAAYE,EAAU,OACvC,CAEO,SAASJ,EAA2BE,EAAgBG,EAAwB,CAC/E,OAAIF,EAAkBD,EAAOJ,CAAe,EAAUO,IAAa,OAC1DF,EAAkBD,EAAOH,CAAiB,EAAUM,IAAa,OAEnE,EACX","names":["tokens_exports","__export","isCVToken","onlyWhenDefined","onlyWhenUndefined","shouldApplySelectorByToken","__toCommonJS","token","isSpecificCVToken","reference","selector"]}

package/build/tokens.d.cts

@@ -0,0 +1,4 @@
+import 'ts-essentials';
+export { j as CVToken, k as isCVToken, o as onlyWhenDefined, g as onlyWhenUndefined, s as shouldApplySelectorByToken } from './cv-gIK0IznJ.cjs';
+import 'clsx';
+import './cn.cjs';

package/build/tokens.d.ts

@@ -0,0 +1,4 @@
+import 'ts-essentials';
+export { j as CVToken, k as isCVToken, o as onlyWhenDefined, g as onlyWhenUndefined, s as shouldApplySelectorByToken } from './cv--G8-bDtP.js';
+import 'clsx';
+import './cn.js';

package/build/tokens.js

@@ -0,0 +1,2 @@
+import{a,b,c,d}from"./chunk-IMTFPGTY.js";export{c as isCVToken,a as onlyWhenDefined,b as onlyWhenUndefined,d as shouldApplySelectorByToken};
+//# sourceMappingURL=tokens.js.map

package/build/tokens.js.map

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

package/build/utils.cjs

@@ -1,2 +1,2 @@
-"use strict";var o=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var p=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 y(n))!p.call(e,r)&&r!==t&&o(e,r,{get:()=>n[r],enumerable:!(i=a(n,r))||i.enumerable});return e};var d=e=>c(o({},"__esModule",{value:!0}),e);var k={};f(k,{getEntries:()=>O,getKeys:()=>s,getVariantsOptions:()=>x,objectFromEntries:()=>V});module.exports=d(k);function s(e){return Object.keys(e)}function O(e){return Object.entries(e)}function x(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});
+"use strict";var a=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var u=Object.prototype.hasOwnProperty;var C=(t,r)=>{for(var e in r)a(t,e,{get:r[e],enumerable:!0})},l=(t,r,e,s)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of y(r))!u.call(t,o)&&o!==e&&a(t,o,{get:()=>r[o],enumerable:!(s=f(r,o))||s.enumerable});return t};var k=t=>l(a({},"__esModule",{value:!0}),t);var x={};C(x,{cvUtils:()=>d,getEntries:()=>V,getKeys:()=>i,getVariantMap:()=>p,splitProps:()=>P});module.exports=k(x);function i(t){return Object.keys(t)}function V(t){return Object.entries(t)}function p(t){return Object.fromEntries(V(t).map(([r,e])=>[r,i(e)]))}function P(t,r){let e={},s={};if(!t)return[e,s];for(let o in t){let n=o;r(n)?e[n]=t[n]:s[n]=t[n]}return[e,s]}function d(t){let r=i(t.variants),e=p(t.variants);return{variantKeys:r,variantMap:e,splitVariantProps:n=>P(n,c=>c in e),getVariantProps:n=>({...t.defaultVariants,...n})}}0&&(module.exports={cvUtils,getEntries,getKeys,getVariantMap,splitProps});
 //# 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\";\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            ? Record<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"]}
+{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["// import type { DeepReadonly, DeepWritable, Prettify, UnionToIntersection } from \"ts-essentials\";\r\nimport type { Prettify } from \"ts-essentials\";\r\nimport type { BooleanStringToBoolean, CVConfig, CVReturnProps, CVVariantKey, CVVariantsSchema } from \"./cv\";\r\n\r\nexport function getKeys<O extends Record<string, unknown>>(obj: O) {\r\n    return Object.keys(obj) as (keyof O & CVVariantKey)[];\r\n}\r\n\r\nexport type 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 type VariantMap<V extends CVVariantsSchema> = {\r\n    [K in keyof V]: BooleanStringToBoolean<keyof V[K] & CVVariantKey>[];\r\n};\r\nexport function getVariantMap<V extends CVVariantsSchema>(variants: V) {\r\n    return Object.fromEntries(getEntries(variants).map(([cvKey, cvVal]) => [cvKey, getKeys(cvVal)])) as VariantMap<V>;\r\n}\r\n\r\nexport function splitProps<TProps>(props: TProps, shouldSplit: (key: keyof TProps) => boolean) {\r\n    const splittedProps = {} as Partial<Record<keyof TProps, unknown>>;\r\n    const otherProps = {} as Partial<Record<keyof TProps, unknown>>;\r\n    if (!props) return [splittedProps, otherProps] as const;\r\n    for (const propKey in props) {\r\n        const key = propKey as keyof TProps;\r\n        if (shouldSplit(key)) splittedProps[key] = props[key];\r\n        else otherProps[key] = props[key];\r\n    }\r\n    return [splittedProps, otherProps] as const;\r\n}\r\n\r\nexport interface CVUtils<V extends CVVariantsSchema> {\r\n    variantKeys: (keyof V & string)[];\r\n    variantMap: Prettify<VariantMap<V>>;\r\n    splitVariantProps: <TProps extends CVReturnProps<V>>(\r\n        props?: TProps,\r\n    ) => [CVReturnProps<V>, Prettify<Omit<TProps, keyof CVReturnProps<V>>>];\r\n    getVariantProps: (props?: CVReturnProps<V>) => Exclude<CVReturnProps<V>, void>;\r\n}\r\n\r\nexport function cvUtils<V extends CVVariantsSchema>(config: CVConfig<V>): CVUtils<V> {\r\n    const variantKeys = getKeys(config.variants);\r\n    const variantMap = getVariantMap(config.variants);\r\n    const splitVariantProps = (props?: CVReturnProps<V>) => splitProps(props, (key) => key in variantMap);\r\n    const getVariantProps = (props?: CVReturnProps<V>) => ({ ...config.defaultVariants, ...props });\r\n\r\n    return { variantKeys, variantMap, splitVariantProps, getVariantProps } as CVUtils<V>;\r\n}\r\n"],"mappings":"yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,aAAAE,EAAA,eAAAC,EAAA,YAAAC,EAAA,kBAAAC,EAAA,eAAAC,IAAA,eAAAC,EAAAP,GAIO,SAASI,EAA2CI,EAAQ,CAC/D,OAAO,OAAO,KAAKA,CAAG,CAC1B,CAGO,SAASL,EAA8CK,EAAQ,CAClE,OAAO,OAAO,QAAQA,CAAG,CAC7B,CAKO,SAASH,EAA0CI,EAAa,CACnE,OAAO,OAAO,YAAYN,EAAWM,CAAQ,EAAE,IAAI,CAAC,CAACC,EAAOC,CAAK,IAAM,CAACD,EAAON,EAAQO,CAAK,CAAC,CAAC,CAAC,CACnG,CAEO,SAASL,EAAmBM,EAAeC,EAA6C,CAC3F,IAAMC,EAAgB,CAAC,EACjBC,EAAa,CAAC,EACpB,GAAI,CAACH,EAAO,MAAO,CAACE,EAAeC,CAAU,EAC7C,QAAWC,KAAWJ,EAAO,CACzB,IAAMK,EAAMD,EACRH,EAAYI,CAAG,EAAGH,EAAcG,CAAG,EAAIL,EAAMK,CAAG,EAC/CF,EAAWE,CAAG,EAAIL,EAAMK,CAAG,CACpC,CACA,MAAO,CAACH,EAAeC,CAAU,CACrC,CAWO,SAASb,EAAoCgB,EAAiC,CACjF,IAAMC,EAAcf,EAAQc,EAAO,QAAQ,EACrCE,EAAaf,EAAca,EAAO,QAAQ,EAIhD,MAAO,CAAE,YAAAC,EAAa,WAAAC,EAAY,kBAHPR,GAA6BN,EAAWM,EAAQK,GAAQA,KAAOG,CAAU,EAG/C,gBAF5BR,IAA8B,CAAE,GAAGM,EAAO,gBAAiB,GAAGN,CAAM,EAExB,CACzE","names":["utils_exports","__export","cvUtils","getEntries","getKeys","getVariantMap","splitProps","__toCommonJS","obj","variants","cvKey","cvVal","props","shouldSplit","splittedProps","otherProps","propKey","key","config","variantKeys","variantMap"]}

package/build/utils.d.cts

@@ -1,3 +1,4 @@
 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-w3SZ98rX.cjs';
+export { h as CVUtils, E as EntriesOf, n as VariantMap, r as cvUtils, m as getEntries, l as getKeys, p as getVariantMap, q as splitProps } from './cv-gIK0IznJ.cjs';
 import 'clsx';
+import './cn.cjs';

package/build/utils.d.ts

@@ -1,3 +1,4 @@
 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-w3SZ98rX.js';
+export { h as CVUtils, E as EntriesOf, n as VariantMap, r as cvUtils, m as getEntries, l as getKeys, p as getVariantMap, q as splitProps } from './cv--G8-bDtP.js';
 import 'clsx';
+import './cn.js';

package/build/utils.js

@@ -1,2 +1,2 @@
-import{a,b,c,d}from"./chunk-4HS2U3AJ.js";export{b as getEntries,a as getKeys,c as getVariantsOptions,d as objectFromEntries};
+import{a,b,c,d,e}from"./chunk-77XW3WZ4.js";export{e as cvUtils,b as getEntries,a as getKeys,c as getVariantMap,d as splitProps};
 //# sourceMappingURL=utils.js.map

package/build/vue.cjs

@@ -1,2 +1,2 @@
-"use strict";var m=Object.defineProperty;var E=Object.getOwnPropertyDescriptor;var U=Object.getOwnPropertyNames;var q=Object.prototype.hasOwnProperty;var D=(e,n)=>{for(var s in n)m(e,s,{get:n[s],enumerable:!0})},N=(e,n,s,i)=>{if(n&&typeof n=="object"||typeof n=="function")for(let t of U(n))!q.call(e,t)&&t!==s&&m(e,t,{get:()=>n[t],enumerable:!(i=E(n,t))||i.enumerable});return e};var j=e=>N(m({},"__esModule",{value:!0}),e);var A={};D(A,{cvWithProps:()=>w,getPropsDeclaration:()=>P});module.exports=j(A);var g=require("clsx");function d(e){return Object.keys(e)}function x(e){return Object.entries(e)}function h(e){return Object.fromEntries(x(e).map(([n,s])=>[n,d(s)]))}function k(e){return Object.fromEntries(e)}function M(e={}){let n=e.merge??g.clsx;return{cn:n,cv:t=>{let{base:V,variants:r,defaultVariants:p,requiredVariants:K}=t,y={variants:r??{},variantKeys:r?d(r):[],variantMap:r?h(r):{},defaultVariants:p??{},requiredVariants:K??{}},T=r?typeof t.compoundVariants=="function"?t.compoundVariants(y):t.compoundVariants:void 0;return Object.assign(f=>{let W=r?y.variantKeys.map(a=>{let u=f?.[a],l=p?.[a],c=u?.toString()||l?.toString();return c?r[a][c]:void 0}):void 0,S=T?.reduce((a,{class:u,className:l,...c})=>(x(c).every(([R,o])=>{let b=p?.[R],C=f?.[R];if(typeof o=="object"&&"__token"in o){if(o.__token===B.__token)return C!==void 0;if(o.__token===I.__token)return C===void 0}let O=C??b;return Array.isArray(o)?o.some(_=>O===_):O===o})&&a.push(u,l),a),new Array);return n(V,W,S,f?.class,f?.className)},y)},compose:(...t)=>V=>{let r={...V,class:void 0,className:void 0};return n(t.map(p=>p(r)),V?.class,V?.className)}}}var{cn:Y,cv:v,compose:Z}=M(),B={__token:"OnlyWhenDefined"},I={__token:"OnlyWhenUndefined"};function P(e){return typeof e?.variants>"u"?{}:k(d(e.variants).map(n=>[n,{type:String,required:e.requiredVariants?.[n]}]))}var w=(e,n)=>{let s=v(e,n),i=P(e);return{getClass:s,props:i}};0&&(module.exports={cvWithProps,getPropsDeclaration});
+"use strict";var o=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var V=Object.prototype.hasOwnProperty;var i=(t,e)=>{for(var n in e)o(t,n,{get:e[n],enumerable:!0})},m=(t,e,n,p)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of y(e))!V.call(t,r)&&r!==n&&o(t,r,{get:()=>e[r],enumerable:!(p=a(e,r))||p.enumerable});return t};var s=t=>m(o({},"__esModule",{value:!0}),t);var u={};i(u,{getPropsDeclaration:()=>f});module.exports=s(u);function f(t){return Object.fromEntries(t.variantKeys.map(e=>[e,{type:null}]))}0&&(module.exports={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\";\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.requiredVariants?.[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\";\nimport {\n    MarkRequired,\n    Opaque,\n    Prettify,\n    type RequiredKeys,\n    type UnionToIntersection,\n} from \"ts-essentials\";\nimport {\n    getEntries,\n    getKeys,\n    getVariantsOptions,\n    KeysOf,\n    VariantOptions as VariantMap,\n} from \"./utils\";\n\ntype ClassProp =\n    | { class?: ClassValue; className?: never }\n    | { class?: never; className?: ClassValue };\n\nexport type WithClassProp<T extends object> = T & ClassProp;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type VariantProps<CVR extends (props?: any) => string> = Prettify<\n    Omit<\n        UnionToIntersection<Exclude<Parameters<CVR>[0], void | null | undefined>>,\n        \"class\" | \"className\"\n    >\n>;\n\ntype BooleanStringToBoolean<T> = T extends \"true\" | \"false\" ? boolean : T;\n\nexport type CVVariantsSchema = Record<string, Record<string | number, ClassValue>>;\n\nexport type CVVariant<V extends CVVariantsSchema> = {\n    [K in keyof V]?: BooleanStringToBoolean<keyof V[K]>;\n};\nexport type CVCompoundVariant<V extends CVVariantsSchema> = WithClassProp<{\n    [K in keyof V]?:\n        | BooleanStringToBoolean<keyof V[K]>\n        | BooleanStringToBoolean<keyof V[K]>[]\n        | CVToken;\n}>;\n\nexport type CVCompoundVariantsSchema<V extends CVVariantsSchema> = CVCompoundVariant<V>[];\n\nexport interface CVConfig<V extends CVVariantsSchema, R extends keyof V> {\n    base?: ClassValue;\n    variants?: V;\n    compoundVariants?:\n        | CVCompoundVariantsSchema<V>\n        | ((arg: CVUtils<V, R>) => CVCompoundVariantsSchema<V>);\n    defaultVariants?: CVVariant<V>;\n    requiredVariants?: Record<R, boolean>;\n}\nexport interface CVOptions {\n    merge?: (...args: ClassValue[]) => string;\n}\n\ntype CVReturnProps<V extends CVVariantsSchema, R extends keyof V = never> =\n    | WithClassProp<MarkRequired<CVVariant<V>, R>>\n    | ([R] extends [never] ? void : never);\n\nexport interface CVUtils<V extends CVVariantsSchema, R extends keyof V = never> {\n    variants: V;\n    variantKeys: KeysOf<V>;\n    variantMap: VariantMap<V>;\n    defaultVariants: CVVariant<V>;\n    requiredVariants: Record<R, boolean>;\n}\nexport interface CVReturn<V extends CVVariantsSchema, R extends keyof V = never>\n    extends CVUtils<V, R> {\n    (props: CVReturnProps<V, R>): string;\n}\n\nexport interface CV {\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        cvOptions?: CVOptions,\n    ): CVReturn<V, R>;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype CVComposeReturnProps<T extends (props?: any) => string> =\n    | WithClassProp<VariantProps<T>>\n    | (RequiredKeys<VariantProps<T>> extends never ? void : never);\nexport interface CVCompose {\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type, @typescript-eslint/no-explicit-any\n    <T extends ((props?: any) => string)[]>(\n        ...components: T\n    ): (props: CVComposeReturnProps<T[number]>) => string;\n}\n\nexport function defineCV(options: CVOptions = {}) {\n    const cn = options.merge ?? clsx;\n\n    const cv: CV = (config) => {\n        const { base, variants, defaultVariants, requiredVariants } = config;\n\n        type ResolvedV = NonNullable<typeof variants>;\n\n        const utils = {\n            variants: variants ?? ({} as ResolvedV),\n            variantKeys: variants ? getKeys(variants) : [],\n            variantMap: variants ? getVariantsOptions(variants) : ({} as VariantMap<ResolvedV>),\n            defaultVariants: defaultVariants ?? ({} as CVVariant<ResolvedV>),\n            requiredVariants: requiredVariants ?? ({} as Record<keyof ResolvedV, boolean>),\n        };\n\n        const compoundVariants = variants\n            ? typeof config.compoundVariants === \"function\"\n                ? config.compoundVariants(utils)\n                : config.compoundVariants\n            : undefined;\n\n        const getVariant = <V extends ResolvedV, R extends keyof V = never>(\n            props: CVReturnProps<V, R>,\n        ) => {\n            const variantClassNames = variants\n                ? utils.variantKeys.map((variant) => {\n                      const variantProp = props?.[variant];\n                      const defaults = defaultVariants?.[variant];\n\n                      const variantKey = variantProp?.toString() || defaults?.toString();\n\n                      return variantKey ? variants[variant][variantKey] : undefined;\n                  })\n                : undefined;\n\n            const compoundVariantClassNames = compoundVariants?.reduce(\n                (acc, { class: cvClass, className: cvClassName, ...cvConfig }) => {\n                    const shouldApplyCompoundVariant = getEntries(cvConfig).every(\n                        ([cvKey, cvSelector]) => {\n                            const defaultsSelector =\n                                defaultVariants?.[cvKey as keyof typeof defaultVariants];\n                            const propsSelector = props?.[cvKey as keyof typeof props];\n\n                            if (typeof cvSelector === \"object\" && \"__token\" in cvSelector) {\n                                if (cvSelector.__token === onlyWhenDefined.__token) {\n                                    return propsSelector !== undefined;\n                                } else if (cvSelector.__token === onlyWhenUndefined.__token) {\n                                    return propsSelector === undefined;\n                                }\n                            }\n\n                            const selector = propsSelector ?? defaultsSelector;\n\n                            return Array.isArray(cvSelector)\n                                ? cvSelector.some((cvSelector) => selector === cvSelector)\n                                : selector === cvSelector;\n                        },\n                    );\n\n                    if (shouldApplyCompoundVariant) acc.push(cvClass, cvClassName);\n                    return acc;\n                },\n                new Array<ClassValue>(),\n            );\n\n            return cn(\n                base,\n                variantClassNames,\n                compoundVariantClassNames,\n                props?.class,\n                props?.className,\n            );\n        };\n\n        return Object.assign(getVariant, utils);\n    };\n\n    const compose: CVCompose =\n        (...components) =>\n        (props) => {\n            const propsWithoutClass = { ...props, class: undefined, className: undefined };\n\n            return cn(\n                components.map((component) => component(propsWithoutClass)),\n                props?.class,\n                props?.className,\n            );\n        };\n\n    return { cn, cv, compose };\n}\n\nexport const { cn, cv, compose } = defineCV();\n\ntype OnlyWhenDefined = Opaque<{ __token: string }, \"OnlyWhenDefined\">;\ntype OnlyWhenUndefined = Opaque<{ __token: string }, \"OnlyWhenUndefined\">;\n\ntype CVToken = OnlyWhenDefined | OnlyWhenUndefined;\n\n/** Apply compound variant only if prop **is** specified */\nexport const onlyWhenDefined = { __token: \"OnlyWhenDefined\" } as OnlyWhenDefined;\n/** Apply compound variant only if prop **is not** specified */\nexport const onlyWhenUndefined = { __token: \"OnlyWhenUndefined\" } as OnlyWhenUndefined;\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            ? Record<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,CD0DO,SAASC,EAASC,EAAqB,CAAC,EAAG,CAC9C,IAAMC,EAAKD,EAAQ,OAAS,OAyF5B,MAAO,CAAE,GAAAC,EAAI,GAvFGC,GAAW,CACvB,GAAM,CAAE,KAAAC,EAAM,SAAAC,EAAU,gBAAAC,EAAiB,iBAAAC,CAAiB,EAAIJ,EAIxDK,EAAQ,CACV,SAAUH,GAAa,CAAC,EACxB,YAAaA,EAAWI,EAAQJ,CAAQ,EAAI,CAAC,EAC7C,WAAYA,EAAWK,EAAmBL,CAAQ,EAAK,CAAC,EACxD,gBAAiBC,GAAoB,CAAC,EACtC,iBAAkBC,GAAqB,CAAC,CAC5C,EAEMI,EAAmBN,EACnB,OAAOF,EAAO,kBAAqB,WAC/BA,EAAO,iBAAiBK,CAAK,EAC7BL,EAAO,iBACX,OAuDN,OAAO,OAAO,OApDVS,GACC,CACD,IAAMC,EAAoBR,EACpBG,EAAM,YAAY,IAAKM,GAAY,CAC/B,IAAMC,EAAcH,IAAQE,CAAO,EAC7BE,EAAWV,IAAkBQ,CAAO,EAEpCG,EAAaF,GAAa,SAAS,GAAKC,GAAU,SAAS,EAEjE,OAAOC,EAAaZ,EAASS,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,EACFpB,IAAkBkB,CAAqC,EACrDG,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,EACHE,EACAS,EACAK,EACAN,GAAO,MACPA,GAAO,SACX,CACJ,EAEiCJ,CAAK,CAC1C,EAciB,QAXb,IAAIuB,IACHnB,GAAU,CACP,IAAMoB,EAAoB,CAAE,GAAGpB,EAAO,MAAO,OAAW,UAAW,MAAU,EAE7E,OAAOV,EACH6B,EAAW,IAAKE,GAAcA,EAAUD,CAAiB,CAAC,EAC1DpB,GAAO,MACPA,GAAO,SACX,CACJ,CAEqB,CAC7B,CAEO,GAAM,CAAE,GAAAV,EAAI,GAAAgC,EAAI,QAAAC,CAAQ,EAAInC,EAAS,EAQ/B4B,EAAkB,CAAE,QAAS,iBAAkB,EAE/CC,EAAoB,CAAE,QAAS,mBAAoB,ED7KzD,SAASO,EACZC,EACF,CACE,OAAI,OAAOA,GAAQ,SAAa,IACrB,CAAC,EAGLC,EACHC,EAAQF,EAAO,QAAQ,EAAE,IACpBG,GACG,CACIA,EACA,CACI,KAAM,OACN,SAAUH,EAAO,mBAAmBG,CAAQ,CAChD,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","defineCV","options","cn","config","base","variants","defaultVariants","requiredVariants","utils","getKeys","getVariantsOptions","compoundVariants","props","variantClassNames","variant","variantProp","defaults","variantKey","compoundVariantClassNames","acc","cvClass","cvClassName","cvConfig","getEntries","cvKey","cvSelector","defaultsSelector","propsSelector","onlyWhenDefined","onlyWhenUndefined","selector","components","propsWithoutClass","component","cv","compose","getPropsDeclaration","config","objectFromEntries","getKeys","key","cvWithProps","options","getClass","cv","props"]}
+{"version":3,"sources":["../src/vue.ts"],"sourcesContent":["import { type PropType } from \"vue\";\r\nimport { type CVReturn, type CVVariantsSchema } from \"./cv\";\r\n\r\nexport function getPropsDeclaration<V extends CVVariantsSchema /* , R extends keyof V = never */>(cv: CVReturn<V>) {\r\n    return Object.fromEntries(\r\n        cv.variantKeys.map((key) => [key, { type: null /* , required: cv.requiredVariants[key as R] */ }]),\r\n    ) as unknown as { [K in keyof V]: { type: PropType<keyof V[K]> /* ; required: K extends R ? true : false */ } };\r\n}\r\n"],"mappings":"yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,yBAAAE,IAAA,eAAAC,EAAAH,GAGO,SAASE,EAAkFE,EAAiB,CAC/G,OAAO,OAAO,YACVA,EAAG,YAAY,IAAKC,GAAQ,CAACA,EAAK,CAAE,KAAM,IAAqD,CAAC,CAAC,CACrG,CACJ","names":["vue_exports","__export","getPropsDeclaration","__toCommonJS","cv","key"]}

package/build/vue.d.cts

@@ -1,22 +1,11 @@
-import { Prettify } from 'ts-essentials';
 import { PropType } from 'vue';
-import { C as CVVariantsSchema, a as CVReturn, b as CVConfig, c as CVOptions } from './index-w3SZ98rX.cjs';
+import { a as CVVariantsSchema, b as CVReturn } from './cv-gIK0IznJ.cjs';
 import 'clsx';
+import 'ts-essentials';
+import './cn.cjs';
 
-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;
-    };
-}>;
-interface CVWithPropsReturn<V extends CVVariantsSchema, R extends keyof V = never> {
-    getClass: CVReturn<V, R>;
-    props: PropsDeclaration<NoInfer<V>, NoInfer<R>>;
-}
-interface CVWithProps {
-    <V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>, options?: CVOptions): CVWithPropsReturn<V, R>;
-}
-declare function getPropsDeclaration<V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>): {};
-declare const cvWithProps: CVWithProps;
+declare function getPropsDeclaration<V extends CVVariantsSchema>(cv: CVReturn<V>): { [K in keyof V]: {
+    type: PropType<keyof V[K]>;
+}; };
 
-export { type CVWithProps, type CVWithPropsReturn, cvWithProps, getPropsDeclaration };
+export { getPropsDeclaration };

package/build/vue.d.ts

@@ -1,22 +1,11 @@
-import { Prettify } from 'ts-essentials';
 import { PropType } from 'vue';
-import { C as CVVariantsSchema, a as CVReturn, b as CVConfig, c as CVOptions } from './index-w3SZ98rX.js';
+import { a as CVVariantsSchema, b as CVReturn } from './cv--G8-bDtP.js';
 import 'clsx';
+import 'ts-essentials';
+import './cn.js';
 
-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;
-    };
-}>;
-interface CVWithPropsReturn<V extends CVVariantsSchema, R extends keyof V = never> {
-    getClass: CVReturn<V, R>;
-    props: PropsDeclaration<NoInfer<V>, NoInfer<R>>;
-}
-interface CVWithProps {
-    <V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>, options?: CVOptions): CVWithPropsReturn<V, R>;
-}
-declare function getPropsDeclaration<V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>): {};
-declare const cvWithProps: CVWithProps;
+declare function getPropsDeclaration<V extends CVVariantsSchema>(cv: CVReturn<V>): { [K in keyof V]: {
+    type: PropType<keyof V[K]>;
+}; };
 
-export { type CVWithProps, type CVWithPropsReturn, cvWithProps, getPropsDeclaration };
+export { getPropsDeclaration };

package/build/vue.js

@@ -1,2 +1,2 @@
-import{c as o}from"./chunk-IW3RSJHX.js";import{a as r,d as n}from"./chunk-4HS2U3AJ.js";function V(e){return typeof e?.variants>"u"?{}:n(r(e.variants).map(t=>[t,{type:String,required:e.requiredVariants?.[t]}]))}var R=(e,t)=>{let s=o(e,t),i=V(e);return{getClass:s,props:i}};export{R as cvWithProps,V as getPropsDeclaration};
+function r(e){return Object.fromEntries(e.variantKeys.map(t=>[t,{type:null}]))}export{r 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\";\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.requiredVariants?.[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,mBAAmBG,CAAQ,CAChD,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"]}
+{"version":3,"sources":["../src/vue.ts"],"sourcesContent":["import { type PropType } from \"vue\";\r\nimport { type CVReturn, type CVVariantsSchema } from \"./cv\";\r\n\r\nexport function getPropsDeclaration<V extends CVVariantsSchema /* , R extends keyof V = never */>(cv: CVReturn<V>) {\r\n    return Object.fromEntries(\r\n        cv.variantKeys.map((key) => [key, { type: null /* , required: cv.requiredVariants[key as R] */ }]),\r\n    ) as unknown as { [K in keyof V]: { type: PropType<keyof V[K]> /* ; required: K extends R ? true : false */ } };\r\n}\r\n"],"mappings":"AAGO,SAASA,EAAkFC,EAAiB,CAC/G,OAAO,OAAO,YACVA,EAAG,YAAY,IAAKC,GAAQ,CAACA,EAAK,CAAE,KAAM,IAAqD,CAAC,CAAC,CACrG,CACJ","names":["getPropsDeclaration","cv","key"]}

package/package.json

@@ -5,7 +5,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.4.0-rc",
+  "version": "0.6.0-rc.1",
   "type": "module",
   "files": [
     "build"

package/build/chunk-4HS2U3AJ.js

@@ -1,2 +0,0 @@
-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-4HS2U3AJ.js.map

package/build/chunk-4HS2U3AJ.js.map

@@ -1 +0,0 @@
-{"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            ? Record<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/chunk-IW3RSJHX.js

@@ -1,2 +0,0 @@
-import{a as f,b as y,c as m}from"./chunk-4HS2U3AJ.js";import{clsx as T}from"clsx";function P(x={}){let V=x.merge??T;return{cn:V,cv:a=>{let{base:s,variants:e,defaultVariants:o,requiredVariants:R}=a,d={variants:e??{},variantKeys:e?f(e):[],variantMap:e?m(e):{},defaultVariants:o??{},requiredVariants:R??{}},h=e?typeof a.compoundVariants=="function"?a.compoundVariants(d):a.compoundVariants:void 0;return Object.assign(r=>{let v=e?d.variantKeys.map(t=>{let p=r?.[t],l=o?.[t],i=p?.toString()||l?.toString();return i?e[t][i]:void 0}):void 0,k=h?.reduce((t,{class:p,className:l,...i})=>(y(i).every(([C,n])=>{let g=o?.[C],u=r?.[C];if(typeof n=="object"&&"__token"in n){if(n.__token===_.__token)return u!==void 0;if(n.__token===W.__token)return u===void 0}let c=u??g;return Array.isArray(n)?n.some(O=>c===O):c===n})&&t.push(p,l),t),new Array);return V(s,v,k,r?.class,r?.className)},d)},compose:(...a)=>s=>{let e={...s,class:void 0,className:void 0};return V(a.map(o=>o(e)),s?.class,s?.className)}}}var{cn:A,cv:j,compose:E}=P(),_={__token:"OnlyWhenDefined"},W={__token:"OnlyWhenUndefined"};export{P as a,A as b,j as c,E as d,_ as e,W as f};
-//# sourceMappingURL=chunk-IW3RSJHX.js.map

package/build/chunk-IW3RSJHX.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { ClassValue, clsx } from \"clsx\";\nimport {\n    MarkRequired,\n    Opaque,\n    Prettify,\n    type RequiredKeys,\n    type UnionToIntersection,\n} from \"ts-essentials\";\nimport {\n    getEntries,\n    getKeys,\n    getVariantsOptions,\n    KeysOf,\n    VariantOptions as VariantMap,\n} from \"./utils\";\n\ntype ClassProp =\n    | { class?: ClassValue; className?: never }\n    | { class?: never; className?: ClassValue };\n\nexport type WithClassProp<T extends object> = T & ClassProp;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type VariantProps<CVR extends (props?: any) => string> = Prettify<\n    Omit<\n        UnionToIntersection<Exclude<Parameters<CVR>[0], void | null | undefined>>,\n        \"class\" | \"className\"\n    >\n>;\n\ntype BooleanStringToBoolean<T> = T extends \"true\" | \"false\" ? boolean : T;\n\nexport type CVVariantsSchema = Record<string, Record<string | number, ClassValue>>;\n\nexport type CVVariant<V extends CVVariantsSchema> = {\n    [K in keyof V]?: BooleanStringToBoolean<keyof V[K]>;\n};\nexport type CVCompoundVariant<V extends CVVariantsSchema> = WithClassProp<{\n    [K in keyof V]?:\n        | BooleanStringToBoolean<keyof V[K]>\n        | BooleanStringToBoolean<keyof V[K]>[]\n        | CVToken;\n}>;\n\nexport type CVCompoundVariantsSchema<V extends CVVariantsSchema> = CVCompoundVariant<V>[];\n\nexport interface CVConfig<V extends CVVariantsSchema, R extends keyof V> {\n    base?: ClassValue;\n    variants?: V;\n    compoundVariants?:\n        | CVCompoundVariantsSchema<V>\n        | ((arg: CVUtils<V, R>) => CVCompoundVariantsSchema<V>);\n    defaultVariants?: CVVariant<V>;\n    requiredVariants?: Record<R, boolean>;\n}\nexport interface CVOptions {\n    merge?: (...args: ClassValue[]) => string;\n}\n\ntype CVReturnProps<V extends CVVariantsSchema, R extends keyof V = never> =\n    | WithClassProp<MarkRequired<CVVariant<V>, R>>\n    | ([R] extends [never] ? void : never);\n\nexport interface CVUtils<V extends CVVariantsSchema, R extends keyof V = never> {\n    variants: V;\n    variantKeys: KeysOf<V>;\n    variantMap: VariantMap<V>;\n    defaultVariants: CVVariant<V>;\n    requiredVariants: Record<R, boolean>;\n}\nexport interface CVReturn<V extends CVVariantsSchema, R extends keyof V = never>\n    extends CVUtils<V, R> {\n    (props: CVReturnProps<V, R>): string;\n}\n\nexport interface CV {\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        cvOptions?: CVOptions,\n    ): CVReturn<V, R>;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype CVComposeReturnProps<T extends (props?: any) => string> =\n    | WithClassProp<VariantProps<T>>\n    | (RequiredKeys<VariantProps<T>> extends never ? void : never);\nexport interface CVCompose {\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type, @typescript-eslint/no-explicit-any\n    <T extends ((props?: any) => string)[]>(\n        ...components: T\n    ): (props: CVComposeReturnProps<T[number]>) => string;\n}\n\nexport function defineCV(options: CVOptions = {}) {\n    const cn = options.merge ?? clsx;\n\n    const cv: CV = (config) => {\n        const { base, variants, defaultVariants, requiredVariants } = config;\n\n        type ResolvedV = NonNullable<typeof variants>;\n\n        const utils = {\n            variants: variants ?? ({} as ResolvedV),\n            variantKeys: variants ? getKeys(variants) : [],\n            variantMap: variants ? getVariantsOptions(variants) : ({} as VariantMap<ResolvedV>),\n            defaultVariants: defaultVariants ?? ({} as CVVariant<ResolvedV>),\n            requiredVariants: requiredVariants ?? ({} as Record<keyof ResolvedV, boolean>),\n        };\n\n        const compoundVariants = variants\n            ? typeof config.compoundVariants === \"function\"\n                ? config.compoundVariants(utils)\n                : config.compoundVariants\n            : undefined;\n\n        const getVariant = <V extends ResolvedV, R extends keyof V = never>(\n            props: CVReturnProps<V, R>,\n        ) => {\n            const variantClassNames = variants\n                ? utils.variantKeys.map((variant) => {\n                      const variantProp = props?.[variant];\n                      const defaults = defaultVariants?.[variant];\n\n                      const variantKey = variantProp?.toString() || defaults?.toString();\n\n                      return variantKey ? variants[variant][variantKey] : undefined;\n                  })\n                : undefined;\n\n            const compoundVariantClassNames = compoundVariants?.reduce(\n                (acc, { class: cvClass, className: cvClassName, ...cvConfig }) => {\n                    const shouldApplyCompoundVariant = getEntries(cvConfig).every(\n                        ([cvKey, cvSelector]) => {\n                            const defaultsSelector =\n                                defaultVariants?.[cvKey as keyof typeof defaultVariants];\n                            const propsSelector = props?.[cvKey as keyof typeof props];\n\n                            if (typeof cvSelector === \"object\" && \"__token\" in cvSelector) {\n                                if (cvSelector.__token === onlyWhenDefined.__token) {\n                                    return propsSelector !== undefined;\n                                } else if (cvSelector.__token === onlyWhenUndefined.__token) {\n                                    return propsSelector === undefined;\n                                }\n                            }\n\n                            const selector = propsSelector ?? defaultsSelector;\n\n                            return Array.isArray(cvSelector)\n                                ? cvSelector.some((cvSelector) => selector === cvSelector)\n                                : selector === cvSelector;\n                        },\n                    );\n\n                    if (shouldApplyCompoundVariant) acc.push(cvClass, cvClassName);\n                    return acc;\n                },\n                new Array<ClassValue>(),\n            );\n\n            return cn(\n                base,\n                variantClassNames,\n                compoundVariantClassNames,\n                props?.class,\n                props?.className,\n            );\n        };\n\n        return Object.assign(getVariant, utils);\n    };\n\n    const compose: CVCompose =\n        (...components) =>\n        (props) => {\n            const propsWithoutClass = { ...props, class: undefined, className: undefined };\n\n            return cn(\n                components.map((component) => component(propsWithoutClass)),\n                props?.class,\n                props?.className,\n            );\n        };\n\n    return { cn, cv, compose };\n}\n\nexport const { cn, cv, compose } = defineCV();\n\ntype OnlyWhenDefined = Opaque<{ __token: string }, \"OnlyWhenDefined\">;\ntype OnlyWhenUndefined = Opaque<{ __token: string }, \"OnlyWhenUndefined\">;\n\ntype CVToken = OnlyWhenDefined | OnlyWhenUndefined;\n\n/** Apply compound variant only if prop **is** specified */\nexport const onlyWhenDefined = { __token: \"OnlyWhenDefined\" } as OnlyWhenDefined;\n/** Apply compound variant only if prop **is not** specified */\nexport const onlyWhenUndefined = { __token: \"OnlyWhenUndefined\" } as OnlyWhenUndefined;\n"],"mappings":"sDAAA,OAAqB,QAAAA,MAAY,OA8F1B,SAASC,EAASC,EAAqB,CAAC,EAAG,CAC9C,IAAMC,EAAKD,EAAQ,OAASE,EAyF5B,MAAO,CAAE,GAAAD,EAAI,GAvFGE,GAAW,CACvB,GAAM,CAAE,KAAAC,EAAM,SAAAC,EAAU,gBAAAC,EAAiB,iBAAAC,CAAiB,EAAIJ,EAIxDK,EAAQ,CACV,SAAUH,GAAa,CAAC,EACxB,YAAaA,EAAWI,EAAQJ,CAAQ,EAAI,CAAC,EAC7C,WAAYA,EAAWK,EAAmBL,CAAQ,EAAK,CAAC,EACxD,gBAAiBC,GAAoB,CAAC,EACtC,iBAAkBC,GAAqB,CAAC,CAC5C,EAEMI,EAAmBN,EACnB,OAAOF,EAAO,kBAAqB,WAC/BA,EAAO,iBAAiBK,CAAK,EAC7BL,EAAO,iBACX,OAuDN,OAAO,OAAO,OApDVS,GACC,CACD,IAAMC,EAAoBR,EACpBG,EAAM,YAAY,IAAKM,GAAY,CAC/B,IAAMC,EAAcH,IAAQE,CAAO,EAC7BE,EAAWV,IAAkBQ,CAAO,EAEpCG,EAAaF,GAAa,SAAS,GAAKC,GAAU,SAAS,EAEjE,OAAOC,EAAaZ,EAASS,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,EACFpB,IAAkBkB,CAAqC,EACrDG,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,EACHG,EACAS,EACAK,EACAN,GAAO,MACPA,GAAO,SACX,CACJ,EAEiCJ,CAAK,CAC1C,EAciB,QAXb,IAAIuB,IACHnB,GAAU,CACP,IAAMoB,EAAoB,CAAE,GAAGpB,EAAO,MAAO,OAAW,UAAW,MAAU,EAE7E,OAAOX,EACH8B,EAAW,IAAKE,GAAcA,EAAUD,CAAiB,CAAC,EAC1DpB,GAAO,MACPA,GAAO,SACX,CACJ,CAEqB,CAC7B,CAEO,GAAM,CAAE,GAAAX,EAAI,GAAAiC,EAAI,QAAAC,CAAQ,EAAIpC,EAAS,EAQ/B6B,EAAkB,CAAE,QAAS,iBAAkB,EAE/CC,EAAoB,CAAE,QAAS,mBAAoB","names":["clsx","defineCV","options","cn","clsx","config","base","variants","defaultVariants","requiredVariants","utils","getKeys","getVariantsOptions","compoundVariants","props","variantClassNames","variant","variantProp","defaults","variantKey","compoundVariantClassNames","acc","cvClass","cvClassName","cvConfig","getEntries","cvKey","cvSelector","defaultsSelector","propsSelector","onlyWhenDefined","onlyWhenUndefined","selector","components","propsWithoutClass","component","cv","compose"]}

package/build/index-w3SZ98rX.d.cts

@@ -1,87 +0,0 @@
-import { ClassValue } from 'clsx';
-import { DeepReadonly, Prettify, UnionToIntersection, DeepWritable, Opaque, MarkRequired, RequiredKeys } 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] ? Record<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 ClassProp = {
-    class?: ClassValue;
-    className?: never;
-} | {
-    class?: never;
-    className?: ClassValue;
-};
-type WithClassProp<T extends object> = T & ClassProp;
-type VariantProps<CVR extends (props?: any) => string> = Prettify<Omit<UnionToIntersection<Exclude<Parameters<CVR>[0], void | null | undefined>>, "class" | "className">>;
-type BooleanStringToBoolean<T> = T extends "true" | "false" ? boolean : T;
-type CVVariantsSchema = Record<string, Record<string | number, 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: CVUtils<V, R>) => CVCompoundVariantsSchema<V>);
-    defaultVariants?: CVVariant<V>;
-    requiredVariants?: Record<R, boolean>;
-}
-interface CVOptions {
-    merge?: (...args: ClassValue[]) => string;
-}
-type CVReturnProps<V extends CVVariantsSchema, R extends keyof V = never> = WithClassProp<MarkRequired<CVVariant<V>, R>> | ([R] extends [never] ? void : never);
-interface CVUtils<V extends CVVariantsSchema, R extends keyof V = never> {
-    variants: V;
-    variantKeys: KeysOf<V>;
-    variantMap: VariantOptions<V>;
-    defaultVariants: CVVariant<V>;
-    requiredVariants: Record<R, boolean>;
-}
-interface CVReturn<V extends CVVariantsSchema, R extends keyof V = never> extends CVUtils<V, R> {
-    (props: CVReturnProps<V, R>): string;
-}
-interface CV {
-    <V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>, cvOptions?: CVOptions): CVReturn<V, R>;
-}
-type CVComposeReturnProps<T extends (props?: any) => string> = WithClassProp<VariantProps<T>> | (RequiredKeys<VariantProps<T>> extends never ? void : never);
-interface CVCompose {
-    <T extends ((props?: any) => string)[]>(...components: T): (props: CVComposeReturnProps<T[number]>) => string;
-}
-declare function defineCV(options?: CVOptions): {
-    cn: (...args: ClassValue[]) => string;
-    cv: CV;
-    compose: CVCompose;
-};
-declare const cn: (...args: ClassValue[]) => string;
-declare const cv: CV;
-declare const compose: CVCompose;
-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 CVUtils as k, type CV as l, type CVCompose as m, defineCV as n, objectFromEntries as o, cn as p, cv as q, compose as r, onlyWhenDefined as s, onlyWhenUndefined as t };

package/build/index-w3SZ98rX.d.ts

@@ -1,87 +0,0 @@
-import { ClassValue } from 'clsx';
-import { DeepReadonly, Prettify, UnionToIntersection, DeepWritable, Opaque, MarkRequired, RequiredKeys } 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] ? Record<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 ClassProp = {
-    class?: ClassValue;
-    className?: never;
-} | {
-    class?: never;
-    className?: ClassValue;
-};
-type WithClassProp<T extends object> = T & ClassProp;
-type VariantProps<CVR extends (props?: any) => string> = Prettify<Omit<UnionToIntersection<Exclude<Parameters<CVR>[0], void | null | undefined>>, "class" | "className">>;
-type BooleanStringToBoolean<T> = T extends "true" | "false" ? boolean : T;
-type CVVariantsSchema = Record<string, Record<string | number, 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: CVUtils<V, R>) => CVCompoundVariantsSchema<V>);
-    defaultVariants?: CVVariant<V>;
-    requiredVariants?: Record<R, boolean>;
-}
-interface CVOptions {
-    merge?: (...args: ClassValue[]) => string;
-}
-type CVReturnProps<V extends CVVariantsSchema, R extends keyof V = never> = WithClassProp<MarkRequired<CVVariant<V>, R>> | ([R] extends [never] ? void : never);
-interface CVUtils<V extends CVVariantsSchema, R extends keyof V = never> {
-    variants: V;
-    variantKeys: KeysOf<V>;
-    variantMap: VariantOptions<V>;
-    defaultVariants: CVVariant<V>;
-    requiredVariants: Record<R, boolean>;
-}
-interface CVReturn<V extends CVVariantsSchema, R extends keyof V = never> extends CVUtils<V, R> {
-    (props: CVReturnProps<V, R>): string;
-}
-interface CV {
-    <V extends CVVariantsSchema, R extends keyof V = never>(config: CVConfig<V, R>, cvOptions?: CVOptions): CVReturn<V, R>;
-}
-type CVComposeReturnProps<T extends (props?: any) => string> = WithClassProp<VariantProps<T>> | (RequiredKeys<VariantProps<T>> extends never ? void : never);
-interface CVCompose {
-    <T extends ((props?: any) => string)[]>(...components: T): (props: CVComposeReturnProps<T[number]>) => string;
-}
-declare function defineCV(options?: CVOptions): {
-    cn: (...args: ClassValue[]) => string;
-    cv: CV;
-    compose: CVCompose;
-};
-declare const cn: (...args: ClassValue[]) => string;
-declare const cv: CV;
-declare const compose: CVCompose;
-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 CVUtils as k, type CV as l, type CVCompose as m, defineCV as n, objectFromEntries as o, cn as p, cv as q, compose as r, onlyWhenDefined as s, onlyWhenUndefined as t };