@yahoo/uds-create-config 4.55.1 → 4.56.0

package/dist/spec/index.d.ts

@@ -1,7 +1,7 @@
 import { GraftableElement, GraftableSpec, PreviewElement, PreviewRef, PreviewSpecNode, PreviewValue, graftPreviewElements, graftSlotContent, hasPreviewElementDeep, isComponentRef, isPreviewElement, isPreviewRef, previewElementNodes, previewElementType } from "./preview-elements.js";
 import { Slot, SlotCell } from "./slot.js";
 import { Cell, CellSlot } from "./cell.js";
-import { DocumentRename, RewritableSpec, SpecRewrite, documentRenamesFromPatches, rewriteSpecRefs } from "./rewrite-refs.js";
+import { DocumentRename, RewritableElement, RewritableSpec, SpecRewrite, composeRenames, documentRenamesFromPatches, documentRenamesFromSource, rewriteSpecRefs } from "./rewrite-refs.js";
 import { applyForcedModifiers, collectForcedModifierProps } from "./apply-forced-modifiers.js";
 import { AcceptsChildNodes, ChildNodesClassification, ClassifyChildNodes, buildAcceptsChildNodes, buildClassifyChildNodes, stripInjectedSlots, withContainerChildSlots, withEmptyNodeSlots, withRenderSlots } from "./empty-node-slots.js";
 import { CollapseTextLabelsResult, CollapsedTextLabel, collapseWrappedTextLabels } from "./collapse-text-labels.js";
@@ -28,4 +28,4 @@ import { SpecToJsxOptions, SpecToJsxResult, specToJsx } from "./specToJsx.js";
  *  element, without changing the rendered layer hierarchy. */
 declare const SYNTHETIC_TEXT_SLOT_PROP = "data-uds-synthetic-text-slot";
 //#endregion
-export { type AcceptsChildNodes, type Cell, type CellSlot, type ChildNodesClassification, type ClassifyChildNodes, type CollapseTextLabelsResult, type CollapsedTextLabel, type DocumentRename, type GlyphJsxForm, type GlyphNodeResolver, type GraftableElement, type GraftableSpec, type JsxToSpecOptions, type PreviewElement, type PreviewRef, type PreviewSpecNode, type PreviewValue, type RewritableSpec, SYNTHETIC_TEXT_SLOT_PROP, type Slot, type SlotCell, type SpecRewrite, type SpecToJsxOptions, type SpecToJsxResult, UNRESOLVED, applyForcedModifiers, buildAcceptsChildNodes, buildClassifyChildNodes, collapseWrappedTextLabels, collectForcedModifierProps, documentRenamesFromPatches, glyphJsxForm, glyphMemberOf, graftPreviewElements, graftSlotContent, hasPreviewElementDeep, hasUnresolvedProps, isComponentRef, isPreviewElement, isPreviewRef, jsxIdentifier, jsxToSpec, parseGlyphType, previewElementNodes, previewElementType, rewriteSpecRefs, specToJsx, stripInjectedSlots, stripUnresolvedProps, withContainerChildSlots, withEmptyNodeSlots, withRenderSlots };
+export { type AcceptsChildNodes, type Cell, type CellSlot, type ChildNodesClassification, type ClassifyChildNodes, type CollapseTextLabelsResult, type CollapsedTextLabel, type DocumentRename, type GlyphJsxForm, type GlyphNodeResolver, type GraftableElement, type GraftableSpec, type JsxToSpecOptions, type PreviewElement, type PreviewRef, type PreviewSpecNode, type PreviewValue, type RewritableElement, type RewritableSpec, SYNTHETIC_TEXT_SLOT_PROP, type Slot, type SlotCell, type SpecRewrite, type SpecToJsxOptions, type SpecToJsxResult, UNRESOLVED, applyForcedModifiers, buildAcceptsChildNodes, buildClassifyChildNodes, collapseWrappedTextLabels, collectForcedModifierProps, composeRenames, documentRenamesFromPatches, documentRenamesFromSource, glyphJsxForm, glyphMemberOf, graftPreviewElements, graftSlotContent, hasPreviewElementDeep, hasUnresolvedProps, isComponentRef, isPreviewElement, isPreviewRef, jsxIdentifier, jsxToSpec, parseGlyphType, previewElementNodes, previewElementType, rewriteSpecRefs, specToJsx, stripInjectedSlots, stripUnresolvedProps, withContainerChildSlots, withEmptyNodeSlots, withRenderSlots };

package/dist/spec/index.js

@@ -4,7 +4,7 @@ import { applyForcedModifiers, collectForcedModifierProps } from "./apply-forced
 import { collapseWrappedTextLabels } from "./collapse-text-labels.js";
 import { buildAcceptsChildNodes, buildClassifyChildNodes, stripInjectedSlots, withContainerChildSlots, withEmptyNodeSlots, withRenderSlots } from "./empty-node-slots.js";
 import { UNRESOLVED, hasUnresolvedProps, jsxToSpec, stripUnresolvedProps } from "./jsxToSpec.js";
-import { documentRenamesFromPatches, rewriteSpecRefs } from "./rewrite-refs.js";
+import { composeRenames, documentRenamesFromPatches, documentRenamesFromSource, rewriteSpecRefs } from "./rewrite-refs.js";
 import { specToJsx } from "./specToJsx.js";
 //#region src/spec/index.ts
 /**
@@ -25,4 +25,4 @@ import { specToJsx } from "./specToJsx.js";
 *  element, without changing the rendered layer hierarchy. */
 const SYNTHETIC_TEXT_SLOT_PROP = "data-uds-synthetic-text-slot";
 //#endregion
-export { SYNTHETIC_TEXT_SLOT_PROP, UNRESOLVED, applyForcedModifiers, buildAcceptsChildNodes, buildClassifyChildNodes, collapseWrappedTextLabels, collectForcedModifierProps, documentRenamesFromPatches, glyphJsxForm, glyphMemberOf, graftPreviewElements, graftSlotContent, hasPreviewElementDeep, hasUnresolvedProps, isComponentRef, isPreviewElement, isPreviewRef, jsxIdentifier, jsxToSpec, parseGlyphType, previewElementNodes, previewElementType, rewriteSpecRefs, specToJsx, stripInjectedSlots, stripUnresolvedProps, withContainerChildSlots, withEmptyNodeSlots, withRenderSlots };
+export { SYNTHETIC_TEXT_SLOT_PROP, UNRESOLVED, applyForcedModifiers, buildAcceptsChildNodes, buildClassifyChildNodes, collapseWrappedTextLabels, collectForcedModifierProps, composeRenames, documentRenamesFromPatches, documentRenamesFromSource, glyphJsxForm, glyphMemberOf, graftPreviewElements, graftSlotContent, hasPreviewElementDeep, hasUnresolvedProps, isComponentRef, isPreviewElement, isPreviewRef, jsxIdentifier, jsxToSpec, parseGlyphType, previewElementNodes, previewElementType, rewriteSpecRefs, specToJsx, stripInjectedSlots, stripUnresolvedProps, withContainerChildSlots, withEmptyNodeSlots, withRenderSlots };

package/dist/spec/rewrite-refs.d.ts

@@ -47,12 +47,39 @@ type DocumentRename = /** A component's path — `element.type` and a node's own
  * last name if the pairs are applied in the order they were made.
  */
 declare function documentRenamesFromPatches(patches: readonly Record<string, unknown>[]): DocumentRename[];
+/**
+ * A source's renames as a consumer's documents see them, once a pin moves from the source `before`
+ * was built against to the one `after` is.
+ *
+ * Only a rename of a row `before` inherited through `slug` comes through: a local row at the same
+ * path shadows the source and keeps its name, and a hand-written alias is a pointer of this config's
+ * own. A component-scoped rename follows its component, since the consumer's row for it is a pointer
+ * whose props and layers are the source's. The inherited set is tracked through the list, so a chain
+ * or a swap lands where the source did. A destination `after` does not hold as a row inherited through
+ * `slug` is refused: written into documents, it would name nothing they can resolve.
+ */
+declare function documentRenamesFromSource({
+  before,
+  after,
+  slug,
+  renames
+}: {
+  before: Config;
+  after: Config;
+  slug: string;
+  renames: readonly DocumentRename[];
+}): DocumentRename[];
+/** Fold adjacent rename steps without moving them past operations that can depend on intermediate names. */
+declare function composeRenames(renames: readonly DocumentRename[]): DocumentRename[];
 /** A spec as this reads it: the structural subset, loose because the rows are whatever was written months ago. */
 interface RewritableSpec {
-  elements?: Record<string, {
-    type?: unknown;
-    props?: Record<string, unknown>;
-  } | undefined>;
+  elements?: Record<string, RewritableElement | undefined>;
+}
+/** One element's rewritable positions: its type, its props bag, and the slot fills keyed by slot prop. */
+interface RewritableElement {
+  type?: unknown;
+  props?: Record<string, unknown>;
+  slots?: Record<string, unknown>;
 }
 interface SpecRewrite {
   readonly spec: RewritableSpec;
@@ -67,4 +94,4 @@ interface SpecRewrite {
  */
 declare function rewriteSpecRefs(config: Config, spec: RewritableSpec, renames: readonly DocumentRename[]): SpecRewrite;
 //#endregion
-export { DocumentRename, RewritableSpec, SpecRewrite, documentRenamesFromPatches, rewriteSpecRefs };
+export { DocumentRename, RewritableElement, RewritableSpec, SpecRewrite, composeRenames, documentRenamesFromPatches, documentRenamesFromSource, rewriteSpecRefs };

package/dist/spec/rewrite-refs.js

@@ -1,6 +1,5 @@
-import { isRef, kindOf, pathOf } from "../framework/utils/refs.js";
-import { StyleProperty } from "../entities/system/StyleProperty.js";
-import { propOwner, resolveComponentProps } from "../framework/projections.js";
+import { isMintedRow, isRef, kindOf, pathOf, sourceOf } from "../framework/utils/refs.js";
+import { propOwner, resolveComponentProps, stylePropLeafForToken, stylePropTokenPath } from "../framework/projections.js";
 import { Component } from "../entities/system/Component.js";
 //#region src/spec/rewrite-refs.ts
 /**
@@ -105,6 +104,69 @@ function documentRenamesFromPatches(patches) {
 	}
 	return renames;
 }
+/**
+* A source's renames as a consumer's documents see them, once a pin moves from the source `before`
+* was built against to the one `after` is.
+*
+* Only a rename of a row `before` inherited through `slug` comes through: a local row at the same
+* path shadows the source and keeps its name, and a hand-written alias is a pointer of this config's
+* own. A component-scoped rename follows its component, since the consumer's row for it is a pointer
+* whose props and layers are the source's. The inherited set is tracked through the list, so a chain
+* or a swap lands where the source did. A destination `after` does not hold as a row inherited through
+* `slug` is refused: written into documents, it would name nothing they can resolve.
+*/
+function documentRenamesFromSource({ before, after, slug, renames }) {
+	const inherited = /* @__PURE__ */ new Set();
+	for (const kind of before.ownedKinds()) for (const entity of before.list(kind)) {
+		const body = before.storedBody(kind, entity.path);
+		if (isMintedRow(body) && isRef(body) && sourceOf(body) === slug) inherited.add(`${kind}:${entity.path}`);
+	}
+	const projected = [];
+	const moved = /* @__PURE__ */ new Set();
+	for (const rename of renames) {
+		if ("component" in rename) {
+			if (inherited.has(`component:${rename.component}`)) projected.push(rename);
+			continue;
+		}
+		const from = `${rename.kind}:${rename.from}`;
+		const to = `${rename.kind}:${rename.to}`;
+		if (!inherited.has(from)) continue;
+		inherited.delete(from);
+		inherited.add(to);
+		moved.delete(from);
+		moved.add(to);
+		projected.push(rename);
+	}
+	for (const target of moved) {
+		const body = after.storedBody(kindOf(target), pathOf(target));
+		if (!isMintedRow(body) || !isRef(body) || sourceOf(body) !== slug || pathOf(body) !== pathOf(target)) throw new Error(`The linked rename destination ${target} is not inherited from ${slug}.`);
+	}
+	return projected;
+}
+/** Fold adjacent rename steps without moving them past operations that can depend on intermediate names. */
+function composeRenames(renames) {
+	const out = [];
+	for (const rename of renames) {
+		const prior = out.at(-1);
+		if (!prior || !sameScope(prior, rename) || prior.to !== rename.from) {
+			out.push(rename);
+			continue;
+		}
+		out.pop();
+		if (prior.from !== rename.to) out.push({
+			...prior,
+			to: rename.to
+		});
+	}
+	return out;
+}
+/** Whether two renames move names in the same namespace, so one's `to` can be the other's `from`. */
+function sameScope(a, b) {
+	if (a.kind !== b.kind) return false;
+	if ("component" in a && "component" in b && a.component !== b.component) return false;
+	if ("prop" in a && "prop" in b && a.prop !== b.prop) return false;
+	return true;
+}
 /** Whether a stored `type` names this component path, in either form it may be written in. */
 function namesComponent(type, path) {
 	if (typeof type !== "string") return false;
@@ -122,12 +184,14 @@ function boundStylePropPath(declaration) {
 	const decl = declaration;
 	return decl?.type === "styleProperty" && isRef(decl.value) ? pathOf(decl.value.__ref) : void 0;
 }
-/** The token GROUP a prop declaration draws its values from, if it draws from one. */
-function tokenGroupOf(config, declaration) {
-	const decl = declaration;
-	if (decl?.type !== "styleProperty" || !isRef(decl.value)) return;
-	const styleProp = StyleProperty.get(config, pathOf(decl.value.__ref));
-	for (const value of styleProp?.values ?? []) if (isRef(value) && kindOf(value.__ref) === "token") return pathOf(value.__ref);
+/**
+* The style property a bag key reaches on this scope: the one its declaration binds, or the key itself
+* when the scope declares nothing under it (an intrinsic tag, or a style prop set directly).
+*/
+function stylePropFor(config, scope, key) {
+	const declaration = scope.declared[key];
+	if (declaration === void 0) return config.resolve("style-property", key) ? key : void 0;
+	return boundStylePropPath(declaration);
 }
 /** The prop a call site overrides a component's inner layers through — see `deriveSpec`, which spreads each of
 *  its bags onto the node whose layer the key names. */
@@ -139,13 +203,17 @@ function nestedBag(value) {
 /**
 * The nested props bag a modifier block holds — `undefined` for anything else in the bag.
 *
-* The `_` prefix is the whole test, which is the same test `styleDeclarations` and the prop validator make. A
-* key naming a modifier the config no longer holds still reads as a block: an unresolvable one is a document
-* that needs repairing, not a reason to leave the props inside it un-renamed.
+* The key is `_` plus the modifier's leaf (`state/hover` is `_hover`; leaves are unique by declaration),
+* and only a key the config knows as a modifier is a block: authored bags carry other `_`-prefixed
+* members (`_TOKENS`) that hold no props. A modifier this batch is renaming resolves under either name,
+* since the config may be on either side of the rename.
 */
-function modifierBlock(key, value) {
-	return key.startsWith("_") ? nestedBag(value) : void 0;
+function modifierBlock(config, key, value, renames) {
+	if (!key.startsWith("_")) return void 0;
+	const leaf = key.slice(1);
+	return config.resolve("modifier", leaf) !== void 0 || renames.some((rename) => rename.kind === "modifier" && (leafOf(rename.from) === leaf || leafOf(rename.to) === leaf)) ? nestedBag(value) : void 0;
 }
+const leafOf = (path) => path.slice(path.lastIndexOf("/") + 1);
 const INTRINSIC = {
 	component: void 0,
 	declared: {}
@@ -169,6 +237,22 @@ function withRenamedKey(props, from, to) {
 	return out;
 }
 /**
+* Whether a component-scoped rename reaches a bag on `scope`.
+*
+* It reaches every component that EXPOSES the renamed prop, not only the one that DECLARES it. `HStack`
+* exposes `Box`'s props through `inherits`, so `<HStack gap="2">` is a position a rename of `Box.gap`
+* has to move — and scoping by `element.type` walked past all of them (7,375 such positions across 32
+* components on the real system). The owner's own elements take the original path untouched, so this
+* only ever ADDS matches.
+*/
+function reachesScope(config, scope, rename) {
+	if (!scope.component) return false;
+	if (scope.component === rename.component) return true;
+	const target = rename.kind === "component-prop" ? rename.to : rename.prop;
+	if (!(propOwner(config, scope.component, target) === rename.component || rename.kind === "component-prop" && propOwner(config, scope.component, rename.from) === rename.component)) return false;
+	return !(rename.kind === "component-prop" && propOwner(config, scope.component, rename.from) === scope.component);
+}
+/**
 * One rename applied to the keys and values of ONE bag — `undefined` when it matched nothing there.
 *
 * Everything scoped to a component is scoped to THIS bag's component, which is the element's for its own props
@@ -176,18 +260,11 @@ function withRenamedKey(props, from, to) {
 */
 function rewriteOwnEntries(config, scope, props, rename) {
 	if (rename.kind === "layer") return void 0;
-	if (rename.kind === "component-prop" || rename.kind === "variant-value") {
-		if (!scope.component) return void 0;
-		if (scope.component !== rename.component) {
-			const target = rename.kind === "component-prop" ? rename.to : rename.prop;
-			if (!(propOwner(config, scope.component, target) === rename.component || rename.kind === "component-prop" && propOwner(config, scope.component, rename.from) === rename.component)) return void 0;
-			if (rename.kind === "component-prop" && propOwner(config, scope.component, rename.from) === scope.component) return;
-		}
-	}
+	if ((rename.kind === "component-prop" || rename.kind === "variant-value") && !reachesScope(config, scope, rename)) return;
 	const declared = scope.declared;
 	if (rename.kind === "modifier") {
-		const from = `_${rename.from}`;
-		return from in props ? withRenamedKey(props, from, `_${rename.to}`) : void 0;
+		const from = `_${leafOf(rename.from)}`;
+		return from in props ? withRenamedKey(props, from, `_${leafOf(rename.to)}`) : void 0;
 	}
 	if (rename.kind === "component-prop") return rename.from in props ? withRenamedKey(props, rename.from, rename.to) : void 0;
 	if (rename.kind === "variant-value") return props[rename.prop] === rename.from ? {
@@ -200,33 +277,51 @@ function rewriteOwnEntries(config, scope, props, rename) {
 		if (declaration !== void 0 && boundStylePropPath(declaration) !== rename.from) return;
 		return withRenamedKey(props, rename.from, rename.to);
 	}
-	const group = rename.from.slice(0, rename.from.lastIndexOf("/"));
-	const leaf = rename.from.slice(rename.from.lastIndexOf("/") + 1);
-	const toLeaf = rename.to.slice(rename.to.lastIndexOf("/") + 1);
-	if (!group) return void 0;
 	let next;
 	for (const [prop, value] of Object.entries(props)) {
-		if (value !== leaf) continue;
-		if (tokenGroupOf(config, declared[prop]) !== group) continue;
+		if (typeof value !== "string") continue;
+		const styleProp = stylePropFor(config, scope, prop);
+		if (!styleProp) continue;
+		const names = stylePropTokenPath(config, styleProp, value);
+		if (names !== rename.from && names !== rename.to) {
+			if (!spellsUnderDomain(config, styleProp, value, rename.from)) continue;
+		} else if (names === rename.to) continue;
+		const toLeaf = stylePropLeafForToken(config, styleProp, rename.to) ?? relativeSpelling(value, rename.from, rename.to);
+		if (toLeaf === void 0 || toLeaf === value) continue;
 		next ??= { ...props };
 		next[prop] = toLeaf;
 	}
 	return next;
 }
 /**
+* Whether `value` is how `tokenPath` would be spelled under one of `styleProp`'s token groups, asked
+* when the property no longer lists that token (the config is already past the rename).
+*/
+function spellsUnderDomain(config, styleProp, value, tokenPath) {
+	if (!tokenPath.endsWith(`/${value}`) && tokenPath !== value) return false;
+	const group = tokenPath.slice(0, tokenPath.length - value.length - 1);
+	return ((config.resolve("style-property", styleProp)?.toJSON())?.values ?? []).some((entry) => isRef(entry) && kindOf(entry.__ref) === "token" && pathOf(entry.__ref) === group);
+}
+/** `to` spelled the way `value` spelled `from`: the same group prefix removed. */
+function relativeSpelling(value, from, to) {
+	if (!from.endsWith(`/${value}`) && from !== value) return void 0;
+	const group = from.slice(0, from.length - value.length);
+	return to.startsWith(group) ? to.slice(group.length) : void 0;
+}
+/**
 * One rename applied to a props bag, to every modifier block nested inside it, and to every layer override under
 * its `layerProps` — at any depth.
 *
 * `undefined` when nothing matched, so a caller can leave the element it came from untouched.
 */
-function rewriteProps(config, scope, props, rename) {
+function rewriteProps(config, scope, props, rename, batch) {
 	let next = rewriteOwnEntries(config, scope, props, rename);
 	for (const [key, value] of Object.entries(next ?? props)) {
 		let rewritten;
-		if (key === LAYER_PROPS) rewritten = rewriteLayerProps(config, scope, value, rename);
+		if (key === LAYER_PROPS) rewritten = rewriteLayerProps(config, scope, value, rename, batch);
 		else {
-			const block = modifierBlock(key, value);
-			rewritten = block ? rewriteProps(config, scope, block, rename) : void 0;
+			const block = modifierBlock(config, key, value, batch);
+			rewritten = block ? rewriteProps(config, scope, block, rename, batch) : void 0;
 		}
 		if (!rewritten) continue;
 		next ??= { ...props };
@@ -241,7 +336,7 @@ function rewriteProps(config, scope, props, rename) {
 * The key rename is the only thing here scoped to the enclosing component rather than to the bag's own — a layer
 * name means nothing on its own, and two components' `text` layers are unrelated.
 */
-function rewriteLayerProps(config, scope, layerProps, rename) {
+function rewriteLayerProps(config, scope, layerProps, rename, batch) {
 	const bags = nestedBag(layerProps);
 	if (!bags) return void 0;
 	let next;
@@ -249,7 +344,7 @@ function rewriteLayerProps(config, scope, layerProps, rename) {
 	for (const [layer, value] of Object.entries(next ?? bags)) {
 		const bag = nestedBag(value);
 		if (!bag) continue;
-		const rewritten = rewriteProps(config, layerScope(config, scope, layer), bag, rename);
+		const rewritten = rewriteProps(config, layerScope(config, scope, layer), bag, rename, batch);
 		if (!rewritten) continue;
 		next ??= { ...bags };
 		next[layer] = rewritten;
@@ -273,18 +368,32 @@ function rewriteSpecRefs(config, spec, renames) {
 		if (!element) continue;
 		let type = element.type;
 		let props = element.props;
+		let slots = element.slots;
 		let touched = 0;
-		const scope = scopeFor(config, componentOf(element.type));
+		let current = componentOf(element.type);
+		const declaredFor = (path) => {
+			const own = scopeFor(config, path);
+			if (Object.keys(own.declared).length > 0 || !path) return own;
+			return {
+				component: path,
+				declared: scopeFor(config, renames.filter((r) => r.kind === "component").reduce((at, r) => r.from === at ? r.to : at, path)).declared
+			};
+		};
 		for (const rename of renames) {
 			if (rename.from === rename.to) continue;
 			if (rename.kind === "component") {
 				if (!namesComponent(type, rename.from)) continue;
 				type = typeof type === "string" && type.includes(":") ? `component:${rename.to}` : rename.to;
+				current = rename.to;
 				touched++;
 				continue;
 			}
+			if (rename.kind === "component-prop" && slots && rename.from in slots && reachesScope(config, declaredFor(current), rename)) {
+				slots = withRenamedKey(slots, rename.from, rename.to);
+				touched++;
+			}
 			if (!props) continue;
-			const next = rewriteProps(config, scope, props, rename);
+			const next = rewriteProps(config, declaredFor(current), props, rename, renames);
 			if (!next) continue;
 			props = next;
 			touched++;
@@ -294,7 +403,8 @@ function rewriteSpecRefs(config, spec, renames) {
 		elements[key] = {
 			...element,
 			...type !== void 0 ? { type } : {},
-			...props ? { props } : {}
+			...props ? { props } : {},
+			...slots ? { slots } : {}
 		};
 		changed += touched;
 	}
@@ -310,4 +420,4 @@ function rewriteSpecRefs(config, spec, renames) {
 	};
 }
 //#endregion
-export { documentRenamesFromPatches, rewriteSpecRefs };
+export { composeRenames, documentRenamesFromPatches, documentRenamesFromSource, rewriteSpecRefs };