@yahoo/uds-v5-wip 1.60.0 → 1.62.0

package/dist/config/dist/createConfig.js

@@ -1,625 +0,0 @@
-import { kebabCase } from "../../utils/dist/string-utils/kebabCase.js";
-import { safeTokenName } from "../../utils/dist/string-utils/cssVar.js";
-import "../../utils/dist/index.js";
-import { getConfigurablePropMapping } from "../../core/dist/configurable-prop-helpers.js";
-import "../../core/dist/index.js";
-import { buildMotionReference, resolveComponentMotionAliases, validateComponentVariants } from "./component-resolution.js";
-import { applyPresetToData, deepMerge, mergeAtomic } from "./preset-merge.js";
-import { resolveTokenType, sniffTokenTypeFromValue } from "./resolveTokenTypes.js";
-import { resolveStyleProp } from "./resolveStyleProp.js";
-import { setRegisteredStyleProps } from "./runtime-registry.js";
-//#region ../config/dist/createConfig.js
-/** biome-ignore-all lint/suspicious/noExplicitAny: necessary for dynamic builder to work correctly */
-/**
-* Convert the authored object-keyed input into the internal `ModeGroup[]` shape.
-* Derives `_${optionKey}` modifiers when no explicit `modifier` is provided.
-* Never sets `default: true` — the new API has no concept of a default option;
-* downstream consumers treat "no option active" as the implicit default.
-*/
-function convertModesInputToGroups(input) {
-	const groups = [];
-	for (const [setKey, setValue] of Object.entries(input)) {
-		const options = [];
-		for (const [optionKey, optionValue] of Object.entries(setValue.options)) {
-			const option = {
-				name: optionKey,
-				modifier: optionValue.modifier ?? `_${optionKey}`
-			};
-			if (optionValue.label !== void 0) option.label = optionValue.label;
-			if (optionValue.css !== void 0) option.css = optionValue.css;
-			if (optionValue.media !== void 0) option.media = optionValue.media;
-			options.push(option);
-		}
-		const group = {
-			name: setKey,
-			options
-		};
-		if (setValue.label !== void 0) group.label = setValue.label;
-		groups.push(group);
-	}
-	return groups;
-}
-/** Build a structured token reference object from atomic tokens */
-function buildTokenReference(atomic, configPrefix) {
-	const result = Object.create(null);
-	for (const token of atomic) {
-		const varPrefix = token.cssPrefix ?? getConfigurablePropMapping(token.properties[0])?.defaultVarPrefix;
-		const tokenEntries = Object.create(null);
-		for (const t of token.tokens) {
-			const safeName = safeTokenName(t.name);
-			const cssVarName = configPrefix ? `--${configPrefix}-${varPrefix}-${safeName}` : `--${varPrefix}-${safeName}`;
-			tokenEntries[t.name] = `var(${cssVarName})`;
-		}
-		for (const prop of token.properties) {
-			if (!result[prop]) result[prop] = Object.create(null);
-			Object.assign(result[prop], tokenEntries);
-		}
-		if (varPrefix) {
-			if (!result[varPrefix]) result[varPrefix] = Object.create(null);
-			Object.assign(result[varPrefix], tokenEntries);
-		}
-		if (token.namespace && token.namespace !== varPrefix) {
-			if (!result[token.namespace]) result[token.namespace] = Object.create(null);
-			Object.assign(result[token.namespace], tokenEntries);
-		}
-	}
-	return result;
-}
-/** Build a structured composite-styles reference object for use in defineModifiers context */
-function buildCompositeStylesReference(compositeStyles) {
-	const result = {};
-	for (const [groupName, def] of Object.entries(compositeStyles)) {
-		result[groupName] = {};
-		for (const valueName of Object.keys(def.styles)) result[groupName][valueName] = { className: `${groupName}-${safeTokenName(valueName)}` };
-	}
-	return result;
-}
-/**
-* Resolve `{composite/<group>/<value>}` brace-refs in a modifier `selector`
-* string. Each ref expands to a CSS container style query targeting the
-* composite's custom-property marker:
-*
-*   `{composite/elevation/1}`
-*   →  `@container style(--uds-composite-elevation: 1)`
-*
-* Multiple refs in the same string are supported. Unknown refs (composite
-* group not in config, or value not in that group's styles) pass through
-* unchanged so the caller can spot the typo at use time. See [[UDS-1644]].
-*/
-const COMPOSITE_REF_PATTERN = /\{composite\/([^/{}]+)\/([^/{}]+)\}/g;
-function resolveCompositeRefsInSelector(selector, compositeStyles) {
-	return selector.replace(COMPOSITE_REF_PATTERN, (raw, groupName, valueName) => {
-		const def = compositeStyles[groupName];
-		if (!def || !def.styles[valueName]) return raw;
-		return `@container style(--uds-composite-${safeTokenName(groupName)}: ${safeTokenName(valueName)})`;
-	});
-}
-/**
-* Migrate legacy `macros` JSON (the pre-rename shape) into the new
-* `compositeStyles` shape. Each old key (`elevation`) becomes a `{ label,
-* styles }` def so older serialized configs (in `uds.config.json`,
-* `draft_base_configs.baseConfig`) keep loading until they're rewritten.
-*
-* Returns `undefined` when no legacy data is present so callers can chain
-* a fallback (`?? {}`).
-*/
-function upgradeLegacyMacros(legacy) {
-	if (!legacy || typeof legacy !== "object") return void 0;
-	const out = {};
-	for (const [name, variants] of Object.entries(legacy)) {
-		if (!variants || typeof variants !== "object") continue;
-		out[name] = {
-			label: name,
-			styles: variants
-		};
-	}
-	return Object.keys(out).length > 0 ? out : void 0;
-}
-/**
-* Convert a VarGroupDef into AtomicToken tokens, extracting modifier overrides.
-*
-* Also extracts group-level metadata:
-* - A top-level `$type` on the group → `groupType`
-* - A top-level `$description` on the group → `groupDescription`
-* - A `$type` on an individual token → `type` on that token (overrides group)
-*
-* Metadata keys (`$type`, `$description`) are filtered out of the emitted tokens.
-*/
-function varGroupToTokens(varGroup, knownModifiers) {
-	let groupType;
-	let groupDescription;
-	const tokens = [];
-	for (const [tokenName, rawDef] of Object.entries(varGroup)) {
-		if (tokenName === "$type") {
-			if (typeof rawDef === "string") groupType = rawDef;
-			continue;
-		}
-		if (tokenName === "$description") {
-			if (typeof rawDef === "string") groupDescription = rawDef;
-			continue;
-		}
-		if (rawDef == null || typeof rawDef !== "object") continue;
-		const tokenDef = rawDef;
-		const modifiers = {};
-		for (const [key, val] of Object.entries(tokenDef)) {
-			if (key === "value" || key === "$type" || val === void 0) continue;
-			if (key.startsWith("_") && knownModifiers.has(key)) modifiers[key] = val;
-		}
-		tokens.push({
-			name: tokenName,
-			value: tokenDef.value,
-			...tokenDef.$type ? { type: tokenDef.$type } : {},
-			...Object.keys(modifiers).length > 0 ? { modifiers } : {}
-		});
-	}
-	return {
-		tokens,
-		groupType,
-		groupDescription
-	};
-}
-/**
-* For each var namespace, derive the list of style-prop names that consume
-* it by inverting `registerStyleProps(...).values`. A styleProp with
-* `values: ['{bg}', '{global}']` is recorded as consuming `bg` and `global`;
-* a `{ ref: '{bg}', namespace: 'background' }` namespaced ref counts the
-* same. Token-key refs like `'{spacing.4}'` also count toward `spacing`.
-*/
-function buildNamespaceConsumers(styleProps) {
-	const result = /* @__PURE__ */ new Map();
-	if (!styleProps) return result;
-	const refRe = /^\{([^.{}]+)/;
-	const addConsumer = (namespace, propName) => {
-		const list = result.get(namespace);
-		if (!list) {
-			result.set(namespace, [propName]);
-			return;
-		}
-		if (!list.includes(propName)) list.push(propName);
-	};
-	for (const [propName, prop] of Object.entries(styleProps)) for (const entry of prop.values ?? []) {
-		let raw;
-		if (typeof entry === "string") raw = entry;
-		else if (entry !== null && typeof entry === "object" && "ref" in entry && typeof entry.ref === "string") raw = entry.ref;
-		if (!raw) continue;
-		const match = refRe.exec(raw);
-		if (!match || !match[1]) continue;
-		addConsumer(match[1], propName);
-	}
-	return result;
-}
-/**
-* Synthesize AtomicToken[] from defineVars + registerStyleProps data. For
-* each var namespace, emits an AtomicToken group whose `properties` list is
-* the set of style props that reference that namespace (or any key inside
-* it) via their `values` field. Replaces the older
-* `synthesizeAtomicFromScopesAndVars` once a config has retired
-* `defineScopes` in favor of per-prop `defineStyleProp({ values })`.
-*/
-function synthesizeAtomicFromVarsAndStyleProps(vars, styleProps, modes) {
-	const knownModifiers = /* @__PURE__ */ new Set();
-	for (const mode of modes) for (const option of mode.options) knownModifiers.add(option.modifier);
-	const consumers = buildNamespaceConsumers(styleProps);
-	const result = [];
-	for (const [namespace, varGroup] of Object.entries(vars)) {
-		const { tokens, groupType, groupDescription } = varGroupToTokens(varGroup, knownModifiers);
-		const properties = consumers.get(namespace) ?? [];
-		const cssPfx = kebabCase(namespace);
-		const resolvedGroupType = resolveTokenType({ explicit: groupType });
-		if (resolvedGroupType && resolvedGroupType !== "string") for (const token of tokens) {
-			if (token.type) continue;
-			if (sniffTokenTypeFromValue(token.value) === "string") token.type = "string";
-		}
-		result.push({
-			properties,
-			tokens,
-			namespace,
-			cssPrefix: cssPfx,
-			...resolvedGroupType ? { type: resolvedGroupType } : {},
-			...groupDescription ? { description: groupDescription } : {}
-		});
-	}
-	return result;
-}
-/** Extract the raw config data from a builder instance */
-function resolveConfig(config) {
-	let configData;
-	if (config._data) configData = config._data;
-	else configData = {
-		modes: config.modes ?? [],
-		modifiers: config.modifiers ?? [],
-		atomic: config.atomic ?? [],
-		compositeStyles: config.compositeStyles ?? upgradeLegacyMacros(config.macros) ?? {},
-		motion: config.motion ?? {},
-		components: config.components ?? {},
-		globalStyles: config.globalStyles ?? {},
-		preflight: config.preflight ?? true,
-		prefix: config.prefix ?? "uds",
-		buildOptions: config.buildOptions,
-		examples: config.examples,
-		designPrinciples: config.designPrinciples,
-		vars: config.vars,
-		presetTokenNames: config.presetTokenNames,
-		styleProps: config.styleProps
-	};
-	if (configData.vars) {
-		const synthesized = synthesizeAtomicFromVarsAndStyleProps(configData.vars, configData.styleProps, configData.modes);
-		const atomic = mergeAtomic(configData.atomic, synthesized, "merge");
-		configData = {
-			...configData,
-			atomic
-		};
-	}
-	if (configData.styleProps) {
-		const entries = Object.entries(configData.styleProps);
-		if (entries.length > 0) {
-			const resolved = entries.map(([propName, prop]) => resolveStyleProp(propName, prop, configData));
-			configData = {
-				...configData,
-				resolvedStyleProps: resolved
-			};
-		}
-		if (configData.styleProps) setRegisteredStyleProps(configData.styleProps);
-	}
-	return configData;
-}
-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: [],
-		compositeStyles: {},
-		motion: input.motion ?? {},
-		components: input.components,
-		globalStyles: {},
-		preflight: true,
-		prefix: "uds"
-	};
-	if ("defineVars" in input) return resolveConfig(input);
-	return {
-		modes: input.modes ?? [],
-		modifiers: input.modifiers ?? [],
-		atomic: input.atomic ?? [],
-		compositeStyles: input.compositeStyles ?? {},
-		motion: input.motion ?? {},
-		components: input.components ?? {},
-		globalStyles: input.globalStyles ?? {},
-		preflight: input.preflight ?? true,
-		prefix: input.prefix ?? "uds",
-		examples: input.examples,
-		designPrinciples: input.designPrinciples,
-		vars: input.vars,
-		presetTokenNames: input.presetTokenNames
-	};
-}
-function extractVarReferences(value) {
-	if (typeof value !== "string") return [];
-	return value.match(/var\([^()]+\)/g) ?? [];
-}
-function collectRequiredTokensFromObject(value, out) {
-	if (value == null) return;
-	if (typeof value === "string") {
-		const refs = extractVarReferences(value);
-		for (const ref of refs) out.add(ref);
-		return;
-	}
-	if (Array.isArray(value)) {
-		for (const item of value) collectRequiredTokensFromObject(item, out);
-		return;
-	}
-	if (typeof value === "object") for (const child of Object.values(value)) collectRequiredTokensFromObject(child, out);
-}
-/**
-* Collect the set of `var(--uds-X-Y)` references a component preset uses, so
-* downstream `compose()` calls can verify the target config emits those
-* variables. Storing raw var refs (instead of `propName.tokenKey` pairs)
-* decouples the check from prop/namespace association lookups — only the
-* actual CSS variable surface needs to be compatible.
-*/
-function collectRequiredTokens(_sourceData, components, motion) {
-	const out = /* @__PURE__ */ new Set();
-	collectRequiredTokensFromObject(components, out);
-	if (motion) collectRequiredTokensFromObject(motion, out);
-	return Array.from(out).sort();
-}
-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) {
-			const newGroups = convertModesInputToGroups(params);
-			return createConfigBuilder({
-				...data,
-				modes: [...data.modes, ...newGroups]
-			}, extensions);
-		},
-		defineModifiers(params) {
-			const resolvedWithComposites = (typeof params === "function" ? params({
-				tokens: buildTokenReference(data.atomic, data.prefix),
-				compositeStyles: buildCompositeStylesReference(data.compositeStyles)
-			}) : params).map((def) => ({
-				...def,
-				selector: resolveCompositeRefsInSelector(def.selector, data.compositeStyles)
-			}));
-			return createConfigBuilder({
-				...data,
-				modifiers: [...data.modifiers, ...resolvedWithComposites]
-			}, extensions);
-		},
-		defineCompositeStyles(params) {
-			const tokenReference = buildTokenReference(data.atomic, data.prefix);
-			const resolved = typeof params === "function" ? params({ tokens: tokenReference }) : params;
-			const allCompositeStyles = {
-				...data.compositeStyles,
-				...resolved
-			};
-			const edges = /* @__PURE__ */ new Map();
-			for (const [groupName, def] of Object.entries(allCompositeStyles)) {
-				const targets = /* @__PURE__ */ new Set();
-				for (const bag of Object.values(def.styles)) if (bag && typeof bag === "object") {
-					for (const key of Object.keys(bag)) if (key in allCompositeStyles) targets.add(key);
-				}
-				if (targets.size > 0) edges.set(groupName, 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 composite style 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,
-				compositeStyles: {
-					...data.compositeStyles,
-					...resolved
-				}
-			}, extensions);
-		},
-		registerStyleProps(props) {
-			const expanded = {};
-			for (const [propName, prop] of Object.entries(props)) {
-				expanded[propName] = prop;
-				if (prop.opacityPair) {
-					const sibling = {
-						kind: "styleProp",
-						cssProperty: prop.cssProperty,
-						classPrefix: "",
-						values: prop.opacityPair.values,
-						arbitrary: void 0,
-						cssType: prop.cssType,
-						metadata: { label: prop.metadata?.label ? `${prop.metadata.label} opacity` : void 0 },
-						_pairedWith: propName,
-						_separator: prop.opacityPair.separator
-					};
-					expanded[prop.opacityPair.as] = sibling;
-				}
-			}
-			const mergedStyleProps = {
-				...data.styleProps ?? {},
-				...expanded
-			};
-			const updates = { styleProps: mergedStyleProps };
-			if (data.vars) updates.atomic = mergeAtomic([], synthesizeAtomicFromVarsAndStyleProps(data.vars, mergedStyleProps, data.modes ?? []), "override");
-			return next(updates);
-		},
-		registerComponents(configs) {
-			const normalized = {};
-			for (const [name, entry] of Object.entries(configs)) {
-				const config = typeof entry === "function" && "__config" in entry ? entry.__config : entry;
-				Object.defineProperty(config, "__componentName", {
-					enumerable: false,
-					configurable: true,
-					writable: true,
-					value: name
-				});
-				normalized[name] = config;
-			}
-			return next({ componentConfigs: {
-				...data.componentConfigs ?? {},
-				...normalized
-			} });
-		},
-		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) => {
-				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,
-				compositeStyles: input.compositeStyles ?? data.compositeStyles,
-				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,
-				examples: input.examples ?? data.examples,
-				designPrinciples: input.designPrinciples ?? data.designPrinciples,
-				vars: input.vars ?? data.vars,
-				presetTokenNames: input.presetTokenNames ?? data.presetTokenNames
-			}, extensions);
-		},
-		extend(ext) {
-			return createConfigBuilder(data, {
-				...extensions,
-				...ext
-			});
-		},
-		defineVars(vars) {
-			const merged = { ...data.vars };
-			for (const [namespace, group] of Object.entries(vars)) merged[namespace] = {
-				...merged[namespace] ?? {},
-				...group
-			};
-			const synthesized = synthesizeAtomicFromVarsAndStyleProps(merged, data.styleProps, data.modes ?? []);
-			const updates = {
-				vars: merged,
-				atomic: mergeAtomic(data.atomic, synthesized, "merge")
-			};
-			return createConfigBuilder({
-				...data,
-				...updates
-			}, extensions);
-		}
-	};
-}
-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: [],
-	compositeStyles: {},
-	motion: {},
-	components: {},
-	globalStyles: {},
-	preflight: true,
-	prefix: "uds"
-});
-//#endregion
-export { buildCompositeStylesReference, buildTokenReference, convertModesInputToGroups, createConfigBuilder, darker, interpolate, lighter, rem, resolveConfig, uds };

package/dist/config/dist/defineComponent.d.ts

@@ -1,24 +0,0 @@
-import { ComponentConfigValue, HtmlTag, LayerInput } from "./component-config.js";
-import { Props } from "./Props.js";
-import { ReactNode } from "react";
-
-//#region ../config/dist/defineComponent.d.ts
-//#region src/defineComponent.d.ts
-/**
- * A React component bound to a `defineComponent` config, with the
- * source config attached as a phantom type slot. Tools (codegen,
- * devtools) recover the config at runtime via the non-enumerable
- * `__config` property; the type slot lets consumers read it at the
- * type level too — `Props<typeof Box['__config']>`.
- */
-type BoundComponent<TConfig extends ComponentConfigValue<Record<string, LayerInput>, any, HtmlTag | undefined>, TExtra extends Record<string, unknown> = {}> = React.FC<Props<TConfig> & TExtra> & {
-  readonly __config: TConfig;
-};
-/**
- * A `defineComponent({...})` config value with a `.render(fn)` builder
- * method bolted on. The builder is non-enumerable so JSON serialization
- * still produces pure data — codegen can read `__kind`, `layers`,
- * `props`, and `defaultProps` without seeing the render hook.
- */
-//#endregion
-export { BoundComponent };

package/dist/config/dist/defineComponent.js

@@ -1,2 +0,0 @@
-import "./createComponent.js";
-import "react";