@yahoo/uds-create-config 1.1.1

package/dist/token-override-rows.js

@@ -0,0 +1,223 @@
+//#region src/token-override-rows.ts
+function createModeBackedModifierLookup(inputs) {
+	const byModifier = /* @__PURE__ */ new Map();
+	const byModeRef = /* @__PURE__ */ new Map();
+	for (const input of inputs) {
+		const definition = {
+			...input,
+			modeRef: `${input.mode}.${input.option}`
+		};
+		byModifier.set(input.modifier, definition);
+		byModeRef.set(definition.modeRef, definition);
+	}
+	return {
+		byModifier,
+		byModeRef
+	};
+}
+function buildModeBackedModifierLookup(modes, modifiers) {
+	const optionMetadata = /* @__PURE__ */ new Map();
+	modes.forEach((mode, modeOrder) => {
+		mode.options.forEach((option, optionOrder) => {
+			optionMetadata.set(`${mode.name}/${option.name}`, {
+				mode: mode.name,
+				option: option.name,
+				label: option.label ?? option.name,
+				modeOrder,
+				optionOrder
+			});
+		});
+	});
+	const inputs = [];
+	for (const modifier of modifiers) {
+		const marker = getModeMarker(modifier.selector);
+		if (!marker) continue;
+		const metadata = optionMetadata.get(marker.ref);
+		if (!metadata) continue;
+		inputs.push({
+			...metadata,
+			modifier: modifier.modifier
+		});
+	}
+	return createModeBackedModifierLookup(inputs);
+}
+function modifierTreeToOverrideRows(modifiers, lookup) {
+	const rows = [];
+	let sourceOrder = 0;
+	const visit = (value, modifierPath) => {
+		const node = asModifierNode(value);
+		const modes = canonicalizeModifierPath(modifierPath, lookup);
+		if (!node) {
+			rows.push({
+				modes,
+				value,
+				sourceModifierPath: modifierPath,
+				sourceOrder
+			});
+			sourceOrder++;
+			return;
+		}
+		if (Object.hasOwn(node, "value") && node.value !== void 0) {
+			rows.push({
+				modes,
+				value: node.value,
+				sourceModifierPath: modifierPath,
+				sourceOrder
+			});
+			sourceOrder++;
+		}
+		for (const [key, nestedValue] of Object.entries(node)) {
+			if (key === "value" || nestedValue === void 0) continue;
+			if (!isModifierKey(key) || !lookup.byModifier.has(key)) continue;
+			visit(nestedValue, [...modifierPath, key]);
+		}
+	};
+	for (const [modifier, value] of Object.entries(modifiers ?? {})) {
+		if (value === void 0) continue;
+		if (!isModifierKey(modifier) || !lookup.byModifier.has(modifier)) continue;
+		visit(value, [modifier]);
+	}
+	return rows;
+}
+function overrideRowsToModifierTree(rows, lookup) {
+	const tree = {};
+	for (const row of rows) {
+		const path = resolveWritableModifierPath(row, lookup);
+		if (path.length === 0) continue;
+		assignModifierPath(tree, path, row.value);
+	}
+	return tree;
+}
+function resolveOverrideRowValue(baseValue, rows, activeModes) {
+	const active = new Set(activeModes);
+	let resolved = baseValue;
+	let bestSpecificity = -1;
+	let bestOrder = -1;
+	rows.forEach((row, order) => {
+		if (!row.modes.every((mode) => active.has(mode))) return;
+		const specificity = row.modes.length;
+		if (specificity < bestSpecificity) return;
+		if (specificity === bestSpecificity && order < bestOrder) return;
+		resolved = row.value;
+		bestSpecificity = specificity;
+		bestOrder = order;
+	});
+	return resolved;
+}
+function modifierPathToId(path) {
+	return path.join(".");
+}
+function modifierIdToPath(id) {
+	return id.split(".").filter(isModifierKey).map((part) => part);
+}
+function buildNestedModifierUpdate(modifierPath, value) {
+	if (modifierPath.length === 0) return {};
+	const [first, ...rest] = modifierPath;
+	if (!first) return {};
+	if (rest.length === 0) return { [first]: value };
+	return { [first]: buildNestedModifierUpdate(rest, value) };
+}
+/**
+* Combines multiple token-modifier update payloads into one patch
+* object. Later updates win on scalar/null leaves; object branches
+* deep-merge so swap operations can delete one nested row and set
+* another nested row under the same parent modifier in a single
+* patch.
+*/
+function mergeModifierUpdates(...updates) {
+	const merged = {};
+	for (const update of updates) mergeModifierUpdateInto(merged, update);
+	return merged;
+}
+function getModeMarker(selector) {
+	if (typeof selector !== "object" || selector === null) return null;
+	const marker = selector;
+	if (marker.__kind !== "mode" || typeof marker.ref !== "string") return null;
+	return {
+		__kind: "mode",
+		ref: marker.ref
+	};
+}
+function mergeModifierUpdateInto(target, update) {
+	for (const [key, value] of Object.entries(update)) {
+		if (value === void 0) continue;
+		const current = target[key];
+		if (isModifierUpdateObject(current) && isModifierUpdateObject(value)) {
+			target[key] = mergeModifierUpdateObjects(current, value);
+			continue;
+		}
+		target[key] = value;
+	}
+}
+function mergeModifierUpdateObjects(current, update) {
+	const merged = {};
+	for (const [key, value] of Object.entries(current)) if (value !== void 0) merged[key] = value;
+	mergeModifierUpdateInto(merged, update);
+	return merged;
+}
+function isModifierUpdateObject(value) {
+	return typeof value === "object" && value !== null;
+}
+function canonicalizeModifierPath(modifierPath, lookup) {
+	return modifierPath.map((modifier) => lookup.byModifier.get(modifier)).filter((definition) => definition !== void 0).sort(compareModeBackedModifiers).map((definition) => definition.modeRef);
+}
+function resolveWritableModifierPath(row, lookup) {
+	if (pathMatchesModes(row.sourceModifierPath, row.modes, lookup)) return row.sourceModifierPath;
+	return row.modes.map((modeRef) => lookup.byModeRef.get(modeRef)).filter((definition) => definition !== void 0).sort(compareModeBackedModifiers).map((definition) => definition.modifier);
+}
+function pathMatchesModes(path, modes, lookup) {
+	if (path.length !== modes.length) return false;
+	const pathModes = canonicalizeModifierPath(path, lookup);
+	const expectedModes = [...modes].sort((a, b) => compareModeBackedModifiersByRef(a, b, lookup));
+	return pathModes.length === expectedModes.length && pathModes.every((mode, index) => mode === expectedModes[index]);
+}
+function assignModifierPath(tree, path, value) {
+	const [modifier, ...rest] = path;
+	if (!modifier) return;
+	if (rest.length === 0) {
+		tree[modifier] = mergeLeafValue(tree[modifier], value);
+		return;
+	}
+	const current = tree[modifier];
+	const node = asWritableModifierNode(current);
+	tree[modifier] = node;
+	assignModifierPath(node, rest, value);
+}
+function mergeLeafValue(current, value) {
+	const node = asModifierNode(current);
+	if (!node) return value;
+	return {
+		...node,
+		value
+	};
+}
+function asWritableModifierNode(current) {
+	const node = asModifierNode(current);
+	if (node) return { ...node };
+	if (current !== void 0) return { value: current };
+	return {};
+}
+function asModifierNode(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+	if (Object.hasOwn(value, "value")) return value;
+	if (Object.keys(value).some(isModifierKey)) return value;
+	return null;
+}
+function isModifierKey(value) {
+	return value.startsWith("_");
+}
+function compareModeBackedModifiers(a, b) {
+	if (a.modeOrder !== b.modeOrder) return a.modeOrder - b.modeOrder;
+	if (a.optionOrder !== b.optionOrder) return a.optionOrder - b.optionOrder;
+	return a.modifier.localeCompare(b.modifier);
+}
+function compareModeBackedModifiersByRef(a, b, lookup) {
+	const aDefinition = lookup.byModeRef.get(a);
+	const bDefinition = lookup.byModeRef.get(b);
+	if (aDefinition && bDefinition) return compareModeBackedModifiers(aDefinition, bDefinition);
+	if (aDefinition) return -1;
+	if (bDefinition) return 1;
+	return a.localeCompare(b);
+}
+//#endregion
+export { buildModeBackedModifierLookup, buildNestedModifierUpdate, createModeBackedModifierLookup, mergeModifierUpdates, modifierIdToPath, modifierPathToId, modifierTreeToOverrideRows, overrideRowsToModifierTree, resolveOverrideRowValue };

package/dist/tokenValueType.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Internal token value-type resolution. Lives outside `index.ts` —
+ * consumers reach for `Token.derived.cssValueType` instead. The static
+ * `Token.sniffValueType(value)` helper is the one entry point exposed
+ * to picker UIs that don't yet have a `Token` instance to derive from.
+ */
+import type { TokenType } from './types';
+import type { CssValueTypeName } from './types/css-values';
+/**
+ * Heuristic CSS-value classifier. Given a raw value string, returns the
+ * best-guess type or `undefined` when no confident match is possible
+ * (e.g. `var(...)` references). Used by `Token.sniffValueType` and as
+ * the value-shape tier of {@link resolveTokenValueType}.
+ */
+export declare function sniffTokenType(value: string): TokenType | undefined;
+/**
+ * Resolve a token's effective {@link CssValueTypeName} using the
+ * canonical 3-tier precedence:
+ *
+ *   1. Per-token explicit `type` — authored override always wins.
+ *   2. Value-shape sniff — handles `'#1167f4' → color` even inside a
+ *      `string` group, and `'transparent' → string` even inside a
+ *      `color` group.
+ *   3. Group `type` — least-specific fallback for legacy untyped
+ *      values.
+ *
+ * `length-percentage` narrows to `length` / `percentage` / `angle` /
+ * `time` based on the trailing suffix; `string` narrows to `shadow`
+ * when the value looks like a CSS shadow declaration.
+ */
+export declare function resolveTokenValueType(token: {
+    value: string;
+    type?: TokenType;
+}, groupType: TokenType | undefined): CssValueTypeName | undefined;

package/dist/tokenValueType.js

@@ -0,0 +1,138 @@
+//#region src/tokenValueType.ts
+const CSS_STRING_KEYWORDS = new Set([
+	"inherit",
+	"initial",
+	"unset",
+	"revert",
+	"revert-layer",
+	"auto",
+	"none",
+	"currentColor",
+	"currentcolor",
+	"transparent",
+	"min-content",
+	"max-content",
+	"fit-content"
+]);
+const HEX_COLOR_RE = /^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+const COLOR_FUNCTION_RE = /^(?:rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch|color|color-mix|light-dark)\s*\(/i;
+const GRADIENT_FUNCTION_RE = /^(?:linear|radial|conic|repeating-linear|repeating-radial|repeating-conic)-gradient\s*\(/i;
+const EASING_FUNCTION_RE = /^(?:cubic-bezier|steps)\s*\(/i;
+const EASING_KEYWORDS = new Set([
+	"linear",
+	"ease",
+	"ease-in",
+	"ease-out",
+	"ease-in-out",
+	"step-start",
+	"step-end"
+]);
+const NAMED_COLOR_KEYWORDS = new Set([
+	"aliceblue",
+	"antiquewhite",
+	"aqua",
+	"aquamarine",
+	"azure",
+	"beige",
+	"bisque",
+	"black",
+	"blue",
+	"brown",
+	"crimson",
+	"cyan",
+	"fuchsia",
+	"gold",
+	"gray",
+	"grey",
+	"green",
+	"indigo",
+	"lavender",
+	"lime",
+	"magenta",
+	"maroon",
+	"navy",
+	"olive",
+	"orange",
+	"pink",
+	"purple",
+	"red",
+	"salmon",
+	"silver",
+	"teal",
+	"tomato",
+	"violet",
+	"white",
+	"yellow"
+]);
+const NUMBER_RE_SRC = "(?:\\d+(?:\\.\\d+)?|\\.\\d+)";
+const DIMENSION_RE = new RegExp(`^-?${NUMBER_RE_SRC}(?:px|rem|em|%|vh|vw|vmin|vmax|vi|vb|svh|svw|lvh|lvw|dvh|dvw|ch|ex|cap|ic|lh|rlh|pt|pc|in|cm|mm|q|fr|deg|turn|rad|grad)$`, "i");
+const DURATION_RE = new RegExp(`^-?${NUMBER_RE_SRC}(?:ms|s)$`, "i");
+const PURE_NUMBER_RE = new RegExp(`^-?${NUMBER_RE_SRC}$`);
+const RATIO_RE = /^\d+(?:\.\d+)?\s*\/\s*\d+(?:\.\d+)?$/;
+const SHADOW_LENGTH_RE = /(?:^|[\s,])-?\d+(?:\.\d+)?(?:px|rem|em|ch|ex)/i;
+const SHADOW_COLOR_RE = /(?:rgba?|hsla?|color|oklch|oklab|lch|lab|hwb)\(|#[0-9a-fA-F]{3,8}\b/;
+function looksLikeShadow(value) {
+	return SHADOW_LENGTH_RE.test(value) && SHADOW_COLOR_RE.test(value);
+}
+/**
+* Heuristic CSS-value classifier. Given a raw value string, returns the
+* best-guess type or `undefined` when no confident match is possible
+* (e.g. `var(...)` references). Used by `Token.sniffValueType` and as
+* the value-shape tier of {@link resolveTokenValueType}.
+*/
+function sniffTokenType(value) {
+	const v = value.trim();
+	if (v.length === 0) return void 0;
+	if (CSS_STRING_KEYWORDS.has(v)) return "string";
+	if (v.startsWith("var(")) return void 0;
+	if (COLOR_FUNCTION_RE.test(v)) return "color";
+	if (HEX_COLOR_RE.test(v)) return "color";
+	if (NAMED_COLOR_KEYWORDS.has(v.toLowerCase())) return "color";
+	if (GRADIENT_FUNCTION_RE.test(v)) return "gradient";
+	if (EASING_FUNCTION_RE.test(v)) return "easing-function";
+	if (EASING_KEYWORDS.has(v.toLowerCase())) return "easing-function";
+	if (DURATION_RE.test(v)) return "time";
+	if (DIMENSION_RE.test(v)) {
+		if (v.endsWith("%")) return "percentage";
+		if (/(deg|rad|grad|turn)$/i.test(v)) return "angle";
+		return "length";
+	}
+	if (PURE_NUMBER_RE.test(v)) return "number";
+	if (RATIO_RE.test(v)) return "ratio";
+	if (looksLikeShadow(v)) return "shadow";
+}
+/**
+* Resolve a token's effective {@link CssValueTypeName} using the
+* canonical 3-tier precedence:
+*
+*   1. Per-token explicit `type` — authored override always wins.
+*   2. Value-shape sniff — handles `'#1167f4' → color` even inside a
+*      `string` group, and `'transparent' → string` even inside a
+*      `color` group.
+*   3. Group `type` — least-specific fallback for legacy untyped
+*      values.
+*
+* `length-percentage` narrows to `length` / `percentage` / `angle` /
+* `time` based on the trailing suffix; `string` narrows to `shadow`
+* when the value looks like a CSS shadow declaration.
+*/
+function resolveTokenValueType(token, groupType) {
+	let resolved;
+	if (token.type) resolved = token.type;
+	else {
+		resolved = sniffTokenType(token.value);
+		if (resolved === void 0 && groupType) resolved = groupType;
+	}
+	if (resolved === void 0) return void 0;
+	const trimmed = token.value.trim();
+	if (resolved === "length-percentage") {
+		if (trimmed.endsWith("%")) return "percentage";
+		if (/(deg|rad|grad|turn)$/.test(trimmed)) return "angle";
+		if (/(ms|s)$/.test(trimmed)) return "time";
+		return "length";
+	}
+	if (resolved === "string" && looksLikeShadow(trimmed)) return "shadow";
+	return resolved;
+}
+//#endregion
+export { resolveTokenValueType, sniffTokenType };