@yahoo/uds 3.156.2 → 3.157.1

package/dist/automated-config/dist/utils/buildConfigSchema.js

@@ -1,10 +1,78 @@
 /*! © 2026 Yahoo, Inc. UDS v0.0.0-development */
-import { filterPseudoStatesByExclusion, getExcludedPseudoStatesForComponentStateOption } from "./componentStatePseudoStates.js";
+import { getExcludedPseudoStatesForComponentStateOption } from "./componentStatePseudoStates.js";
 import { generateSchemaKey } from "./generateSchemaKey.js";
+import { resolvePropertyStates } from "./resolvePropertyStates.js";
 import { isVariantConfigWithComponentStates, isVariantConfigWithProperties } from "./variantConfigGuards.js";
 import { getArbitraryFixture, validateArbitraryValue } from "../../../fixtures/src/util.js";
 //#region ../automated-config/dist/utils/buildConfigSchema.js
 /*! © 2026 Yahoo, Inc. UDS Default Config v0.0.0-development */
+/**
+* Builds the per-state schema entries for one property on one variant option.
+* Each state slot (rest, hover, invalid&hover, ...) gets the property's
+* default value as a starting point so the Configurator UI has something to
+* render before users tweak.
+*
+* Per-state CSS emission depends on the emit mode (`exhaustive` by default,
+* `selective` opt-in) and on the `isEnabled` flag this builder writes:
+*   - `rest` always emits in both modes (no flag needed; CSS gen treats rest
+*     as enabled).
+*   - Under EXHAUSTIVE (the default) on `atomicStates` layers, every declared
+*     non-rest state emits a rule regardless of `isEnabled`; its value is
+*     cascade-resolved (see `resolveSlotByCascade`), so there are no gaps.
+*     `isEnabled` there only selects which value a state resolves to, not
+*     whether it emits.
+*   - Under SELECTIVE (and legacy `pseudoStates`) emission, non-rest slots
+*     emit only when `isEnabled === true`.
+*   - `skipRestState` properties have no rest fallback, so every populated
+*     state slot must emit; we set `isEnabled: true` on each.
+*   - Otherwise, auto-populated non-rest slots ship with no flag — under
+*     selective they're off until a designer enables them via the
+*     configurator's per-property checkbox (which sets or clears this flag
+*     through the setter); under exhaustive they still emit via the cascade.
+*/
+function buildPropertyStateMap(layer, property, variantOption, excludedStates = []) {
+	const stateMap = {};
+	const excluded = new Set(excludedStates);
+	const states = resolvePropertyStates(layer, property);
+	const fixtureType = findFixtureType(property, variantOption);
+	const value = property.defaults[variantOption];
+	const skipRestState = property.skipRestState === true;
+	const isTextVariant = propertyVariesOnlyAtRest(property);
+	for (const state of states) {
+		if (excluded.has(state)) continue;
+		if (isTextVariant && state !== "rest") continue;
+		stateMap[state] = skipRestState ? {
+			type: fixtureType,
+			valueType: "alias",
+			value,
+			isEnabled: true
+		} : {
+			type: fixtureType,
+			valueType: "alias",
+			value
+		};
+	}
+	return stateMap;
+}
+/**
+* Whether a property's non-rest slots are stored SPARSELY — never pre-populated
+* by the schema builder, only persisted when a designer authors an explicit
+* per-state override (resolved via the cascade otherwise). `textVariant` is the
+* only such property today: its non-rest "Emphasized" overrides are created
+* lazily in the configurator rather than seeded for every state.
+*
+* Consulted by the schema builder ({@link buildPropertyStateMap}) to keep the
+* stored config compact. CSS emission does NOT special-case these properties:
+* exhaustive emission walks every declared state and resolves each through the
+* cascade (`resolveSlotByCascade`), so an authored non-rest override emits a
+* rule that renders while unauthored states resolve back to rest.
+*/
+function propertyVariesOnlyAtRest(property) {
+	return property.name === "textVariant";
+}
+function isOptionalInDefaultSchema(property) {
+	return property.optionalInDefaultSchema === true;
+}
 /** Resolves the fixture type by finding which value set contains the given value */
 function findFixtureTypeForValue(property, value) {
 	const index = property.values.findIndex((arr) => arr.includes(value));
@@ -17,13 +85,30 @@ function findFixtureTypeForValue(property, value) {
 function findFixtureType(property, variantKey) {
 	return findFixtureTypeForValue(property, property.defaults[variantKey]);
 }
-function appendPseudoStateVariables(variableObject, propertyKey, property, variantOption, excludedPseudoStates = []) {
-	if (!property.pseudoStates) return;
-	for (const pseudoState of filterPseudoStatesByExclusion(property.pseudoStates, excludedPseudoStates)) variableObject[propertyKey][pseudoState] = {
-		type: findFixtureType(property, variantOption),
-		valueType: "alias",
-		value: property.defaults[variantOption]
-	};
+/**
+* Walk a set of layers and emit schema entries keyed by layer (no
+* component-state segment). Shared between `VariantConfigWithProperties` and
+* the optional top-level `layers` field on `VariantConfigWithComponentStates`.
+*/
+function emitUniversalLayerSchema(result, layers, variantKey, variantOption, subComponentName) {
+	for (const layerKey in layers) {
+		const layer = layers[layerKey];
+		const schemaKey = generateSchemaKey({
+			variantKey,
+			variantValue: variantOption,
+			layer: layerKey,
+			subComponentName
+		});
+		result.variables[schemaKey] = {};
+		for (const propertyKey in layer.properties) {
+			const property = layer.properties[propertyKey];
+			if (isOptionalInDefaultSchema(property)) continue;
+			result.variables[schemaKey] = {
+				...result.variables[schemaKey],
+				[propertyKey]: buildPropertyStateMap(layer, property, variantOption)
+			};
+		}
+	}
 }
 /** Builds component schema from ComponentConfig at runtime */
 function buildConfigSchema(config) {
@@ -35,6 +120,7 @@ function buildConfigSchema(config) {
 	for (const variantKey in config.variants) {
 		const variantConfig = config.variants[variantKey];
 		for (const variantOption of variantConfig.options) if (isVariantConfigWithComponentStates(variantConfig)) {
+			if (variantConfig.layers) emitUniversalLayerSchema(result, variantConfig.layers, variantKey, variantOption);
 			const componentStates = variantConfig.componentStates;
 			for (const componentStateKey in componentStates) {
 				const componentState = componentStates[componentStateKey];
@@ -50,16 +136,10 @@ function buildConfigSchema(config) {
 					result.variables[schemaKey] = {};
 					for (const propertyKey in layer.properties) {
 						const property = layer.properties[propertyKey];
-						const variableObject = { [propertyKey]: {} };
-						if (property?.skipRestState !== true) variableObject[propertyKey] = { rest: {
-							type: findFixtureType(property, variantOption),
-							valueType: "alias",
-							value: property.defaults[variantOption]
-						} };
-						appendPseudoStateVariables(variableObject, propertyKey, property, variantOption, getExcludedPseudoStatesForComponentStateOption(componentState, componentStateOption));
+						if (isOptionalInDefaultSchema(property)) continue;
 						result.variables[schemaKey] = {
 							...result.variables[schemaKey],
-							...variableObject
+							[propertyKey]: buildPropertyStateMap(layer, property, variantOption, getExcludedPseudoStatesForComponentStateOption(componentState, componentStateOption))
 						};
 					}
 				}
@@ -70,43 +150,17 @@ function buildConfigSchema(config) {
 				result.variables[variantSchemaKey] = result.variables[variantSchemaKey] ?? {};
 				for (const propertyKey in variantConfig.variantProperties) {
 					const property = variantConfig.variantProperties[propertyKey];
-					const variableObject = { [propertyKey]: {} };
-					if (property?.skipRestState !== true) variableObject[propertyKey] = { rest: {
-						type: findFixtureType(property, variantOption),
-						valueType: "alias",
-						value: property.defaults[variantOption]
-					} };
-					appendPseudoStateVariables(variableObject, propertyKey, property, variantOption);
+					if (isOptionalInDefaultSchema(property)) continue;
 					result.variables[variantSchemaKey] = {
 						...result.variables[variantSchemaKey],
-						...variableObject
-					};
-				}
-			}
-			const layers = variantConfig.layers;
-			for (const layerKey in layers) {
-				const layer = layers[layerKey];
-				const schemaKey = generateSchemaKey({
-					variantKey,
-					variantValue: variantOption,
-					layer: layerKey
-				});
-				result.variables[schemaKey] = {};
-				for (const propertyKey in layer.properties) {
-					const property = layer.properties[propertyKey];
-					const variableObject = { [propertyKey]: {} };
-					if (property?.skipRestState !== true) variableObject[propertyKey] = { rest: {
-						type: findFixtureType(property, variantOption),
-						valueType: "alias",
-						value: property.defaults[variantOption]
-					} };
-					appendPseudoStateVariables(variableObject, propertyKey, property, variantOption);
-					result.variables[schemaKey] = {
-						...result.variables[schemaKey],
-						...variableObject
+						[propertyKey]: buildPropertyStateMap({
+							label: "",
+							properties: {}
+						}, property, variantOption)
 					};
 				}
 			}
+			emitUniversalLayerSchema(result, variantConfig.layers, variantKey, variantOption);
 		}
 	}
 	if (config.subComponents) {
@@ -115,6 +169,7 @@ function buildConfigSchema(config) {
 			const variantConfig = subComponents[subComponentKey].variants[variantKey];
 			result.defaults[variantKey] = variantConfig.default;
 			for (const variantOption of variantConfig.options) if (isVariantConfigWithComponentStates(variantConfig)) {
+				if (variantConfig.layers) emitUniversalLayerSchema(result, variantConfig.layers, variantKey, variantOption, subComponentKey);
 				const componentStates = variantConfig.componentStates;
 				for (const componentStateKey in componentStates) {
 					const componentState = componentStates[componentStateKey];
@@ -131,47 +186,15 @@ function buildConfigSchema(config) {
 						result.variables[schemaKey] = {};
 						for (const propertyKey in layer.properties) {
 							const property = layer.properties[propertyKey];
-							const variableObject = { [propertyKey]: {} };
-							if (property?.skipRestState !== true) variableObject[propertyKey] = { rest: {
-								type: findFixtureType(property, variantOption),
-								valueType: "alias",
-								value: property.defaults[variantOption]
-							} };
-							appendPseudoStateVariables(variableObject, propertyKey, property, variantOption, getExcludedPseudoStatesForComponentStateOption(componentState, componentStateOption));
+							if (isOptionalInDefaultSchema(property)) continue;
 							result.variables[schemaKey] = {
 								...result.variables[schemaKey],
-								...variableObject
+								[propertyKey]: buildPropertyStateMap(layer, property, variantOption, getExcludedPseudoStatesForComponentStateOption(componentState, componentStateOption))
 							};
 						}
 					}
 				}
-			} else if (isVariantConfigWithProperties(variantConfig)) {
-				const layers = variantConfig.layers;
-				for (const layerKey in layers) {
-					const layer = layers[layerKey];
-					const schemaKey = generateSchemaKey({
-						variantKey,
-						variantValue: variantOption,
-						layer: layerKey,
-						subComponentName: subComponentKey
-					});
-					result.variables[schemaKey] = {};
-					for (const propertyKey in layer.properties) {
-						const property = layer.properties[propertyKey];
-						const variableObject = { [propertyKey]: {} };
-						if (property?.skipRestState !== true) variableObject[propertyKey] = { rest: {
-							type: findFixtureType(property, variantOption),
-							valueType: "alias",
-							value: property.defaults[variantOption]
-						} };
-						appendPseudoStateVariables(variableObject, propertyKey, property, variantOption);
-						result.variables[schemaKey] = {
-							...result.variables[schemaKey],
-							...variableObject
-						};
-					}
-				}
-			}
+			} else if (isVariantConfigWithProperties(variantConfig)) emitUniversalLayerSchema(result, variantConfig.layers, variantKey, variantOption, subComponentKey);
 		}
 	}
 	return result;

package/dist/automated-config/dist/utils/canonicalizeStateKey.cjs

@@ -0,0 +1,32 @@
+/*! © 2026 Yahoo, Inc. UDS v0.0.0-development */
+const require_StateAxis = require("../types/StateAxis.cjs");
+//#region ../automated-config/dist/utils/canonicalizeStateKey.js
+/*! © 2026 Yahoo, Inc. UDS Default Config v0.0.0-development */
+function canonicalizeStateKey(atoms) {
+	if (atoms.length === 0) return "rest";
+	const seen = /* @__PURE__ */ new Set();
+	const modifiers = [];
+	const interactives = [];
+	for (const atom of atoms) {
+		if (seen.has(atom)) continue;
+		seen.add(atom);
+		if (require_StateAxis.isModifierAtomic(atom)) modifiers.push(atom);
+		else if (require_StateAxis.isInteractiveAtomic(atom)) interactives.push(atom);
+		else throw new Error(`canonicalizeStateKey received an unrecognized atom "${atom}". Atoms must be in MODIFIER_ATOMICS or INTERACTIVE_ATOMICS — see StateAxis.`);
+	}
+	modifiers.sort(require_StateAxis.comparePriority);
+	interactives.sort(require_StateAxis.comparePriority);
+	const ordered = [...modifiers, ...interactives];
+	return ordered.length === 0 ? "rest" : ordered.join("&");
+}
+/**
+* Splits a canonical (or legacy) state key into its atomic parts.
+* `'rest'` and `''` produce an empty array.
+*/
+function splitStateKey(stateKey) {
+	if (!stateKey || stateKey === "rest") return [];
+	return stateKey.split("&");
+}
+//#endregion
+exports.canonicalizeStateKey = canonicalizeStateKey;
+exports.splitStateKey = splitStateKey;

package/dist/automated-config/dist/utils/canonicalizeStateKey.d.cts

@@ -0,0 +1,48 @@
+
+import { AtomicState } from "../types/StateAxis.cjs";
+import { PossibleStatesWithRest } from "../types/ComponentConfig.cjs";
+
+//#region ../automated-config/dist/utils/canonicalizeStateKey.d.ts
+//#region src/utils/canonicalizeStateKey.d.ts
+/**
+ * Returns the canonical state-key string for a list of atomic states.
+ *
+ * Canonical ordering rules:
+ * 1. Modifier atomics come first, sorted by `STATE_PRIORITY` (weakest first).
+ * 2. Interactive atomics come last, also sorted by `STATE_PRIORITY`. Multiple
+ *    interactives can co-occur (e.g. `focus-within` + `hover`), so a key may
+ *    carry more than one.
+ *    Sorting by priority — not alphabetically — keeps a key's atom order aligned
+ *    with the emission/cascade order in `resolvePropertyStates` and
+ *    `resolveSlotByCascade`, so one ordering convention holds end-to-end. (For
+ *    Input the two orders coincide; they diverge only for atoms like `visited`,
+ *    `autofill`, or `focus-visible` whose priority rank differs from their
+ *    alphabetical position.)
+ * 3. Duplicates are removed.
+ * 4. Unknown atoms throw. Every caller passes atoms already validated via
+ *    `isModifierAtomic`/`isInteractiveAtomic` (or pulled from
+ *    `MODIFIER_ATOMICS`/`INTERACTIVE_ATOMICS`), so an unrecognized atom signals
+ *    a caller bug and fails loudly rather than producing a silent bad key.
+ *
+ * Examples:
+ *   canonicalizeStateKey(['hover', 'invalid'])   // 'invalid&hover'
+ *   canonicalizeStateKey(['invalid', 'hover'])   // 'invalid&hover' (same)
+ *   canonicalizeStateKey(['hover'])              // 'hover'
+ *   canonicalizeStateKey([])                     // 'rest'
+ *
+ * The narrow public overload returns `PossibleStatesWithRest` so callers
+ * passing known atomics get a usable state-key type back without having to
+ * cast the result at the call site. The looser overload remains for callers
+ * that may pass unvalidated strings; its return is widened to `string` since
+ * those inputs can't guarantee a canonical-key result. The runtime body
+ * type-checks against the loose overload and validates atoms at runtime.
+ */
+declare function canonicalizeStateKey(atoms: readonly AtomicState[]): PossibleStatesWithRest;
+declare function canonicalizeStateKey(atoms: readonly string[]): string;
+/**
+ * Splits a canonical (or legacy) state key into its atomic parts.
+ * `'rest'` and `''` produce an empty array.
+ */
+declare function splitStateKey(stateKey: string): string[]; //#endregion
+//#endregion
+export { canonicalizeStateKey, splitStateKey };

package/dist/automated-config/dist/utils/canonicalizeStateKey.d.ts

@@ -0,0 +1,48 @@
+
+import { AtomicState } from "../types/StateAxis.js";
+import { PossibleStatesWithRest } from "../types/ComponentConfig.js";
+
+//#region ../automated-config/dist/utils/canonicalizeStateKey.d.ts
+//#region src/utils/canonicalizeStateKey.d.ts
+/**
+ * Returns the canonical state-key string for a list of atomic states.
+ *
+ * Canonical ordering rules:
+ * 1. Modifier atomics come first, sorted by `STATE_PRIORITY` (weakest first).
+ * 2. Interactive atomics come last, also sorted by `STATE_PRIORITY`. Multiple
+ *    interactives can co-occur (e.g. `focus-within` + `hover`), so a key may
+ *    carry more than one.
+ *    Sorting by priority — not alphabetically — keeps a key's atom order aligned
+ *    with the emission/cascade order in `resolvePropertyStates` and
+ *    `resolveSlotByCascade`, so one ordering convention holds end-to-end. (For
+ *    Input the two orders coincide; they diverge only for atoms like `visited`,
+ *    `autofill`, or `focus-visible` whose priority rank differs from their
+ *    alphabetical position.)
+ * 3. Duplicates are removed.
+ * 4. Unknown atoms throw. Every caller passes atoms already validated via
+ *    `isModifierAtomic`/`isInteractiveAtomic` (or pulled from
+ *    `MODIFIER_ATOMICS`/`INTERACTIVE_ATOMICS`), so an unrecognized atom signals
+ *    a caller bug and fails loudly rather than producing a silent bad key.
+ *
+ * Examples:
+ *   canonicalizeStateKey(['hover', 'invalid'])   // 'invalid&hover'
+ *   canonicalizeStateKey(['invalid', 'hover'])   // 'invalid&hover' (same)
+ *   canonicalizeStateKey(['hover'])              // 'hover'
+ *   canonicalizeStateKey([])                     // 'rest'
+ *
+ * The narrow public overload returns `PossibleStatesWithRest` so callers
+ * passing known atomics get a usable state-key type back without having to
+ * cast the result at the call site. The looser overload remains for callers
+ * that may pass unvalidated strings; its return is widened to `string` since
+ * those inputs can't guarantee a canonical-key result. The runtime body
+ * type-checks against the loose overload and validates atoms at runtime.
+ */
+declare function canonicalizeStateKey(atoms: readonly AtomicState[]): PossibleStatesWithRest;
+declare function canonicalizeStateKey(atoms: readonly string[]): string;
+/**
+ * Splits a canonical (or legacy) state key into its atomic parts.
+ * `'rest'` and `''` produce an empty array.
+ */
+declare function splitStateKey(stateKey: string): string[]; //#endregion
+//#endregion
+export { canonicalizeStateKey, splitStateKey };

package/dist/automated-config/dist/utils/canonicalizeStateKey.js

@@ -0,0 +1,31 @@
+/*! © 2026 Yahoo, Inc. UDS v0.0.0-development */
+import { comparePriority, isInteractiveAtomic, isModifierAtomic } from "../types/StateAxis.js";
+//#region ../automated-config/dist/utils/canonicalizeStateKey.js
+/*! © 2026 Yahoo, Inc. UDS Default Config v0.0.0-development */
+function canonicalizeStateKey(atoms) {
+	if (atoms.length === 0) return "rest";
+	const seen = /* @__PURE__ */ new Set();
+	const modifiers = [];
+	const interactives = [];
+	for (const atom of atoms) {
+		if (seen.has(atom)) continue;
+		seen.add(atom);
+		if (isModifierAtomic(atom)) modifiers.push(atom);
+		else if (isInteractiveAtomic(atom)) interactives.push(atom);
+		else throw new Error(`canonicalizeStateKey received an unrecognized atom "${atom}". Atoms must be in MODIFIER_ATOMICS or INTERACTIVE_ATOMICS — see StateAxis.`);
+	}
+	modifiers.sort(comparePriority);
+	interactives.sort(comparePriority);
+	const ordered = [...modifiers, ...interactives];
+	return ordered.length === 0 ? "rest" : ordered.join("&");
+}
+/**
+* Splits a canonical (or legacy) state key into its atomic parts.
+* `'rest'` and `''` produce an empty array.
+*/
+function splitStateKey(stateKey) {
+	if (!stateKey || stateKey === "rest") return [];
+	return stateKey.split("&");
+}
+//#endregion
+export { canonicalizeStateKey, splitStateKey };

package/dist/automated-config/dist/utils/getButtonControlHeight.cjs

@@ -0,0 +1,129 @@
+/*! © 2026 Yahoo, Inc. UDS v0.0.0-development */
+const require_index = require("../../../css-tokens/dist/index.cjs");
+const require_mapTextVariantFixtureToValue = require("../mapTextVariantFixtureToValue.cjs");
+const require_properties = require("../properties.cjs");
+const require_iconButtonMatchButtonHeight = require("./iconButtonMatchButtonHeight.cjs");
+//#region ../automated-config/dist/utils/getButtonControlHeight.js
+/*! © 2026 Yahoo, Inc. UDS Default Config v0.0.0-development */
+/** Sizes where IconButton control height should match Button. */
+const SHARED_BUTTON_ICONBUTTON_SIZES = new Set([
+	"xs",
+	"sm",
+	"md",
+	"lg"
+]);
+function getButtonIconSizeVar({ schema, iconLayerKey, state, theme }) {
+	const iconSizeValue = schema.variables?.[iconLayerKey]?.size?.[state]?.value;
+	if (typeof iconSizeValue === "string" && iconSizeValue) return theme(require_properties.configurableProperties.iconSize.twThemePath("iconSizes", iconSizeValue));
+}
+/**
+* Button content box: max(icon size, text line-height).
+* Matches Figma auto-layout and keeps IconButton height aligned with Button.
+*/
+function getButtonControlContentSize({ schema, rootLayerKey, iconLayerKey, state, theme }) {
+	const iconSizeVar = getButtonIconSizeVar({
+		schema,
+		iconLayerKey,
+		state,
+		theme
+	});
+	const textVariantValue = schema.variables?.[rootLayerKey]?.textVariant?.[state]?.value;
+	if (iconSizeVar && typeof textVariantValue === "string" && textVariantValue) return `max(${iconSizeVar}, ${theme(require_mapTextVariantFixtureToValue.mapTextVariantFixtureToValue("lineHeight")("textVariants", textVariantValue))})`;
+	if (iconSizeVar) return iconSizeVar;
+}
+/** `round(up, …, 1px)` matches Math.ceil in getButtonControlHeightPx and Figma hug height. */
+function formatControlHeightCalc(calcExpression) {
+	return `round(up, ${calcExpression}, 1px)`;
+}
+/**
+* Button control height: vertical padding on both sides plus max(icon size, text line-height).
+*/
+function getButtonControlHeight({ paddingVertical, schema, rootLayerKey, iconLayerKey, state, theme }) {
+	const contentSize = getButtonControlContentSize({
+		schema,
+		rootLayerKey,
+		iconLayerKey,
+		state,
+		theme
+	});
+	if (!contentSize) return;
+	return formatControlHeightCalc(`calc(2 * ${paddingVertical} + ${contentSize})`);
+}
+/**
+* IconButton control height: uniform padding plus icon size only (no typography).
+*/
+function getIconButtonControlHeight({ paddingVertical, schema, iconLayerKey, state, theme }) {
+	const iconSizeVar = getButtonIconSizeVar({
+		schema,
+		iconLayerKey,
+		state,
+		theme
+	});
+	if (!iconSizeVar) return;
+	return formatControlHeightCalc(`calc(2 * ${paddingVertical} + ${iconSizeVar})`);
+}
+/**
+* Layout line-height for button root: max(icon size, text line-height).
+*/
+function getButtonContentLineHeight({ schema, rootLayerKey, iconLayerKey, state, theme }) {
+	return getButtonControlContentSize({
+		schema,
+		rootLayerKey,
+		iconLayerKey,
+		state,
+		theme
+	}) ?? "1em";
+}
+function applyButtonControlHeightDeclarations({ cssDeclarations, paddingVertical, schema, rootLayerKey, iconLayerKey, state, theme }) {
+	const controlHeight = rootLayerKey ? getButtonControlHeight({
+		paddingVertical,
+		schema,
+		rootLayerKey,
+		iconLayerKey,
+		state,
+		theme
+	}) : getIconButtonControlHeight({
+		paddingVertical,
+		schema,
+		iconLayerKey,
+		state,
+		theme
+	});
+	if (controlHeight) {
+		cssDeclarations[require_index.BUTTON_CONTROL_HEIGHT_VAR] = controlHeight;
+		cssDeclarations.height = `var(${require_index.BUTTON_CONTROL_HEIGHT_VAR})`;
+	}
+}
+function applyIconButtonSquareDimensions(cssDeclarations) {
+	if (cssDeclarations[require_index.BUTTON_CONTROL_HEIGHT_VAR]) cssDeclarations.width = `var(${require_index.BUTTON_CONTROL_HEIGHT_VAR})`;
+}
+/**
+* IconButton height for xs–lg mirrors Button (padding + max(icon, line-height)).
+* xl uses icon-only height from IconButton tokens.
+*/
+function applyIconButtonControlHeightDeclarations({ cssDeclarations, paddingVertical, iconButtonSchema, buttonHeightReferenceSchema, variantValue, iconLayerKey: _iconLayerKey, state, theme }) {
+	if (buttonHeightReferenceSchema && SHARED_BUTTON_ICONBUTTON_SIZES.has(variantValue) && require_iconButtonMatchButtonHeight.isIconButtonMatchButtonHeightEnabled(iconButtonSchema, variantValue)) {
+		const buttonRootLayerKey = `size/${variantValue}/root`;
+		const buttonIconLayerKey = `size/${variantValue}/icon`;
+		const buttonSpacingValue = buttonHeightReferenceSchema.variables?.[buttonRootLayerKey]?.spacingVertical?.[state]?.value;
+		applyButtonControlHeightDeclarations({
+			cssDeclarations,
+			paddingVertical: typeof buttonSpacingValue === "string" && buttonSpacingValue ? theme(require_properties.configurableProperties.spacingVertical.twThemePath("spacingAliases", buttonSpacingValue)) : paddingVertical,
+			schema: buttonHeightReferenceSchema,
+			rootLayerKey: buttonRootLayerKey,
+			iconLayerKey: buttonIconLayerKey,
+			state,
+			theme
+		});
+		applyIconButtonSquareDimensions(cssDeclarations);
+	}
+}
+//#endregion
+exports.SHARED_BUTTON_ICONBUTTON_SIZES = SHARED_BUTTON_ICONBUTTON_SIZES;
+exports.applyButtonControlHeightDeclarations = applyButtonControlHeightDeclarations;
+exports.applyIconButtonControlHeightDeclarations = applyIconButtonControlHeightDeclarations;
+exports.getButtonContentLineHeight = getButtonContentLineHeight;
+exports.getButtonControlContentSize = getButtonControlContentSize;
+exports.getButtonControlHeight = getButtonControlHeight;
+exports.getButtonIconSizeVar = getButtonIconSizeVar;
+exports.getIconButtonControlHeight = getIconButtonControlHeight;

package/dist/automated-config/dist/utils/getButtonControlHeight.d.cts

@@ -0,0 +1,133 @@
+
+import { IconButtonMatchButtonHeightConfig } from "./iconButtonMatchButtonHeight.cjs";
+
+//#region ../automated-config/dist/utils/getButtonControlHeight.d.ts
+//#region src/utils/getButtonControlHeight.d.ts
+type ThemeFn = (path: string) => string;
+/** Sizes where IconButton control height should match Button. */
+declare const SHARED_BUTTON_ICONBUTTON_SIZES: Set<string>;
+type ButtonControlSchema = IconButtonMatchButtonHeightConfig & {
+  variables?: Record<string, Record<string, Record<string, {
+    value?: unknown;
+  }>>>;
+};
+declare function getButtonIconSizeVar({
+  schema,
+  iconLayerKey,
+  state,
+  theme
+}: {
+  schema: ButtonControlSchema;
+  iconLayerKey: string;
+  state: string;
+  theme: ThemeFn;
+}): string | undefined;
+/**
+ * Button content box: max(icon size, text line-height).
+ * Matches Figma auto-layout and keeps IconButton height aligned with Button.
+ */
+declare function getButtonControlContentSize({
+  schema,
+  rootLayerKey,
+  iconLayerKey,
+  state,
+  theme
+}: {
+  schema: ButtonControlSchema;
+  rootLayerKey: string;
+  iconLayerKey: string;
+  state: string;
+  theme: ThemeFn;
+}): string | undefined;
+/**
+ * Button control height: vertical padding on both sides plus max(icon size, text line-height).
+ */
+declare function getButtonControlHeight({
+  paddingVertical,
+  schema,
+  rootLayerKey,
+  iconLayerKey,
+  state,
+  theme
+}: {
+  paddingVertical: string;
+  schema: ButtonControlSchema;
+  rootLayerKey: string;
+  iconLayerKey: string;
+  state: string;
+  theme: ThemeFn;
+}): string | undefined;
+/**
+ * IconButton control height: uniform padding plus icon size only (no typography).
+ */
+declare function getIconButtonControlHeight({
+  paddingVertical,
+  schema,
+  iconLayerKey,
+  state,
+  theme
+}: {
+  paddingVertical: string;
+  schema: ButtonControlSchema;
+  iconLayerKey: string;
+  state: string;
+  theme: ThemeFn;
+}): string | undefined;
+/**
+ * Layout line-height for button root: max(icon size, text line-height).
+ */
+declare function getButtonContentLineHeight({
+  schema,
+  rootLayerKey,
+  iconLayerKey,
+  state,
+  theme
+}: {
+  schema: ButtonControlSchema;
+  rootLayerKey: string;
+  iconLayerKey: string;
+  state: string;
+  theme: ThemeFn;
+}): string;
+declare function applyButtonControlHeightDeclarations({
+  cssDeclarations,
+  paddingVertical,
+  schema,
+  rootLayerKey,
+  iconLayerKey,
+  state,
+  theme
+}: {
+  cssDeclarations: Record<string, string>;
+  paddingVertical: string;
+  schema: ButtonControlSchema;
+  rootLayerKey?: string;
+  iconLayerKey: string;
+  state: string;
+  theme: ThemeFn;
+}): void;
+/**
+ * IconButton height for xs–lg mirrors Button (padding + max(icon, line-height)).
+ * xl uses icon-only height from IconButton tokens.
+ */
+declare function applyIconButtonControlHeightDeclarations({
+  cssDeclarations,
+  paddingVertical,
+  iconButtonSchema,
+  buttonHeightReferenceSchema,
+  variantValue,
+  iconLayerKey: _iconLayerKey,
+  state,
+  theme
+}: {
+  cssDeclarations: Record<string, string>;
+  paddingVertical: string;
+  iconButtonSchema: ButtonControlSchema;
+  buttonHeightReferenceSchema?: ButtonControlSchema;
+  variantValue: string;
+  iconLayerKey: string;
+  state: string;
+  theme: ThemeFn;
+}): void; //#endregion
+//#endregion
+export { type ButtonControlSchema, SHARED_BUTTON_ICONBUTTON_SIZES, applyButtonControlHeightDeclarations, applyIconButtonControlHeightDeclarations, getButtonContentLineHeight, getButtonControlContentSize, getButtonControlHeight, getButtonIconSizeVar, getIconButtonControlHeight };