@yahoo/uds-create-config 4.39.1 → 4.40.0

package/dist/configs/react-native-system.d.ts

@@ -92,14 +92,14 @@ declare const ReactNativeSystemDefinition: ConfigClass<{
       filter: "filter";
       transform: "transform";
       position: "position";
+      color: "color";
+      inset: "inset";
       end: "end";
       start: "start";
       bottom: "bottom";
       left: "left";
       right: "right";
       top: "top";
-      color: "color";
-      inset: "inset";
       flex: "flex";
       cursor: "cursor";
       direction: "direction";

package/dist/entities/native/NativeStyleProperty.d.ts

@@ -9,14 +9,14 @@ declare const rnStyleKey: z.ZodEnum<{
   filter: "filter";
   transform: "transform";
   position: "position";
+  color: "color";
+  inset: "inset";
   end: "end";
   start: "start";
   bottom: "bottom";
   left: "left";
   right: "right";
   top: "top";
-  color: "color";
-  inset: "inset";
   flex: "flex";
   cursor: "cursor";
   direction: "direction";
@@ -176,14 +176,14 @@ declare const NativeStyleProperty: EntityClass<z.ZodObject<Omit<{
     filter: "filter";
     transform: "transform";
     position: "position";
+    color: "color";
+    inset: "inset";
     end: "end";
     start: "start";
     bottom: "bottom";
     left: "left";
     right: "right";
     top: "top";
-    color: "color";
-    inset: "inset";
     flex: "flex";
     cursor: "cursor";
     direction: "direction";

package/dist/entities/system/Component.d.ts

@@ -40,7 +40,13 @@ interface LayerClass extends Named<typeof LayerDefinition> {}
 declare function forwardedNames(config: Config, element: unknown, entry: unknown): string[] | null;
 declare const ForwardDefinition: SubEntityClass<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodObject<{
   __ref: z.ZodString;
-}, z.core.$strip>>]>>;
+}, z.core.$strip>>]> | z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodObject<{
+  __ref: z.ZodString;
+}, z.core.$strip>>]>, z.ZodTransform<"*" | {
+  __ref: string;
+}[], "*" | {
+  __ref: string;
+}[]>>>;
 interface ForwardClass extends Named<typeof ForwardDefinition> {}
 /**
  * One value a variant prop offers — the keyed collection under its `value`.

package/dist/entities/system/Component.js

@@ -1,11 +1,11 @@
 import { reject, rejectData } from "../../framework/rejection.js";
-import { canonicalCondition, isRef, kindOf, pathOf, ref, refLeaf, refSchema, splitRef } from "../../framework/utils/refs.js";
+import { canonicalCondition, isRef, kindOf, memberRef, pathOf, ref, refLeaf, refSchema, splitRef } from "../../framework/utils/refs.js";
 import { isPlainObject } from "../../framework/utils/field-path.js";
 import { pathInput } from "../../framework/schemas.js";
-import { defineEntity } from "../../framework/defineEntity.js";
-import { defineSubEntity } from "../../framework/defineSubEntity.js";
 import { derivedColor, gradient } from "./color.js";
 import { shadowValue } from "./shadow.js";
+import { defineEntity } from "../../framework/defineEntity.js";
+import { defineSubEntity } from "../../framework/defineSubEntity.js";
 import { childrenPolicy, forwardedPropName } from "./element.js";
 import { listedIn } from "../../framework/utils/enumerated.js";
 import { valueSchemaOf } from "../../framework/value-domain.js";
@@ -13,7 +13,7 @@ import { Package } from "./Package.js";
 import { bindPreviewGlyphs, glyphLeafOf } from "./glyph-identity.js";
 import { Style, addBagKeyIssues, anatomyPropValue, bagNameEdges, bagRewriteName, bindBagTokens, collectBag, isPlainRecord, openBag, styleValue } from "./style-bag.js";
 import { storedPreview } from "../../framework/preview-store.js";
-import { glyphPropsOf, propValueDomain, refListOf, resolveComponentProps, stylePropValueLeaves, validateComponentProps } from "../../framework/projections.js";
+import { glyphPropsOf, propOwner, propValueDomain, refListOf, resolveComponentProps, stylePropValueLeaves, validateComponentProps } from "../../framework/projections.js";
 import { carriesContent, intoName, isValueSlot, renderBoundProp, routedPropIn, routesContent } from "../../framework/prop-surface.js";
 import { slotAnatomyPropOf, slotTargetsOf, withoutTruthyTerm } from "../../framework/render-spec.js";
 import { listSlots, namedSlots, slotHostedBy, slotOf } from "../../spec/slot.js";
@@ -239,7 +239,7 @@ function forwardedNames(config, element, entry) {
 	if (entry !== "*" || !isRef(element)) return null;
 	return Object.keys(resolveComponentProps(config, pathOf(element.__ref)));
 }
-const Forward = defineSubEntity({
+const ForwardDefinition = defineSubEntity({
 	name: "forward",
 	label: "Forward",
 	labelPlural: "Forwards",
@@ -296,9 +296,30 @@ const Forward = defineSubEntity({
 					message: `layers "${key}" and "${otherKey}" would both forward ${shared.slice(0, 3).map((n) => `"${n}"`).join(", ")}${shared.length > 3 ? ` (+${shared.length - 3} more)` : ""}. Route one explicitly with bind().`
 				});
 			}
-		});
+		}).transform((value) => declaringForwardRefs(config, element, value));
 	}
 });
+/**
+* A narrowing list with each ref naming the component that DECLARES its prop — `defineComponent`'s
+* `storedForwards`, asked of the config instead of the handles.
+*
+* The builder walks a layer's handle to find the declaration, and a layer written as a ref has no
+* handle to walk: `.layers({ root: Component.ref('Pressable') })` mints `component:Pressable#props/width`
+* for a `width` Pressable only forwards from Box, a ref that resolves to nothing. That is the spelling
+* of every layer a consumer builds on a component borrowed through a link, so the config — which can
+* resolve the element — re-points it here, where the same forward on the source's own handle already
+* names Box. A ref whose prop nothing in the chain declares is left as it was, for validation to judge.
+*/
+function declaringForwardRefs(config, element, value) {
+	if (value === "*" || !isRef(element)) return value;
+	return value.map((entry) => {
+		const name = forwardedPropName(entry);
+		const owner = name && propOwner(config, pathOf(element.__ref), name);
+		if (!name || !owner || pathOf(entry.__ref) === owner) return entry;
+		return memberRef("component", owner, "props", name);
+	});
+}
+const Forward = ForwardDefinition;
 const VariantValue = defineSubEntity({
 	name: "value",
 	label: "Value",
@@ -515,7 +536,30 @@ function propSchemaFor(config, owner) {
 			path: ["accepts"],
 			message: routed ? `\`accepts\` says what may FILL a content hole — an icon set, so any glyph it registers can be dropped in (\`EmptyState.icon\` accepts \`Icon.ref('phosphor')\`), or a component. \`${layer}/${prop}\` is a ${routed.type} prop, so it takes a value rather than content. Remove \`accepts\`, or point \`target\` at a prop declared \`{ type: 'slot' }\`.` : `\`accepts\` says what may FILL a content hole — an icon set, or a component. The \`${layer}\` layer is a plain tag, and \`children\` is the only prop a tag carries content through — so either target \`${layer}/children\`, or remove \`accepts\`.`
 		});
-	});
+	}).overwrite((decl) => declaringInto(config, layers, decl));
+}
+/**
+* A route's `into` naming the component that DECLARES its prop — `storedRoutedForward`, asked of the
+* config instead of the handles, as {@link declaringForwardRefs} is for `forwards`.
+*
+* The builder walks the target layer's handle to find the declaration, and a layer written as a ref
+* has none: `{ type: 'forward', target: 'root/children' }` over `root: Component.ref('Pressable')`
+* kept the bare name `children` where the same route over the source's own handle stores
+* `component:Box#props/children`. A name is invisible to the dependency graph, so a rename of the
+* prop never reached it. The config resolves the element and mints the ref here. A prop nothing in
+* the chain declares is the DOM's (`aria-label` on the element's tag) and keeps its name.
+*/
+function declaringInto(config, layers, decl) {
+	if (!isPlainObject(decl) || decl.type !== "forward" || !isRef(decl.target)) return decl;
+	const element = layers?.[pathOf(decl.target)];
+	if (!isRef(element)) return decl;
+	const name = intoName(decl.into);
+	const owner = propOwner(config, pathOf(element), name);
+	if (!owner || isRef(decl.into) && pathOf(decl.into) === owner) return decl;
+	return {
+		...decl,
+		into: memberRef("component", owner, "props", name)
+	};
 }
 /**
 * A condition narrowed to one owner's props: each key a sibling, each value one of that sibling's

package/dist/entities/system/GlobalStyle.js

@@ -1,6 +1,6 @@
 import { refSchema } from "../../framework/utils/refs.js";
-import { defineEntity } from "../../framework/defineEntity.js";
 import { derivedColor } from "./color.js";
+import { defineEntity } from "../../framework/defineEntity.js";
 import { z } from "zod";
 //#region src/entities/system/GlobalStyle.ts
 /**

package/dist/entities/system/Token.js

@@ -1,7 +1,7 @@
 import { isRef, pathOf, ref, sourceOf } from "../../framework/utils/refs.js";
+import { composedValueSchemas } from "./composed-values.js";
 import { defineEntity } from "../../framework/defineEntity.js";
 import { defineSubEntity } from "../../framework/defineSubEntity.js";
-import { composedValueSchemas } from "./composed-values.js";
 import { Font } from "./Font.js";
 import { Modifier } from "./Modifier.js";
 import { authoringPhantom } from "../../framework/utils/authoring-phantom.js";

package/dist/entities/system/style-bag.js

@@ -1,6 +1,6 @@
 import { isExtendedRef, isRef, ref, refSchema, splitRef } from "../../framework/utils/refs.js";
-import { defineSubEntity } from "../../framework/defineSubEntity.js";
 import { composedValueSchemas } from "./composed-values.js";
+import { defineSubEntity } from "../../framework/defineSubEntity.js";
 import { isCssProperty, kebabCase } from "../../css/values.js";
 import { valueSchemaOf } from "../../framework/value-domain.js";
 import { glyphLeafOf, glyphPackageRef } from "./glyph-identity.js";

package/dist/framework/Config.d.ts

@@ -2094,6 +2094,18 @@ declare class Config {
   withDerivedRows(): this;
   /** {@link withDerivedRows} for a derivation already in hand. */
   private withRowsOf;
+  /**
+   * Re-coerce every authored item that names a row just written — {@link coerceOwned}'s second pass,
+   * for the rows a link brings.
+   *
+   * A member's schema is built from the config, so it binds against whatever rows exist when it runs,
+   * and an authored config is coerced at `register`, before any source is attached. A consumer's
+   * component built on a borrowed one — `root: Component.ref('Pressable')`, forwarding `width` — was
+   * judged against a config with no Pressable in it, and kept a ref at Pressable for a prop Pressable
+   * only forwards from Box. Only the dependents of what this pass wrote can change, so only they are
+   * asked again; a minted row is remade from its source and has nothing of its own to coerce.
+   */
+  private coerceReferrers;
   /**
    * The rows an edit changes, derived inside that edit's own apply.
    *

package/dist/framework/Config.js

@@ -3997,7 +3997,44 @@ var Config = class Config {
 	withRowsOf(derived) {
 		const moved = derived.changes.filter((change) => !this.holdsDerivedRow(change));
 		if (moved.length === 0) return this;
-		return this.derive({ snapshot: this.state.snapshot.withChanges(moved) });
+		return this.derive({ snapshot: this.state.snapshot.withChanges(moved) }).coerceReferrers(moved);
+	}
+	/**
+	* Re-coerce every authored item that names a row just written — {@link coerceOwned}'s second pass,
+	* for the rows a link brings.
+	*
+	* A member's schema is built from the config, so it binds against whatever rows exist when it runs,
+	* and an authored config is coerced at `register`, before any source is attached. A consumer's
+	* component built on a borrowed one — `root: Component.ref('Pressable')`, forwarding `width` — was
+	* judged against a config with no Pressable in it, and kept a ref at Pressable for a prop Pressable
+	* only forwards from Box. Only the dependents of what this pass wrote can change, so only they are
+	* asked again; a minted row is remade from its source and has nothing of its own to coerce.
+	*/
+	coerceReferrers(written) {
+		const { snapshot } = this.state;
+		const dependents = /* @__PURE__ */ new Set();
+		for (const change of written) {
+			if (change.target !== "item" || !change.value) continue;
+			for (const dependent of this.referrersOf(snapshot, change.kind, change.path)) dependents.add(dependent);
+		}
+		const changes = [];
+		for (const dependent of dependents) {
+			const kind = kindOf(dependent);
+			const path = pathOf(dependent);
+			const entry = this.entityOf(kind);
+			const before = snapshot.get(kind, path)?.toJSON();
+			if (!entry || Object.keys(entry.subEntities).length === 0) continue;
+			if (!before || isRef(before) || isMintedRow(before)) continue;
+			const after = this.normalizeMembers(entry, before);
+			if (JSON.stringify(after) === JSON.stringify(before)) continue;
+			changes.push({
+				kind,
+				target: "item",
+				path,
+				value: new Entity(path, after, entry.fieldKeys)
+			});
+		}
+		return changes.length === 0 ? this : this.derive({ snapshot: snapshot.withChanges(changes) });
 	}
 	/**
 	* The rows an edit changes, derived inside that edit's own apply.

package/dist/framework/source-integrity.d.ts

@@ -124,7 +124,8 @@ interface MisdeclaredOverlay {
 type LeafAddress = string | readonly string[];
 /** Every leaf address under `body`, as segments, so a member key that contains a dot stays one key. */
 declare function leafAddresses(body: unknown): (readonly string[])[];
-/** The value at a leaf address, or `undefined` where the body has none. A ref is one value, not walked into. */
+/** The value at a leaf address, or `undefined` where the body has none. A ref and a composed value are
+ *  each one value, not walked into. */
 declare function valueAt(body: unknown, field: LeafAddress): unknown;
 /** The two things a local leaf can be to the source: a value it defines, replaced, or one it lacks, added. */
 type OverlayVerb = 'override' | 'extend';

package/dist/framework/source-integrity.js

@@ -1,7 +1,22 @@
 import { collectRefs, isExtendedRef, isRef, kindOf, memberOf, pathOf, sourceOf, splitRef } from "./utils/refs.js";
 import { isPlainObject, setAtPath } from "./utils/field-path.js";
+import { isComposedValue } from "../entities/system/composed-values.js";
 //#region src/framework/source-integrity.ts
 /**
+* Whether a config's links hold — the two ways a borrow can be broken by the other side.
+*
+* Both are pure questions about a `Config` with its sources attached, which is why they live here rather
+* than in the build that refuses on them. Three surfaces need the same answers: `uds build` refuses,
+* Create's update sweep asks which borrows a new version drops, and an editor will want to say so before
+* the push. Written once, they can't disagree, and a sweep that disagreed with the build would look like
+* a branch that merged clean and then wouldn't compile.
+*
+* The two provenance walks are the rest of it, and what every consumer reads. `sourcedFields` answers
+* where an entity's values come from, and `borrowedSlug` answers whether the entity itself is someone
+* else's. The framework installs both as computeds on every kind (`sources`, `borrowedFrom`), so nothing
+* re-derives them and no kind has to opt in.
+*/
+/**
 * Every `@source` ref in `config` that does not resolve against its attached source.
 *
 * This is the guarantee the emitted types can only approximate. A union narrows what an author can type, but
@@ -189,18 +204,42 @@ function redundantQualifiers(config) {
 function segmentsOf(field) {
 	return typeof field === "string" ? field.split(".") : field;
 }
-/** A leaf is anything that is not a plain object to walk into. A ref is one value, not a shape. */
+/**
+* Whether a leaf walk goes into `value`: a record, but not a ref and not a composed value
+* (`alpha(…)`, `shadow(…)`, a gradient, a transition). Both are one value however many fields spell
+* them, so an `alpha()` laid over a source's ref is an override of that ref, not an extension of an
+* `amount` the source never had.
+*/
+const isWalkable = (value) => isPlainObject(value) && !isRef(value) && !isComposedValue(value);
+/**
+* A leaf is anything {@link isWalkable} does not walk into.
+*
+* An EMPTY record below the root is a leaf too: it is a member whose value carries no fields — a
+* package export is `{}`, its identity is its key. Walked into, it contributes no address at all, so a
+* member added that way vanished from every overlay classified here.
+*/
 function leafEntries(value, prefix = []) {
-	if (!isPlainObject(value) || isRef(value)) return [[prefix, value]];
+	if (!isWalkable(value)) return [[prefix, value]];
+	if (prefix.length > 0 && Object.keys(value).length === 0) return [[prefix, value]];
 	return Object.entries(value).flatMap(([key, child]) => leafEntries(child, [...prefix, key]));
 }
 /** Every leaf address under `body`, as segments, so a member key that contains a dot stays one key. */
 function leafAddresses(body) {
 	return leafEntries(body).map(([address]) => address).filter((address) => address.length > 0);
 }
-/** The value at a leaf address, or `undefined` where the body has none. A ref is one value, not walked into. */
+/** The value at a leaf address, or `undefined` where the body has none. A ref and a composed value are
+*  each one value, not walked into. */
 function valueAt(body, field) {
-	return segmentsOf(field).reduce((at, key) => isPlainObject(at) && !isRef(at) ? at[key] : void 0, body);
+	return segmentsOf(field).reduce((at, key) => isWalkable(at) ? at[key] : void 0, body);
+}
+/**
+* Whether a component leaf sits under a style rule's `when` (`styles.<key>.when…`). That's the rule's
+* name, not its content: a rule is stored under the key its condition spells, so a condition restated
+* over a rule the source has is the source's own, and a rule list, which has no key to write, has to
+* restate it to reach the rule at all. An extension there is never wrong.
+*/
+function isRuleCondition(field) {
+	return field[0] === "styles" && field[2] === "when";
 }
 /**
 * The verb one local leaf is against the source's value at the same address: `extend` where the
@@ -256,13 +295,16 @@ function misdeclaredOverlays(config) {
 			const overlay = config.sourceOverlay(slug, kind, path);
 			if (!overlay) continue;
 			const theirs = source.resolve(kind, path)?.toJSON();
-			for (const field of leafAddresses(overlay.extend)) if (valueAt(theirs, field) !== void 0) found.push({
-				slug,
-				kind,
-				path,
-				declared: "extend",
-				field
-			});
+			for (const field of leafAddresses(overlay.extend)) {
+				if (kind === "component" && isRuleCondition(field)) continue;
+				if (valueAt(theirs, field) !== void 0) found.push({
+					slug,
+					kind,
+					path,
+					declared: "extend",
+					field
+				});
+			}
 			for (const field of leafAddresses(overlay.override)) if (valueAt(theirs, field) === void 0) found.push({
 				slug,
 				kind,

package/dist/index.js

@@ -5,15 +5,15 @@ import { ENTITY_PATH_MESSAGE, MINTED, collectRefs, entityRefOf, isEntityPath, is
 import { describePatch } from "./framework/plan.js";
 import { applyPathDelta, isPlainObject, namedFields, pathDelta, pathSegments, setAtPath, touchedFields } from "./framework/utils/field-path.js";
 import { declaredField, deriveCreateSchema, deriveUpdateSchema, fieldKeys } from "./framework/utils/field-schema.js";
+import { DERIVED_COLOR_SPACE, alpha, darken, isDerivedColor, isGradient, lighten, linearGradient, mix, renderDerivedColor, renderGradient } from "./entities/system/color.js";
+import { isShadow, renderShadow, shadow } from "./entities/system/shadow.js";
+import { isTransition, renderTransition, transition } from "./entities/system/transition.js";
+import { composedValueAuthoring, composedValueFormOf, composedValueForms, composedValueSchemas, isComposedValue, renderComposedValue } from "./entities/system/composed-values.js";
 import { classifyOverlay, danglingDirectives, danglingSourcedRefs, leafAddresses, leafVerb, misdeclaredOverlays, overlayVerb, redundantQualifiers, unadoptedDirectives, unreadableBorrows, unstatableConditions, unstatableOverrides, valueAt } from "./framework/source-integrity.js";
 import { opsForKind } from "./framework/registry.js";
 import { GROUP, brandGroup, isGroupBody } from "./framework/utils/group.js";
 import { defineEntity } from "./framework/defineEntity.js";
 import { defineSubEntity } from "./framework/defineSubEntity.js";
-import { DERIVED_COLOR_SPACE, alpha, darken, isDerivedColor, isGradient, lighten, linearGradient, mix, renderDerivedColor, renderGradient } from "./entities/system/color.js";
-import { isShadow, renderShadow, shadow } from "./entities/system/shadow.js";
-import { isTransition, renderTransition, transition } from "./entities/system/transition.js";
-import { composedValueAuthoring, composedValueFormOf, composedValueForms, composedValueSchemas, isComposedValue, renderComposedValue } from "./entities/system/composed-values.js";
 import { VOID_ELEMENTS, childrenPolicy, forwardsOf, ownerOf, partsOf, renderedElement, renderedTarget, rootLayerOf } from "./entities/system/element.js";
 import { Font, FontFile, cssString, fontFamilyStack } from "./entities/system/Font.js";
 import { CSS_PROPERTY_NAMES, CSS_WIDE_KEYWORDS, cssProperty, cssValueIssue, isCssProperty } from "./css/values.js";