@yahoo/uds-create-config 5.64.1 → 5.64.2

package/dist/entities/system/LinkedSystem.js

@@ -316,10 +316,11 @@ const LinkedSystemDefinition = defineEntity({
 			title: (entity) => `Link something from ${entity}`,
 			example: linkExample,
 			handler: (input, config) => {
-				const { plan: { linked, patches }, after } = planLinkApplied({
+				const { plan: { linked, patches, stranded, blocked }, after } = planLinkApplied({
 					config,
 					input: linkPlanInputOf(input)
 				});
+				if (stranded && stranded.length > 0 && blocked) rejectData(blocked, ["onLinked"]);
 				if (linked.length > 0 && input.onLinked === void 0) {
 					const named = linked.map((at) => `${at.path} (from ${at.from})`);
 					rejectData(`Linking through "${String(input.path)}" reaches what another linked system provides: ${named.join(", ")}. Say whether to take them (\`onLinked: 'take'\`) or keep them where they come from (\`onLinked: 'keep'\`).`, ["onLinked"]);

package/dist/entities/system/component-module.js

@@ -419,7 +419,8 @@ function linkedComponentModule(config, componentPathOrRef) {
 	const owner = config.configFor(fileRef);
 	const pin = publishedPin(config, slug);
 	if (!owner || !pin) return void 0;
-	const view = cachedView(config, owner, slug, askedSource !== void 0);
+	const shadowed = askedSource !== void 0;
+	const view = cachedView(config, (shadowed && owner === config.sourceFor(slug) ? config.drawnSourceFor(slug) : void 0) ?? owner, slug, shadowed);
 	const moduleKey = componentModuleKey(view, filePath);
 	if (!moduleKey) return void 0;
 	const authored = Component.list(owner).find((candidate) => {

package/dist/entities/system/link-plan.d.ts

@@ -29,6 +29,12 @@ interface DroppedDirective extends EntityAddress {
   /** The accessor the entry sits under in that pin's `options`. */
   readonly accessor: string;
 }
+/** An entry in another pin's `options` a take would leave naming something that pin's own copy can't
+ *  be drawn with ({@link Config.pinCopyOf}). The take refuses rather than remove it. */
+interface StrandedDirective extends DroppedDirective {
+  /** The refs the entry names that the pin's copy has no name for. */
+  readonly unreadable: readonly string[];
+}
 /** One row a link mints. `named` when a path the call named covers it; otherwise it comes along
  *  because something linked points at it. */
 interface LinkArrival extends EntityAddress {
@@ -51,6 +57,10 @@ interface LinkPlan {
    *  rows their pin derives, and the row there follows this one now. Not carried onto the taken row,
    *  since an entry corrects what that pin brings rather than stating a value of this config's own. */
   readonly dropped: readonly DroppedDirective[];
+  /** The other pins' entries at what the take moves that it can't carry: each lays over a copy that
+   *  pin still builds, and names something the copy can't be drawn with. The take refuses while any
+   *  remain, and `blocked` says what to change. */
+  readonly stranded?: readonly StrandedDirective[];
   /** Members already here from the source's own origin, left alone and kept out of the declaration. */
   readonly shared: readonly EntityAddress[];
   /** Paths another pin offers that a `hybrid` link reaches as a different entity. The other pin's

package/dist/entities/system/link-plan.js

@@ -267,12 +267,13 @@ function planLinkApplied({ config, input }) {
 	];
 	let result = planned.length > 0 ? applied(config, planned) : void 0;
 	if (takes.length > 0 && result && "failed" in result) throw result.failed;
-	const { dropped, patches: drops } = takes.length > 0 && result && "config" in result ? directivesTakenFrom({
+	const { dropped, stranded, patches: drops } = takes.length > 0 && result && "config" in result ? directivesTakenFrom({
 		config,
 		slug,
 		after: result.config
 	}) : {
 		dropped: [],
+		stranded: [],
 		patches: []
 	};
 	if (drops.length > 0 && result && "config" in result) result = applied(result.config, drops);
@@ -292,9 +293,13 @@ function planLinkApplied({ config, input }) {
 			extended,
 			dropped,
 			shared,
-			patches
+			patches,
+			...stranded.length > 0 ? {
+				stranded,
+				blocked: strandedMessage(slug, stranded)
+			} : {}
 		},
-		after: result && "config" in result ? result.config : void 0
+		after: stranded.length === 0 && result && "config" in result ? result.config : void 0
 	};
 }
 /**
@@ -314,14 +319,20 @@ function directivesTakenFrom({ config, slug, after }) {
 	const key = (at) => `${at.slug}\u0000${at.accessor}\u0000${at.path}`;
 	const already = new Set(danglingDirectives(config).map(key));
 	const dropped = [];
+	const stranded = [];
 	for (const at of danglingDirectives(after)) {
 		if (at.missing !== "row" || at.heldBy !== slug || already.has(key(at))) continue;
-		dropped.push({
+		const entry = {
 			kind: config.accessors()[at.accessor]?.kind ?? at.accessor,
 			path: at.path,
 			from: at.slug,
 			accessor: at.accessor
+		};
+		if (at.unreadable) stranded.push({
+			...entry,
+			unreadable: at.unreadable
 		});
+		else dropped.push(entry);
 	}
 	const edits = [];
 	for (const pin of new Set(dropped.map((at) => at.from))) {
@@ -347,9 +358,16 @@ function directivesTakenFrom({ config, slug, after }) {
 	}
 	return {
 		dropped,
+		stranded,
 		patches: edits
 	};
 }
+/** Why a take refuses over the entries it can't carry ({@link StrandedDirective}). */
+function strandedMessage(slug, stranded) {
+	const named = stranded.map((at) => `${at.from}'s ${at.accessor} entry at "${at.path}" names ${at.unreadable.join(", ")}`).join("; ");
+	const [one] = stranded;
+	return `Can't take through "${slug}": ${named}. ${stranded.length === 1 && one ? `${one.from} still builds its own ${one.path}, which its components render, and that entry applies to it` : "each pin still builds its own copy, which its components render, and the entry applies to it"}, but Create can draw that copy only with this system's own tokens, not yet with this system's own components, composites or motion presets. Point those values at something the pin links, or remove them from the entry, then take again.`;
+}
 /** What a plan reports of a refusal: its message, and the collisions when that's what it names. */
 function refusal(error) {
 	const collisions = error.issues.flatMap((issue) => issue.collisions ?? []);

package/dist/framework/Config.d.ts

@@ -2460,6 +2460,41 @@ declare class Config {
     kind: string;
     path: string;
   }): boolean;
+  /**
+   * The source at `slug` as this build draws the copies it still builds of its components that another
+   * row stands in for here, each drawn the way the pin's own row was: with the entry the pin's
+   * `options` lay at its path ({@link pinCopyOf}).
+   *
+   * A product that takes Yahoo OS's Button still builds the Bridge's, which the Bridge's Banner
+   * renders, and the Bridge pin's entry for its Button is what that copy is drawn with. Everything else
+   * is the source's own, so the source itself comes back when no copy carries an entry.
+   */
+  drawnSourceFor(slug: string): Config | undefined;
+  /**
+   * The body `slug`'s copy of `kind:path` is drawn with, spelled as the source spells it: the source's
+   * entity with the entry the pin's `options` lay at the path, read as the pin's row would read it
+   * here. `undefined` when this config holds the pin's row at the path (the row is what's drawn), holds
+   * nothing there, or the pin lays nothing over it.
+   *
+   * A token it names that the source has no name for (one of this config's own, or one it takes
+   * through another pin) is named under {@link CONSUMER_TOKENS} instead, and `tokens` gives each such
+   * path the variable this config's stylesheet declares for it. `unreadable` names any other ref the
+   * source has no name for: the copy can't be drawn with it, so the entry is reported instead.
+   */
+  pinCopyOf({
+    slug,
+    kind,
+    path
+  }: {
+    slug: string;
+    kind: string;
+    path: string;
+  }): {
+    readonly body: Record<string, unknown>;
+    readonly tokens: ReadonlyMap<string, string>;
+  } | {
+    readonly unreadable: readonly string[];
+  } | undefined;
   /**
    * The group counterpart of {@link heldThroughAnotherPin}: this config holds the group at `path`
    * through another pin, and every member `slug` offers under it is held that way too. A group is a

package/dist/framework/Config.js

@@ -9,7 +9,7 @@ import { isComposedValue } from "../entities/system/composed-values.js";
 import { borrowedSlug, classifyOverlay, uniteEntries } from "./source-integrity.js";
 import { kindBorrowable, titleCase } from "./registry.js";
 import { isGroupBody } from "./utils/group.js";
-import { authoredBag, pinBodyStyleNumbers, stylePropNumberUnit } from "./projections.js";
+import { authoredBag, cssVar, declaresCssVariable, pinBodyStyleNumbers, stylePropNumberUnit } from "./projections.js";
 import { isAuthoringPhantom, phantomsIn } from "./utils/authoring-phantom.js";
 import { addressOf, editOp, inputOf, opVerb } from "./config-op.js";
 import { configSchemas } from "./config-ops.js";
@@ -696,6 +696,13 @@ function objectSchemaOf(schema) {
 *  of {@link Config.sourceClosure}. Per config, since a source's files and components only change
 *  with the source. */
 const implementedByCache = /* @__PURE__ */ new WeakMap();
+/**
+* The folder a source's drawn copy ({@link Config.drawnSourceFor}) names this config's own tokens
+* under. Not a path a system authors, so it never stands for one of the source's.
+*/
+const CONSUMER_TOKENS = "__consumer";
+/** {@link Config.drawnSourceFor} per config and slug. */
+const drawnSources = /* @__PURE__ */ new WeakMap();
 function implementedBy(config) {
 	const cached = implementedByCache.get(config);
 	if (cached) return cached;
@@ -5009,6 +5016,104 @@ var Config = class Config {
 		});
 	}
 	/**
+	* The source at `slug` as this build draws the copies it still builds of its components that another
+	* row stands in for here, each drawn the way the pin's own row was: with the entry the pin's
+	* `options` lay at its path ({@link pinCopyOf}).
+	*
+	* A product that takes Yahoo OS's Button still builds the Bridge's, which the Bridge's Banner
+	* renders, and the Bridge pin's entry for its Button is what that copy is drawn with. Everything else
+	* is the source's own, so the source itself comes back when no copy carries an entry.
+	*/
+	drawnSourceFor(slug) {
+		const source = this.sourceFor(slug);
+		if (!source) return void 0;
+		let bySlug = drawnSources.get(this);
+		if (!bySlug) {
+			bySlug = /* @__PURE__ */ new Map();
+			drawnSources.set(this, bySlug);
+		}
+		const cached = bySlug.get(slug);
+		if (cached) return cached;
+		const changes = [];
+		for (const { kind, path } of this.sourceDirectives(slug)) {
+			const entry = kind === void 0 ? void 0 : this.entityOf(kind);
+			if (kind !== "component" || !entry) continue;
+			const copy = this.pinCopyOf({
+				slug,
+				kind,
+				path
+			});
+			if (!copy || !("body" in copy)) continue;
+			changes.push({
+				kind,
+				target: "item",
+				path,
+				value: new Entity(path, copy.body, entry.fieldKeys)
+			});
+			const tokenEntry = this.entityOf("token");
+			for (const [at, cssVariable] of copy.tokens) {
+				if (!tokenEntry) break;
+				changes.push({
+					kind: "token",
+					target: "item",
+					path: at,
+					value: new Entity(at, { cssVariable }, tokenEntry.fieldKeys)
+				});
+			}
+		}
+		const drawn = changes.length === 0 ? source : source.derive({ snapshot: source.state.snapshot.withChanges(changes) });
+		bySlug.set(slug, drawn);
+		return drawn;
+	}
+	/**
+	* The body `slug`'s copy of `kind:path` is drawn with, spelled as the source spells it: the source's
+	* entity with the entry the pin's `options` lay at the path, read as the pin's row would read it
+	* here. `undefined` when this config holds the pin's row at the path (the row is what's drawn), holds
+	* nothing there, or the pin lays nothing over it.
+	*
+	* A token it names that the source has no name for (one of this config's own, or one it takes
+	* through another pin) is named under {@link CONSUMER_TOKENS} instead, and `tokens` gives each such
+	* path the variable this config's stylesheet declares for it. `unreadable` names any other ref the
+	* source has no name for: the copy can't be drawn with it, so the entry is reported instead.
+	*/
+	pinCopyOf({ slug, kind, path }) {
+		const stored = this.storedBody(kind, path);
+		if (stored === void 0 || isRef(stored) && sourceOf(stored) === slug) return;
+		const overlay = this.sourceDirective(slug, kind, path).overlay;
+		const source = this.sourceFor(slug);
+		const theirs = this.theirBody({
+			slug,
+			kind,
+			path
+		});
+		if (!overlay || !source || !theirs) return void 0;
+		const read = this.derive({ snapshot: this.state.snapshot.withChanges([derivedItemChange(kind, path, ref(kind, path, slug).__ref, overlayBody({
+			overlay,
+			theirs
+		}))]) }).resolve(kind, path)?.toJSON();
+		if (!read) return void 0;
+		const owned = new Set(source.ownedKinds());
+		const unreadable = [...new Set(collectRefs(read).filter((target) => sourceOf(target) === void 0 && owned.has(kindOf(target)) && pathOf(target) !== "" && !this.borrowsExactly({ __ref: target }, slug)))];
+		let body = read;
+		const tokens = /* @__PURE__ */ new Map();
+		const others = [];
+		for (const target of unreadable) {
+			const path = pathOf(target);
+			if (kindOf(target) !== "token" || !declaresCssVariable(this, path)) {
+				others.push(target);
+				continue;
+			}
+			const at = `${CONSUMER_TOKENS}/${path}`;
+			body = rewriteRefs(body, target, ref("token", at).__ref);
+			tokens.set(at, cssVar(this, "token", path));
+		}
+		if (others.length > 0) return { unreadable: others };
+		return {
+			body: rewriteRefSource(body, slug, void 0),
+			tokens
+		};
+	}
+	/**
 	* The group counterpart of {@link heldThroughAnotherPin}: this config holds the group at `path`
 	* through another pin, and every member `slug` offers under it is held that way too. A group is a
 	* folder over its members, so it is the same folder exactly when they are the same entities.

package/dist/framework/projections.js

@@ -80,7 +80,7 @@ const sourceVarPrefix = (config, slug) => prefixed({
 */
 function linkedVarNaming(config, slug) {
 	const pinned = sourceVarPrefix(config, slug);
-	const source = config.sourceFor(slug);
+	const source = config.drawnSourceFor(slug);
 	const named = /* @__PURE__ */ new Map();
 	return (tokenPath) => {
 		const hit = named.get(tokenPath);

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

@@ -249,6 +249,11 @@ interface DanglingDirective {
   missing: 'accessor' | 'path' | 'row';
   /** With `row`: the pin the row there follows instead, absent when it is this config's own. */
   heldBy?: string;
+  /**
+   * With `row`, for a component the pin still builds its own copy of beside that row: the refs the
+   * entry names that the source has no name for, so the copy can't be drawn with it.
+   */
+  unreadable?: readonly string[];
 }
 /**
  * Every directive aimed at nothing — an accessor this config has no kind for, a path the source

package/dist/framework/source-integrity.js

@@ -534,6 +534,15 @@ function heldElsewhere(config, { slug, kind, path }) {
 */
 function danglingDirectives(config) {
 	const found = [];
+	const reached = /* @__PURE__ */ new Map();
+	const reachedComponents = (slug) => {
+		let paths = reached.get(slug);
+		if (!paths) {
+			paths = new Set(config.sourceClosure(slug, "component").map(pathOf));
+			reached.set(slug, paths);
+		}
+		return paths;
+	};
 	for (const slug of config.sourceSlugs()) {
 		const source = config.liveSourceFor(slug);
 		if (!source) continue;
@@ -555,6 +564,25 @@ function danglingDirectives(config) {
 					path
 				});
 				if (heldBy === void 0) continue;
+				if (kind === "component" && reachedComponents(slug).has(path)) {
+					const copy = config.pinCopyOf({
+						slug,
+						kind,
+						path
+					});
+					if (copy && "unreadable" in copy) {
+						found.push({
+							slug,
+							accessor,
+							path,
+							missing: "row",
+							...heldBy === null ? {} : { heldBy },
+							unreadable: copy.unreadable
+						});
+						continue;
+					}
+					if (copy) continue;
+				}
 				found.push({
 					slug,
 					accessor,