clava 0.1.16 → 0.1.17

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # clava
 
+## 0.1.17
+
+### Patch Changes
+
+- c2f1fa9: Added support for disabling inherited variants and variant values with `null`.
+
+  ```ts
+  const base = cv({
+    variants: { size: { sm: "sm", lg: "lg" } },
+    defaultVariants: { size: "sm" },
+  });
+
+  const button = cv({
+    extend: [base],
+    variants: { size: { sm: null } },
+  });
+
+  button({ size: "lg" }); // ✅
+  button({ size: "sm" }); // ❌ TypeScript error
+  ```
+
+  Disabled variants and values are excluded from `defaultVariants`, resolved variant props, and applied classes/styles.
+
+- a8cc18c: Added `Variant<T, K>` utility type for cross-component variant key constraints.
+- 4e54d51: Required an explicit `style` key for object-based variant/computed outputs.
+- 7e32a54: Reduced runtime overhead in `cv` hot paths.
+
+  This avoids repeated key-array allocations when merging style objects and when propagating override metadata to extended components. Behavior remains the same while reducing per-call work in frequently executed code paths, especially for components with many style merges or multiple `extend` entries.
+
 ## 0.1.16
 
 ### Patch Changes

package/dist/index.d.ts

@@ -20245,17 +20245,23 @@ type MergeExtendedVariants<T> = T extends readonly [infer First, ...infer Rest]
 type MergeExtendedComputedVariants<T> = T extends readonly [infer First, ...infer Rest] ? ExtractComputedVariants<First> & MergeExtendedComputedVariants<Rest> : {};
 type ExtractVariants<T> = T extends CVComponent<infer V, any, infer E, any> ? V & MergeExtendedVariants<E> : {};
 type ExtractComputedVariants<T> = T extends CVComponent<any, infer CV, infer E, any> ? CV & Omit<MergeExtendedComputedVariants<E>, keyof CV> : {};
-type MergeVariants<V, CV, E extends AnyComponent[]> = NoInfer<CV> & Omit<NoInfer<V>, keyof CV> & Omit<MergeExtendedVariants<E>, keyof CV> & Omit<MergeExtendedComputedVariants<E>, keyof CV>;
+type MergeVariantDefinition<Child, Parent> = Child extends Record<string, any> ? Parent extends Record<string, any> ? Omit<Parent, keyof Child> & Child : Child : Child;
+type MergeVariantMaps<Child, Parent> = { [K in keyof Child | keyof Parent]: K extends keyof Child ? K extends keyof Parent ? MergeVariantDefinition<Child[K], Parent[K]> : Child[K] : K extends keyof Parent ? Parent[K] : never };
+type MergeExtendedAllVariants<E extends AnyComponent[]> = MergeExtendedVariants<E> & MergeExtendedComputedVariants<E>;
+type MergeBaseVariants<V, E extends AnyComponent[]> = MergeVariantMaps<NoInfer<V>, MergeExtendedAllVariants<E>>;
+type MergeVariants<V, CV, E extends AnyComponent[]> = NoInfer<CV> & Omit<MergeBaseVariants<V, E>, keyof CV>;
 type StringToBoolean<T> = T extends "true" | "false" ? boolean : T;
 type VariantValue = ClassValue | StyleClassValue;
-type ExtractVariantValue<T> = T extends ((value: infer V) => any) ? V : T extends ClassValue ? boolean : T extends Record<infer K, any> ? StringToBoolean<K> : never;
+type NonNullKeys<T> = { [K in keyof T]: T[K] extends null ? never : K }[keyof T];
+type ExtractVariantValue<T> = T extends null ? never : T extends ((value: infer V) => any) ? V : T extends Record<string, any> ? StringToBoolean<NonNullKeys<T>> : T extends ClassValue ? boolean : never;
 type VariantValues<V> = { [K in keyof V]?: ExtractVariantValue<V[K]> };
 type StyleValue = Properties & {
   [key: `--${string}`]: string;
 };
-type StyleClassValue = StyleValue & {
+interface StyleClassValue {
+  style?: StyleValue;
   class?: ClassValue;
-};
+}
 interface ComputedContext<V> {
   variants: VariantValues<V>;
   setVariants: (variants: VariantValues<V>) => void;
@@ -20266,10 +20272,11 @@ interface ComputedContext<V> {
 type Computed<V> = (context: ComputedContext<V>) => VariantValue;
 type ComputedVariant = (value: any) => VariantValue;
 type ComputedVariants = Record<string, ComputedVariant>;
-type Variant = ClassValue | Record<string, VariantValue>;
-type Variants = Record<string, Variant>;
+type Variant$1 = ClassValue | Record<string, VariantValue>;
+type Variants = Record<string, Variant$1>;
 type ExtendedVariants<E extends AnyComponent[]> = MergeExtendedVariants<E> & MergeExtendedComputedVariants<E>;
-type ExtendableVariants<V extends Variants, E extends AnyComponent[]> = V & { [K in keyof ExtendedVariants<E>]?: Partial<ExtendedVariants<E>[K]> | Variant };
+type NullablePartial<T> = T extends Record<string, any> ? { [K in keyof T]?: T[K] | null } : T | null;
+type ExtendableVariants<V extends Variants, E extends AnyComponent[]> = V & { [K in keyof ExtendedVariants<E>]?: NullablePartial<ExtendedVariants<E>[K]> | Variant$1 };
 //#endregion
 //#region src/utils.d.ts
 declare const MODES: readonly ["jsx", "html", "htmlObj"];
@@ -20277,6 +20284,8 @@ type Mode = (typeof MODES)[number];
 //#endregion
 //#region src/index.d.ts
 type VariantProps<T extends Pick<AnyComponent, "getVariants">> = ReturnType<T["getVariants"]>;
+type VariantKey<T> = T extends boolean ? "true" | "false" : Extract<T, string>;
+type Variant<T extends Pick<AnyComponent, "getVariants">, K extends keyof VariantProps<T>> = Record<VariantKey<NonNullable<VariantProps<T>[K]>>, ClassValue | StyleClassValue>;
 interface CVConfig<V extends Variants = {}, CV extends ComputedVariants = {}, E extends AnyComponent[] = []> {
   extend?: E;
   class?: ClassValue;
@@ -20321,5 +20330,5 @@ declare function create<M extends Mode = "jsx">({
 };
 declare const cv: <V extends Variants = {}, CV extends ComputedVariants = {}, const E extends AnyComponent[] = []>(config?: CVConfig<V, CV, E>) => CVComponent<V, CV, E, JSXProps>, cx: (...classes: ClassValue$1[]) => string;
 //#endregion
-export { type CVComponent, CVConfig, type ClassValue, type HTMLObjProps, type HTMLProps, type JSXProps, type StyleClassValue, type StyleValue, VariantProps, create, cv, cx, splitProps };
+export { type CVComponent, CVConfig, type ClassValue, type HTMLObjProps, type HTMLProps, type JSXProps, type StyleClassValue, type StyleValue, Variant, VariantProps, create, cv, cx, splitProps };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -12,7 +12,6 @@ function clsx() {
 	for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
 	return n;
 }
-var clsx_default = clsx;
 
 //#endregion
 //#region src/utils.ts
@@ -159,6 +158,7 @@ function isHTMLObjStyle(style) {
 //#region src/index.ts
 const META_KEY = "__meta";
 const SKIP_STYLE_KEYS = Symbol("skipStyleKeys");
+const SKIP_STYLE_VARIANT_VALUES = Symbol("skipStyleVariantValues");
 function getComponentMeta(component) {
 	return component[META_KEY];
 }
@@ -170,19 +170,25 @@ function setComponentMeta(component, meta) {
 * overhead in hot paths where we're building up a result object.
 */
 function assign(target, source) {
-	for (const key of Object.keys(source)) target[key] = source[key];
+	for (const key in source) {
+		if (!Object.prototype.hasOwnProperty.call(source, key)) continue;
+		target[key] = source[key];
+	}
 }
-/**
-* Checks if a value is a style-class object (has style properties, not just a
-* class value).
-*/
-function isStyleClassValue(value) {
+function isRecordObject(value) {
 	if (typeof value !== "object") return false;
 	if (value == null) return false;
 	if (Array.isArray(value)) return false;
 	return true;
 }
 /**
+* Checks if a value is a style-class object (`{ style, class? }`).
+*/
+function isStyleClassValue(value) {
+	if (!isRecordObject(value)) return false;
+	return "style" in value || "class" in value;
+}
+/**
 * Converts any style input (string, JSX object, or HTML object) to a normalized
 * StyleValue.
 */
@@ -198,10 +204,9 @@ function normalizeStyle(style) {
 * Extracts class and style from a style-class value object.
 */
 function extractStyleClass(value) {
-	const { class: cls, ...style } = value;
 	return {
-		class: cls,
-		style
+		class: value.class,
+		style: normalizeStyle(value.style)
 	};
 }
 /**
@@ -210,6 +215,10 @@ function extractStyleClass(value) {
 */
 function extractClassAndStyle(value) {
 	if (isStyleClassValue(value)) return extractStyleClass(value);
+	if (isRecordObject(value)) return {
+		class: null,
+		style: {}
+	};
 	return {
 		class: value,
 		style: {}
@@ -222,10 +231,68 @@ function extractClassAndStyle(value) {
 function collectVariantKeys(config) {
 	const keys = /* @__PURE__ */ new Set();
 	if (config.extend) for (const ext of config.extend) for (const key of ext.variantKeys) keys.add(key);
-	if (config.variants) for (const key of Object.keys(config.variants)) keys.add(key);
+	if (config.variants) for (const [key, variant] of Object.entries(config.variants)) {
+		if (variant === null) {
+			keys.delete(key);
+			continue;
+		}
+		keys.add(key);
+	}
 	if (config.computedVariants) for (const key of Object.keys(config.computedVariants)) keys.add(key);
 	return Array.from(keys);
 }
+function isVariantDisabled(config, key) {
+	return config.variants?.[key] === null;
+}
+function getVariantValueKey(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number") return String(value);
+	if (typeof value === "boolean") return String(value);
+}
+function isVariantValueDisabled(config, key, value) {
+	const valueKey = getVariantValueKey(value);
+	if (valueKey == null) return false;
+	const variant = config.variants?.[key];
+	if (!isRecordObject(variant)) return false;
+	return variant[valueKey] === null;
+}
+function filterDisabledVariants(config, variants) {
+	const filtered = {};
+	for (const [key, value] of Object.entries(variants)) {
+		if (isVariantDisabled(config, key)) continue;
+		if (isVariantValueDisabled(config, key, value)) continue;
+		filtered[key] = value;
+	}
+	return filtered;
+}
+function collectDisabledVariantKeys(config) {
+	const keys = /* @__PURE__ */ new Set();
+	if (!config.variants) return keys;
+	for (const [key, value] of Object.entries(config.variants)) if (value === null) keys.add(key);
+	return keys;
+}
+function collectDisabledVariantValues(config) {
+	const values = {};
+	if (!config.variants) return values;
+	for (const [key, variant] of Object.entries(config.variants)) {
+		if (!isRecordObject(variant)) continue;
+		for (const [variantValue, variantEntry] of Object.entries(variant)) {
+			if (variantEntry !== null) continue;
+			if (!values[key]) values[key] = /* @__PURE__ */ new Set();
+			values[key].add(variantValue);
+		}
+	}
+	return values;
+}
+function mergeDisabledVariantValues(base, override) {
+	const merged = {};
+	for (const [key, values] of Object.entries(base)) merged[key] = new Set(values);
+	for (const [key, values] of Object.entries(override)) {
+		if (!merged[key]) merged[key] = /* @__PURE__ */ new Set();
+		for (const value of values) merged[key].add(value);
+	}
+	return merged;
+}
 /**
 * Collects static default variants from extended components and the current
 * config. Also handles implicit boolean defaults (when only `false` key
@@ -239,11 +306,11 @@ function collectStaticDefaults(config) {
 		if (meta) Object.assign(defaults, meta.staticDefaults);
 	}
 	if (config.variants) for (const [variantName, variantDef] of Object.entries(config.variants)) {
-		if (!isStyleClassValue(variantDef)) continue;
+		if (!isRecordObject(variantDef)) continue;
 		if (Object.keys(variantDef).includes("false") && !defaults[variantName]) defaults[variantName] = false;
 	}
 	if (config.defaultVariants) Object.assign(defaults, config.defaultVariants);
-	return defaults;
+	return filterDisabledVariants(config, defaults);
 }
 /**
 * Collects default variants from extended components and the current config.
@@ -259,7 +326,7 @@ function collectDefaultVariants(config, propsVariants = {}) {
 		if (!meta) continue;
 		Object.assign(defaults, meta.resolveDefaults(defaults, propsVariants));
 	}
-	return defaults;
+	return filterDisabledVariants(config, defaults);
 }
 /**
 * Filters out keys with undefined values from an object.
@@ -277,17 +344,17 @@ function filterUndefined(obj) {
 * undefined values are filtered out so they don't override defaults.
 */
 function resolveVariants(config, props = {}) {
-	return {
+	return filterDisabledVariants(config, {
 		...collectDefaultVariants(config, props),
 		...filterUndefined(props)
-	};
+	});
 }
 /**
 * Gets the value for a single variant based on the variant definition and the
 * selected value.
 */
 function getVariantResult(variantDef, selectedValue) {
-	if (!isStyleClassValue(variantDef)) {
+	if (!isRecordObject(variantDef)) {
 		if (selectedValue === true) return extractClassAndStyle(variantDef);
 		return {
 			class: null,
@@ -313,7 +380,7 @@ function extractVariantClasses(fullClass, baseClass) {
 	const baseClassSet = new Set(baseClass.split(" ").filter(Boolean));
 	return fullClass.split(" ").filter((c) => c && !baseClassSet.has(c)).join(" ");
 }
-function computeExtendedStyles(config, resolvedVariants, overrideVariantKeys = /* @__PURE__ */ new Set()) {
+function computeExtendedStyles(config, resolvedVariants, overrideVariantKeys = /* @__PURE__ */ new Set(), overrideVariantValues = {}) {
 	const baseClasses = [];
 	const variantClasses = [];
 	const style = {};
@@ -322,9 +389,12 @@ function computeExtendedStyles(config, resolvedVariants, overrideVariantKeys = /
 		variantClasses,
 		style
 	};
+	const hasOverrideVariantKeys = overrideVariantKeys.size > 0;
+	const hasOverrideVariantValues = Object.keys(overrideVariantValues).length > 0;
 	for (const ext of config.extend) {
 		const propsForExt = { ...resolvedVariants };
-		if (overrideVariantKeys.size > 0) propsForExt[SKIP_STYLE_KEYS] = overrideVariantKeys;
+		if (hasOverrideVariantKeys) propsForExt[SKIP_STYLE_KEYS] = overrideVariantKeys;
+		if (hasOverrideVariantValues) propsForExt[SKIP_STYLE_VARIANT_VALUES] = overrideVariantValues;
 		const extResult = ext(propsForExt);
 		assign(style, normalizeStyle(extResult.style));
 		const baseClass = getComponentMeta(ext)?.baseClass ?? "";
@@ -342,13 +412,15 @@ function computeExtendedStyles(config, resolvedVariants, overrideVariantKeys = /
 * Computes class and style from the component's own variants and
 * computedVariants (not extended components).
 */
-function computeVariantStyles(config, resolvedVariants, skipStyleKeys = /* @__PURE__ */ new Set()) {
+function computeVariantStyles(config, resolvedVariants, skipStyleKeys = /* @__PURE__ */ new Set(), skipVariantValues = {}) {
 	const classes = [];
 	const style = {};
 	if (config.variants) for (const [variantName, variantDef] of Object.entries(config.variants)) {
 		if (skipStyleKeys.has(variantName)) continue;
 		const selectedValue = resolvedVariants[variantName];
 		if (selectedValue === void 0) continue;
+		const selectedKey = getVariantValueKey(selectedValue);
+		if (selectedKey && skipVariantValues[variantName]?.has(selectedKey)) continue;
 		const result = getVariantResult(variantDef, selectedValue);
 		classes.push(result.class);
 		assign(style, result.style);
@@ -357,6 +429,8 @@ function computeVariantStyles(config, resolvedVariants, skipStyleKeys = /* @__PU
 		if (skipStyleKeys.has(variantName)) continue;
 		const selectedValue = resolvedVariants[variantName];
 		if (selectedValue === void 0) continue;
+		const selectedKey = getVariantValueKey(selectedValue);
+		if (selectedKey && skipVariantValues[variantName]?.has(selectedKey)) continue;
 		const result = extractClassAndStyle(computeFn(selectedValue));
 		classes.push(result.class);
 		assign(style, result.style);
@@ -382,10 +456,14 @@ function runComputedFunction(config, resolvedVariants, propsVariants) {
 	const context = {
 		variants: resolvedVariants,
 		setVariants: (newVariants) => {
-			Object.assign(updatedVariants, newVariants);
+			Object.assign(updatedVariants, filterDisabledVariants(config, newVariants));
 		},
 		setDefaultVariants: (newDefaults) => {
-			for (const [key, value] of Object.entries(newDefaults)) if (propsVariants[key] === void 0) updatedVariants[key] = value;
+			for (const [key, value] of Object.entries(newDefaults)) if (propsVariants[key] === void 0) {
+				if (isVariantDisabled(config, key)) continue;
+				if (isVariantValueDisabled(config, key, value)) continue;
+				updatedVariants[key] = value;
+			}
 		},
 		addClass: (className) => {
 			classes.push(className);
@@ -403,7 +481,7 @@ function runComputedFunction(config, resolvedVariants, propsVariants) {
 	return {
 		classes,
 		style,
-		updatedVariants
+		updatedVariants: filterDisabledVariants(config, updatedVariants)
 	};
 }
 const EMPTY_SOURCE = {
@@ -510,6 +588,8 @@ function createResolveDefaults(config) {
 			setDefaultVariants: (newDefaults) => {
 				for (const [key, value] of Object.entries(newDefaults)) {
 					if (userProps[key] !== void 0) continue;
+					if (isVariantDisabled(config, key)) continue;
+					if (isVariantValueDisabled(config, key, value)) continue;
 					computedDefaults[key] = value;
 				}
 			},
@@ -523,9 +603,11 @@ function createResolveDefaults(config) {
 * Creates the cv and cx functions.
 */
 function create({ defaultMode = "jsx", transformClass = (className) => className } = {}) {
-	const cx = (...classes) => transformClass(clsx_default(...classes));
+	const cx = (...classes) => transformClass(clsx(...classes));
 	const cv = (config = {}) => {
 		const variantKeys = collectVariantKeys(config);
+		const disabledVariantKeys = collectDisabledVariantKeys(config);
+		const disabledVariantValues = collectDisabledVariantValues(config);
 		const getPropsKeys = (mode) => [
 			getClassPropertyName(mode),
 			"style",
@@ -535,20 +617,24 @@ function create({ defaultMode = "jsx", transformClass = (className) => className
 			const allClasses = [];
 			const allStyle = {};
 			const skipStyleKeys = props[SKIP_STYLE_KEYS] ?? /* @__PURE__ */ new Set();
+			const skipStyleVariantValues = props[SKIP_STYLE_VARIANT_VALUES] ?? {};
 			const variantProps = {};
 			for (const key of variantKeys) if (key in props) variantProps[key] = props[key];
 			let resolvedVariants = resolveVariants(config, variantProps);
 			const computedResult = runComputedFunction(config, resolvedVariants, variantProps);
 			resolvedVariants = computedResult.updatedVariants;
-			const computedVariantKeys = new Set(skipStyleKeys);
+			const currentVariantKeys = new Set(skipStyleKeys);
+			for (const key of disabledVariantKeys) currentVariantKeys.add(key);
+			const computedVariantKeys = new Set(currentVariantKeys);
 			if (config.computedVariants) for (const key of Object.keys(config.computedVariants)) computedVariantKeys.add(key);
-			const extendedResult = computeExtendedStyles(config, resolvedVariants, computedVariantKeys);
+			const computedVariantValues = mergeDisabledVariantValues(skipStyleVariantValues, disabledVariantValues);
+			const extendedResult = computeExtendedStyles(config, resolvedVariants, computedVariantKeys, computedVariantValues);
 			allClasses.push(...extendedResult.baseClasses);
 			assign(allStyle, extendedResult.style);
 			allClasses.push(config.class);
 			if (config.style) assign(allStyle, config.style);
 			allClasses.push(...extendedResult.variantClasses);
-			const variantsResult = computeVariantStyles(config, resolvedVariants, skipStyleKeys);
+			const variantsResult = computeVariantStyles(config, resolvedVariants, currentVariantKeys, computedVariantValues);
 			allClasses.push(...variantsResult.classes);
 			assign(allStyle, variantsResult.style);
 			allClasses.push(...computedResult.classes);