@yahoo/uds-v5-wip 0.0.1

package/dist/config/dist/createConfig.d.ts

@@ -0,0 +1,214 @@
+import { BaseModifierProp, ComponentsConfig, ConfigurableProp, MacroConfig, ModifierProp, MotionPreset, RemotionComponentDef, RemotionConfig, RemotionTransitionDef } from "@uds/types";
+
+//#region ../config/dist/createConfig.d.ts
+//#region src/createConfig.d.ts
+type MotionPresetsDef = Record<string, MotionPreset>;
+type MotionAliasValue<TMotion> = TMotion extends Record<string, infer V> ? Extract<V, string> : never;
+type EmptyMotion = {};
+type EmptyMacros = {};
+/** Transform macro config type into the reference shape passed to defineModifiers */
+type MacroReference<T> = { [K in keyof T]: { [V in keyof T[K]]: {
+  className: string;
+} } };
+type ModifierNameShape = `_${string}`;
+/**
+ * Check if a modifier overlaps with base reserved modifiers (not including custom ones)
+ * BaseModifierProp excludes CustomModifierNames to prevent circular dependency
+ */
+type IsReservedModifier<T> = T extends BaseModifierProp ? true : false;
+/** Check if any modifier in the union is reserved */
+type HasReservedModifier<T> = T extends any ? IsReservedModifier<T> extends true ? true : never : never;
+interface ModeOption {
+  name: string;
+  modifier: ModifierNameShape;
+  /** Description for AI prompt generation (e.g. "Apply styles in dark mode") */
+  description?: string;
+  css?: string;
+  media?: string;
+  default?: true;
+}
+interface ModeGroup {
+  name: string;
+  options: ModeOption[];
+}
+interface ModifierDef {
+  modifier: ModifierNameShape;
+  selector: string;
+  /** Description for AI prompt generation (e.g. "Apply styles on elevation-1 surfaces") */
+  description?: string;
+}
+/** Extract modifier union from all mode groups */
+type GetModifierName<M extends readonly ModeGroup[]> = M[number]['options'][number]['modifier'];
+interface ArbitraryTokenGroup {
+  properties: string[];
+  pattern: string | string[];
+}
+type AtomicTokenValue<M extends ModifierNameShape> = {
+  name: string;
+  value: string;
+  modifiers?: Partial<Record<M, string>>;
+};
+interface AtomicToken<M extends ModifierNameShape = ModifierNameShape> {
+  properties: ConfigurableProp[];
+  tokens: AtomicTokenValue<M>[];
+  /**
+   * Optional CSS variable prefix override
+   *
+   * By default, the prefix is determined by the property type:
+   * - color/bg/borderColor → '--color-*'
+   * - spacing → '--spacing-*'
+   * - fontFamily → '--font-*'
+   *
+   * Use this to customize the namespace for specific tokens.
+   *
+   * @example
+   * ```ts
+   * {
+   *   properties: ['color'],
+   *   cssPrefix: 'text', // Creates '--text-*' instead of '--color-*'
+   *   tokens: [{ name: 'brand', value: '#3b82f6' }]
+   * }
+   * ```
+   */
+  cssPrefix?: string;
+}
+/** Helper to extract all modifier keys from AtomicToken array */
+type ExtractModifierKeys<T> = T extends readonly AtomicToken<infer M>[] ? M : never;
+/** Helper to check if all modifiers in the tokens are valid */
+type ValidateModifiers<Tokens extends readonly AtomicToken<any>[], ValidModifiers extends ModifierNameShape> = ExtractModifierKeys<Tokens> extends ValidModifiers ? Tokens : never;
+/** Extract property keys from atomic tokens */
+type ExtractProperties<T extends readonly AtomicToken<any>[]> = T[number]['properties'][number];
+/** Distributive helper: for each token group U, yield its token names if P is one of its properties */
+type TokenNamesForProperty<U, P extends ConfigurableProp> = U extends AtomicToken<any> ? P extends U['properties'][number] ? U['tokens'][number]['name'] : never : never;
+/** Build token structure for a specific property */
+type BuildTokensForProperty<T extends readonly AtomicToken<any>[], P extends ConfigurableProp> = { [K in TokenNamesForProperty<T[number], P>]: string };
+/** Extract token names from atomic tokens array */
+type ExtractTokenNames<T extends readonly AtomicToken<any>[]> = { [P in ExtractProperties<T>]: BuildTokensForProperty<T, P> };
+/** Merge two token structures */
+type MergeTokens<A, B> = { [K in keyof A | keyof B]: K extends keyof B ? K extends keyof A ? A[K] & B[K] : B[K] : K extends keyof A ? A[K] : never };
+/** Empty tokens type for initial state */
+type EmptyTokens = {};
+/** Build a structured token reference object from atomic tokens */
+declare function buildTokenReference(atomic: AtomicToken<ModifierNameShape>[], configPrefix: string): Record<ConfigurableProp, Record<string, string>>;
+/** Build a structured macro reference object for use in defineModifiers context */
+/** Extract all modifiers from mode groups and check if any are reserved */
+type CheckForReservedModifiers<T extends readonly ModeGroup[]> = true extends HasReservedModifier<GetModifierName<T>> ? 'ERROR: Cannot use reserved modifier names from ModifierProp. Please use a different modifier name.' : T;
+/** Global styles definition — CSS selector → style props */
+type GlobalStylesDef = Record<string, Record<string, any>>;
+/** CSS properties for the example wrapper element */
+type ExampleLayoutStyles = Record<string, string>;
+/** Single example entry — either iterates a variant axis or shows a static example */
+interface ExampleEntryDef<TAxis extends string = string> {
+  each?: TAxis;
+  layout?: ExampleLayoutStyles;
+  props?: Record<string, Record<string, unknown>>;
+}
+/** Map of example keys (e.g. 'default', 'anatomy') to their definitions */
+type ExampleDef<TAxis extends string = string> = Record<string, ExampleEntryDef<TAxis>>;
+/** Build options that can be set in uds.config.ts via .buildOptions() */
+interface BuildOptions {
+  skipCssVariables?: boolean;
+  preflight?: boolean;
+}
+/** Internal data shape — accessible via resolveConfig() */
+interface UdsConfigData {
+  modes: ModeGroup[];
+  modifiers: ModifierDef[];
+  atomic: AtomicToken<ModifierNameShape>[];
+  macros: MacroConfig;
+  motion: MotionPresetsDef;
+  components: ComponentsConfig<string>;
+  globalStyles: GlobalStylesDef;
+  preflight: boolean;
+  prefix: string;
+  remotion?: RemotionConfig;
+  arbitraryTokens?: ArbitraryTokenGroup[];
+  buildOptions?: BuildOptions;
+  examples?: Record<string, ExampleDef>;
+  designPrinciples?: string[];
+}
+interface ComponentConfig<TComponents extends ComponentsConfig<string> = ComponentsConfig<string>, TMotion extends MotionPresetsDef | undefined = MotionPresetsDef | undefined> {
+  name?: string;
+  requiredTokens: string[];
+  components: TComponents;
+  motion?: TMotion;
+  /** Remotion metadata — carried through compose() automatically */
+  remotion?: RemotionConfig;
+}
+type SingleComponentDef<TMotionAlias extends string = string> = ComponentsConfig<TMotionAlias>[string];
+type EmptyMotionPresetsDef = Record<never, never>;
+type SingleComponentDefinitionRecord<TName extends string, TComponent extends SingleComponentDef<string>> = { [K in TName]: TComponent };
+type DefineComponentInput<TTokens, TMotion, TComponent extends SingleComponentDef<MotionAliasValue<TMotion> | string> = SingleComponentDef<MotionAliasValue<TMotion> | string>> = TComponent | ((ctx: {
+  tokens: TTokens;
+  motion: TMotion;
+  components: Record<string, any>;
+}) => TComponent);
+type DefineComponentMotionInput<TTokens, TMotion extends MotionPresetsDef = MotionPresetsDef> = TMotion | ((tokens: TTokens) => TMotion);
+/** Input shape for defineRemotionComponent — component def or factory function */
+type RemotionComponentInput<TTokens, TMotion> = RemotionComponentDef | ((ctx: {
+  tokens: TTokens;
+  motion: TMotion;
+  components: Record<string, any>;
+}) => RemotionComponentDef);
+/** Helper type: builder result includes both the UdsConfig interface and any extensions */
+type ConfigResult<TModifier extends ModifierNameShape, TTokens, TMotion, TExt extends Record<string, any> = {}, TMacros = EmptyMacros> = UdsConfig<TModifier, TTokens, TMotion, TExt, TMacros> & TExt;
+interface UdsConfig<TModifier extends ModifierNameShape = ModifierProp, TTokens = EmptyTokens, TMotion = EmptyMotion, TExt extends Record<string, any> = {}, TMacros = EmptyMacros> {
+  modes: ModeGroup[];
+  atomic: AtomicToken<ModifierNameShape>[];
+  components: ComponentsConfig;
+  preflight(enabled?: boolean): ConfigResult<TModifier, TTokens, TMotion, TExt, TMacros>;
+  prefix(value: string): ConfigResult<TModifier, TTokens, TMotion, TExt, TMacros>;
+  buildOptions(options: BuildOptions): ConfigResult<TModifier, TTokens, TMotion, TExt, TMacros>;
+  defineModes<const NewModes extends readonly ModeGroup[]>(params: CheckForReservedModifiers<NewModes>): ConfigResult<TModifier | GetModifierName<NewModes>, TTokens, TMotion, TExt, TMacros>;
+  defineModifiers<const Defs extends readonly ModifierDef[]>(params: Defs | ((ctx: {
+    tokens: TTokens;
+    macros: MacroReference<TMacros>;
+  }) => Defs)): ConfigResult<TModifier | Defs[number]['modifier'], TTokens, TMotion, TExt, TMacros>;
+  defineMacro<const M extends MacroConfig>(params: M | ((ctx: {
+    tokens: TTokens;
+  }) => M)): ConfigResult<TModifier, TTokens, TMotion, TExt, TMacros & M>;
+  defineAtomicTokens<const Tokens extends readonly AtomicToken<any>[]>(params: [TModifier] extends [ModifierProp] ? Tokens : ValidateModifiers<Tokens, TModifier>): ConfigResult<TModifier, MergeTokens<TTokens, ExtractTokenNames<Tokens>>, TMotion, TExt, TMacros>;
+  defineArbitraryTokens(params: ArbitraryTokenGroup[]): ConfigResult<TModifier, TTokens, TMotion, TExt, TMacros>;
+  defineMotion<const M extends MotionPresetsDef>(presets: M | ((tokens: TTokens) => M)): ConfigResult<TModifier, TTokens, { [K in keyof M]: string }, TExt, TMacros>;
+  defineComponents(params: ComponentsConfig<MotionAliasValue<TMotion> | string> | ((ctx: {
+    tokens: TTokens;
+    motion: TMotion;
+    components: Record<string, any>;
+  }) => ComponentsConfig<MotionAliasValue<TMotion> | string>)): ConfigResult<TModifier, TTokens, TMotion, TExt, TMacros>;
+  defineGlobalStyles(params: GlobalStylesDef | ((tokens: TTokens) => GlobalStylesDef)): ConfigResult<TModifier, TTokens, TMotion, TExt, TMacros>;
+  defineDesignPrinciples(principles: string[]): ConfigResult<TModifier, TTokens, TMotion, TExt, TMacros>;
+  defineExample(name: string, examples: ExampleDef): ConfigResult<TModifier, TTokens, TMotion, TExt, TMacros>;
+  compose(...presets: (ComponentConfig | UdsConfig | Partial<UdsConfigData>)[]): ConfigResult<TModifier, TTokens, TMotion, TExt, TMacros>;
+  defineComponent<const TName extends string, const TComponent extends SingleComponentDef<MotionAliasValue<TMotion> | string>, const TPresetMotion extends MotionPresetsDef = EmptyMotionPresetsDef>(name: TName, component: DefineComponentInput<TTokens, TMotion, TComponent>, motion?: DefineComponentMotionInput<TTokens, TPresetMotion>): ComponentConfig<SingleComponentDefinitionRecord<TName, TComponent>, TPresetMotion>;
+  from(data: Partial<UdsConfigData>): ConfigResult<TModifier, TTokens, TMotion, TExt, TMacros>;
+  extend<const NewExt extends Record<string, any>>(ext: NewExt): ConfigResult<TModifier, TTokens, TMotion, TExt & NewExt, TMacros>;
+  defineRemotionComponents(params: RemotionConfig | ((ctx: {
+    tokens: TTokens;
+    motion: TMotion;
+    components: Record<string, any>;
+  }) => RemotionConfig)): ConfigResult<TModifier, TTokens, TMotion, TExt, TMacros>;
+  defineRemotionComponent<const TName extends string, const TComponent extends SingleComponentDef<MotionAliasValue<TMotion> | string>, const TPresetMotion extends MotionPresetsDef = EmptyMotionPresetsDef>(name: TName, def: RemotionComponentInput<TTokens, TMotion>, motion?: DefineComponentMotionInput<TTokens, TPresetMotion>): ComponentConfig<SingleComponentDefinitionRecord<TName, TComponent>, TPresetMotion>;
+  defineRemotionTransition(name: string, def: RemotionTransitionDef | ((ctx: {
+    tokens: TTokens;
+  }) => RemotionTransitionDef)): ComponentConfig;
+  defineRemotionTransitions(params: Record<string, RemotionTransitionDef> | ((ctx: {
+    tokens: TTokens;
+  }) => Record<string, RemotionTransitionDef>)): ConfigResult<TModifier, TTokens, TMotion, TExt, TMacros>;
+}
+type AnyUdsConfig = UdsConfig<ModifierNameShape, any, any, any, any>;
+/** Extract the raw config data from a builder instance */
+declare function resolveConfig(config: AnyUdsConfig): UdsConfigData;
+/**
+ * Resolve configuration with all token references replaced by their raw values.
+ * Useful for tools that need the actual values (e.g. anatomy generation).
+ */
+declare function createConfigBuilder<TModifier extends ModifierNameShape = ModifierProp, TTokens = EmptyTokens, TMotion = EmptyMotion, TExt extends Record<string, any> = {}, TMacros = EmptyMacros>(data: UdsConfigData, extensions?: TExt): UdsConfig<TModifier, TTokens, TMotion, TExt, TMacros> & TExt;
+interface InterpolateMarker {
+  __type: 'interpolate';
+  output: number[];
+  extrapolate: 'clamp' | 'extend' | 'identity';
+}
+declare function darker(color: string, amount: number): string;
+declare function lighter(color: string, amount: number): string;
+//#endregion
+export { ArbitraryTokenGroup, AtomicToken, BuildOptions, ComponentConfig, DefineComponentInput, DefineComponentMotionInput, ExampleDef, ExampleEntryDef, ExampleLayoutStyles, GlobalStylesDef, InterpolateMarker, ModeGroup, ModifierDef, MotionPresetsDef, UdsConfig, UdsConfigData, buildTokenReference, createConfigBuilder, darker, lighter, resolveConfig };

package/dist/config/dist/createConfig.js

@@ -0,0 +1,454 @@
+import { safeTokenName } from "../../utils/dist/string-utils/cssVar.js";
+import "../../utils/dist/index.js";
+import { getConfigurablePropMapping } from "../../core/dist/propMappings.js";
+import "../../core/dist/index.js";
+import { buildMotionReference, resolveComponentMotionAliases, validateComponentVariants } from "./component-resolution.js";
+import { applyPresetToData, deepMerge, mergeAtomic } from "./preset-merge.js";
+//#region ../config/dist/createConfig.js
+/** biome-ignore-all lint/suspicious/noExplicitAny: necessary for dynamic builder to work correctly */
+/** Build a structured token reference object from atomic tokens */
+function buildTokenReference(atomic, configPrefix) {
+	const result = Object.create(null);
+	for (const token of atomic) for (const prop of token.properties) {
+		if (!result[prop]) result[prop] = Object.create(null);
+		for (const t of token.tokens) {
+			const varPrefix = token.cssPrefix ?? getConfigurablePropMapping(prop)?.defaultVarPrefix;
+			const safeName = safeTokenName(t.name);
+			const cssVarName = configPrefix ? `--${configPrefix}-${varPrefix}-${safeName}` : `--${varPrefix}-${safeName}`;
+			result[prop][t.name] = `var(${cssVarName})`;
+		}
+	}
+	return result;
+}
+/** Build a structured macro reference object for use in defineModifiers context */
+function buildMacroReference(macros) {
+	const result = {};
+	for (const [macroName, def] of Object.entries(macros)) {
+		result[macroName] = {};
+		for (const valueName of Object.keys(def)) result[macroName][valueName] = { className: `${macroName}-${safeTokenName(valueName)}` };
+	}
+	return result;
+}
+/** Extract the raw config data from a builder instance */
+function resolveConfig(config) {
+	if (config._data) return config._data;
+	return {
+		modes: config.modes ?? [],
+		modifiers: config.modifiers ?? [],
+		atomic: config.atomic ?? [],
+		macros: config.macros ?? {},
+		motion: config.motion ?? {},
+		components: config.components ?? {},
+		globalStyles: config.globalStyles ?? {},
+		preflight: config.preflight ?? true,
+		prefix: config.prefix ?? "uds",
+		arbitraryTokens: config.arbitraryTokens,
+		remotion: config.remotion,
+		buildOptions: config.buildOptions,
+		examples: config.examples,
+		designPrinciples: config.designPrinciples
+	};
+}
+function mergeRemotionConfig(existing, incoming) {
+	return {
+		components: {
+			...existing?.components ?? {},
+			...incoming.components
+		},
+		transitions: {
+			...existing?.transitions ?? {},
+			...incoming.transitions ?? {}
+		},
+		effects: {
+			...existing?.effects ?? {},
+			...incoming.effects ?? {}
+		}
+	};
+}
+function isComponentDefinition(input) {
+	return typeof input === "object" && input !== null && "requiredTokens" in input && "components" in input;
+}
+function resolvePresetData(input) {
+	if (isComponentDefinition(input)) return {
+		modes: [],
+		modifiers: [],
+		atomic: [],
+		macros: {},
+		motion: input.motion ?? {},
+		components: input.components,
+		globalStyles: {},
+		preflight: true,
+		prefix: "uds",
+		remotion: input.remotion
+	};
+	if ("defineAtomicTokens" in input) return resolveConfig(input);
+	return {
+		modes: input.modes ?? [],
+		modifiers: input.modifiers ?? [],
+		atomic: input.atomic ?? [],
+		macros: input.macros ?? {},
+		motion: input.motion ?? {},
+		components: input.components ?? {},
+		globalStyles: input.globalStyles ?? {},
+		preflight: input.preflight ?? true,
+		prefix: input.prefix ?? "uds",
+		arbitraryTokens: input.arbitraryTokens,
+		remotion: input.remotion,
+		examples: input.examples,
+		designPrinciples: input.designPrinciples
+	};
+}
+function extractVarReferences(value) {
+	if (typeof value !== "string") return [];
+	return value.match(/var\([^()]+\)/g) ?? [];
+}
+function collectRequiredTokensFromObject(value, varToToken, out) {
+	if (value == null) return;
+	if (typeof value === "string") {
+		const refs = extractVarReferences(value);
+		for (const ref of refs) {
+			const token = varToToken.get(ref);
+			if (token) out.add(token);
+		}
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const item of value) collectRequiredTokensFromObject(item, varToToken, out);
+		return;
+	}
+	if (typeof value === "object") for (const child of Object.values(value)) collectRequiredTokensFromObject(child, varToToken, out);
+}
+function buildVarToTokenMap(data) {
+	const tokenReference = buildTokenReference(data.atomic, data.prefix);
+	const map = /* @__PURE__ */ new Map();
+	for (const [prop, tokens] of Object.entries(tokenReference)) for (const [tokenName, tokenRef] of Object.entries(tokens)) map.set(tokenRef, `${prop}.${tokenName}`);
+	return map;
+}
+function collectRequiredTokens(sourceData, components, motion) {
+	const out = /* @__PURE__ */ new Set();
+	const varToToken = buildVarToTokenMap(sourceData);
+	collectRequiredTokensFromObject(components, varToToken, out);
+	if (motion) collectRequiredTokensFromObject(motion, varToToken, out);
+	return Array.from(out).sort();
+}
+function availableTokenNames(data) {
+	const names = /* @__PURE__ */ new Set();
+	for (const group of data.atomic) for (const prop of group.properties) for (const token of group.tokens) names.add(`${prop}.${token.name}`);
+	return names;
+}
+function validatePresetRequiredTokens(base, preset) {
+	if (preset.requiredTokens.length === 0) return;
+	const available = availableTokenNames(base);
+	const missing = preset.requiredTokens.filter((name) => !available.has(name));
+	if (missing.length === 0) return;
+	const presetLabel = preset.name ? `"${preset.name}"` : "component preset";
+	throw new Error(`Cannot compose ${presetLabel}: missing required tokens in current preset: ${missing.join(", ")}`);
+}
+function buildComponentsAccessor(components) {
+	const accessor = {};
+	for (const [name, config] of Object.entries(components)) {
+		const comp = {};
+		comp.base = { ...config.base?.root ?? {} };
+		for (const [slot, styles] of Object.entries(config.base ?? {})) if (slot !== "root") comp.base[slot] = styles;
+		if (config.variants) for (const [axis, values] of Object.entries(config.variants)) {
+			const axisAcc = {};
+			for (const [val, slots] of Object.entries(values)) {
+				axisAcc[val] = { ...slots.root ?? {} };
+				for (const [slot, styles] of Object.entries(slots)) if (slot !== "root") axisAcc[val][slot] = styles;
+			}
+			comp[axis] = axisAcc;
+		}
+		accessor[name] = comp;
+	}
+	return accessor;
+}
+function createConfigBuilder(data, extensions) {
+	const next = (overrides = {}) => createConfigBuilder({
+		...data,
+		...overrides
+	}, extensions);
+	return {
+		...extensions,
+		_data: data,
+		modes: data.modes,
+		atomic: data.atomic,
+		components: data.components,
+		preflight(enabled = true) {
+			return next({ preflight: enabled });
+		},
+		prefix(value) {
+			return next({ prefix: value });
+		},
+		buildOptions(options) {
+			return next({ buildOptions: options });
+		},
+		defineModes(params) {
+			return createConfigBuilder({
+				...data,
+				modes: [...data.modes, ...params]
+			}, extensions);
+		},
+		defineModifiers(params) {
+			const resolved = typeof params === "function" ? params({
+				tokens: buildTokenReference(data.atomic, data.prefix),
+				macros: buildMacroReference(data.macros)
+			}) : params;
+			return createConfigBuilder({
+				...data,
+				modifiers: [...data.modifiers, ...resolved]
+			}, extensions);
+		},
+		defineMacro(params) {
+			const tokenReference = buildTokenReference(data.atomic, data.prefix);
+			const resolved = typeof params === "function" ? params({ tokens: tokenReference }) : params;
+			const allMacros = {
+				...data.macros,
+				...resolved
+			};
+			const edges = /* @__PURE__ */ new Map();
+			for (const [macroName, macroDef] of Object.entries(allMacros)) {
+				const targets = /* @__PURE__ */ new Set();
+				for (const bag of Object.values(macroDef)) if (bag && typeof bag === "object") {
+					for (const key of Object.keys(bag)) if (key in allMacros) targets.add(key);
+				}
+				if (targets.size > 0) edges.set(macroName, targets);
+			}
+			const visited = /* @__PURE__ */ new Set();
+			const stack = /* @__PURE__ */ new Set();
+			const path = [];
+			function dfs(node) {
+				if (stack.has(node)) {
+					const cycleStart = path.indexOf(node);
+					throw new Error(`Circular macro reference: ${[...path.slice(cycleStart), node].join(" → ")}`);
+				}
+				if (visited.has(node)) return;
+				visited.add(node);
+				stack.add(node);
+				path.push(node);
+				const neighbors = edges.get(node);
+				if (neighbors) for (const neighbor of neighbors) dfs(neighbor);
+				path.pop();
+				stack.delete(node);
+			}
+			for (const node of edges.keys()) dfs(node);
+			return createConfigBuilder({
+				...data,
+				macros: {
+					...data.macros,
+					...resolved
+				}
+			}, extensions);
+		},
+		defineAtomicTokens(params) {
+			return createConfigBuilder({
+				...data,
+				atomic: mergeAtomic(data.atomic, params, "merge")
+			}, extensions);
+		},
+		defineArbitraryTokens(params) {
+			return next({ arbitraryTokens: [...data.arbitraryTokens ?? [], ...params] });
+		},
+		defineMotion(presets) {
+			const tokenReference = buildTokenReference(data.atomic, data.prefix);
+			const resolved = typeof presets === "function" ? presets(tokenReference) : presets;
+			return createConfigBuilder({
+				...data,
+				motion: {
+					...data.motion,
+					...resolved
+				}
+			}, extensions);
+		},
+		defineComponents(params) {
+			const tokenReference = buildTokenReference(data.atomic, data.prefix);
+			const motionReference = buildMotionReference(data.motion);
+			const componentsAccessor = buildComponentsAccessor(data.components);
+			const newComponents = resolveComponentMotionAliases(typeof params === "function" ? params({
+				tokens: tokenReference,
+				motion: motionReference,
+				components: componentsAccessor
+			}) : params, data.motion);
+			validateComponentVariants(newComponents);
+			const mergedComponents = { ...data.components };
+			for (const [name, def] of Object.entries(newComponents)) {
+				const existing = mergedComponents[name];
+				if (existing && typeof existing === "object" && typeof def === "object") mergedComponents[name] = deepMerge(existing, def);
+				else mergedComponents[name] = def;
+			}
+			return next({ components: mergedComponents });
+		},
+		defineGlobalStyles(params) {
+			const tokenReference = buildTokenReference(data.atomic, data.prefix);
+			const newGlobalStyles = typeof params === "function" ? params(tokenReference) : params;
+			return next({ globalStyles: {
+				...data.globalStyles,
+				...newGlobalStyles
+			} });
+		},
+		defineDesignPrinciples(principles) {
+			return next({ designPrinciples: [...data.designPrinciples ?? [], ...principles] });
+		},
+		defineExample(name, examples) {
+			const componentConfig = data.components[name];
+			if (!componentConfig) throw new Error(`defineExample: component "${name}" not found. Available components: ${Object.keys(data.components).join(", ")}`);
+			const variantAxes = Object.keys(componentConfig.variants ?? {});
+			for (const [exampleKey, entry] of Object.entries(examples)) if (entry.each && !variantAxes.includes(entry.each)) throw new Error(`defineExample: "${name}" example "${exampleKey}" references unknown variant axis "${entry.each}". Available axes: ${variantAxes.join(", ") || "(none)"}`);
+			return next({ examples: {
+				...data.examples,
+				[name]: examples
+			} });
+		},
+		compose(...presets) {
+			return createConfigBuilder(presets.reduce((acc, preset) => {
+				if (isComponentDefinition(preset)) validatePresetRequiredTokens(acc, preset);
+				return applyPresetToData(acc, resolvePresetData(preset));
+			}, data), extensions);
+		},
+		defineComponent(name, component, motion) {
+			const tokenReference = buildTokenReference(data.atomic, data.prefix);
+			const resolvedMotion = typeof motion === "function" ? motion(tokenReference) : motion;
+			const motionReference = buildMotionReference({
+				...data.motion,
+				...resolvedMotion ?? {}
+			});
+			const componentsAccessor = buildComponentsAccessor(data.components);
+			const inputComponent = typeof component === "function" ? component({
+				tokens: tokenReference,
+				motion: motionReference,
+				components: componentsAccessor
+			}) : component;
+			const resolvedComponents = resolveComponentMotionAliases({ [name]: inputComponent }, {
+				...data.motion,
+				...resolvedMotion ?? {}
+			});
+			validateComponentVariants(resolvedComponents);
+			return {
+				name,
+				requiredTokens: collectRequiredTokens(data, resolvedComponents, resolvedMotion),
+				components: resolvedComponents,
+				motion: resolvedMotion
+			};
+		},
+		from(input) {
+			return createConfigBuilder({
+				modes: input.modes ?? data.modes,
+				modifiers: input.modifiers ?? data.modifiers,
+				atomic: input.atomic ?? data.atomic,
+				macros: input.macros ?? data.macros,
+				motion: input.motion ?? data.motion,
+				components: input.components ?? data.components,
+				globalStyles: input.globalStyles ?? data.globalStyles,
+				preflight: input.preflight ?? data.preflight,
+				prefix: input.prefix ?? data.prefix,
+				arbitraryTokens: input.arbitraryTokens ?? data.arbitraryTokens,
+				examples: input.examples ?? data.examples,
+				designPrinciples: input.designPrinciples ?? data.designPrinciples
+			}, extensions);
+		},
+		extend(ext) {
+			return createConfigBuilder(data, {
+				...extensions,
+				...ext
+			});
+		},
+		defineRemotionComponents(params) {
+			const tokenReference = buildTokenReference(data.atomic, data.prefix);
+			const motionReference = buildMotionReference(data.motion);
+			const componentsAccessor = buildComponentsAccessor(data.components);
+			const remotionConfig = typeof params === "function" ? params({
+				tokens: tokenReference,
+				motion: motionReference,
+				components: componentsAccessor
+			}) : params;
+			for (const [name, def] of Object.entries(remotionConfig.components)) validateComponentVariants(resolveComponentMotionAliases({ [name]: def.config }, data.motion));
+			return next({ remotion: mergeRemotionConfig(data.remotion, remotionConfig) });
+		},
+		defineRemotionComponent(name, def, motion) {
+			const tokenReference = buildTokenReference(data.atomic, data.prefix);
+			const resolvedMotion = typeof motion === "function" ? motion(tokenReference) : motion;
+			const motionReference = buildMotionReference({
+				...data.motion,
+				...resolvedMotion ?? {}
+			});
+			const componentsAccessor = buildComponentsAccessor(data.components);
+			const resolved = typeof def === "function" ? def({
+				tokens: tokenReference,
+				motion: motionReference,
+				components: componentsAccessor
+			}) : def;
+			const resolvedComponents = resolveComponentMotionAliases({ [name]: resolved.config }, {
+				...data.motion,
+				...resolvedMotion ?? {}
+			});
+			validateComponentVariants(resolvedComponents);
+			return {
+				name,
+				requiredTokens: collectRequiredTokens(data, resolvedComponents, resolvedMotion),
+				components: {},
+				motion: resolvedMotion,
+				remotion: {
+					components: { [name]: resolved },
+					transitions: {},
+					effects: {}
+				}
+			};
+		},
+		defineRemotionTransition(name, def) {
+			const tokenReference = buildTokenReference(data.atomic, data.prefix);
+			const resolved = typeof def === "function" ? def({ tokens: tokenReference }) : def;
+			return {
+				name,
+				requiredTokens: [],
+				components: {},
+				remotion: {
+					components: {},
+					transitions: { [name]: resolved },
+					effects: {}
+				}
+			};
+		},
+		defineRemotionTransitions(params) {
+			const tokenReference = buildTokenReference(data.atomic, data.prefix);
+			const resolved = typeof params === "function" ? params({ tokens: tokenReference }) : params;
+			return next({ remotion: mergeRemotionConfig(data.remotion, {
+				components: {},
+				transitions: resolved
+			}) });
+		}
+	};
+}
+function interpolate(config) {
+	return {
+		__type: "interpolate",
+		output: config.output,
+		extrapolate: config.extrapolate ?? "extend"
+	};
+}
+/**
+* Convert a px value to rem (assuming 16px base).
+*
+* @example rem(14) // '0.875rem'
+*/
+function rem(px) {
+	return `${px / 16}rem`;
+}
+function darker(color, amount) {
+	return `color-mix(in oklch, ${color}, light-dark(black, white) ${amount}%)`;
+}
+function lighter(color, amount) {
+	return `color-mix(in oklch, ${color}, light-dark(white, black) ${amount}%)`;
+}
+const uds = createConfigBuilder({
+	atomic: [],
+	modes: [],
+	modifiers: [],
+	macros: {},
+	motion: {},
+	components: {},
+	globalStyles: {},
+	preflight: true,
+	prefix: "uds",
+	remotion: void 0
+});
+//#endregion
+export { buildMacroReference, buildTokenReference, createConfigBuilder, darker, interpolate, lighter, rem, resolveConfig, uds };

package/dist/config/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { defaultColors } from "./consts/defaultColors.js";
+import { ArbitraryTokenGroup, AtomicToken, BuildOptions, ComponentConfig, DefineComponentInput, DefineComponentMotionInput, ExampleDef, ExampleEntryDef, ExampleLayoutStyles, GlobalStylesDef, InterpolateMarker, ModeGroup, ModifierDef, MotionPresetsDef, UdsConfig, UdsConfigData, buildTokenReference, createConfigBuilder, darker, lighter, resolveConfig } from "./createConfig.js";
+import { SerializedConfig, TokenRef, buildReverseMap, deserializeConfig, serializeConfig } from "./serialize.js";
+import { ComponentsConfig as ComponentsConfig$1 } from "@uds/types";
+export { type ComponentsConfig$1 as ComponentsConfig };

package/dist/config/dist/index.js

@@ -0,0 +1,4 @@
+import "./consts/defaultColors.js";
+import "./component-resolution.js";
+import "./createConfig.js";
+import "./serialize.js";