@yahoo/uds-create-config 5.59.2 → 5.59.4

package/dist/entities/system/LinkedSystem.js

@@ -8,7 +8,7 @@ import { storedStyleRules } from "./Component.js";
 import { sourceUnreachable } from "../../framework/sources.js";
 import { covers, excludes } from "./link-declaration.js";
 import { planCopy } from "./copy-plan.js";
-import { planBreak, planExclude, planLink, planUnlink, sourceRowStates } from "./link-plan.js";
+import { planBreak, planExclude, planLink, planLinkApplied, planUnlink, sourceRowStates } from "./link-plan.js";
 import { z } from "zod";
 //#region src/entities/system/LinkedSystem.ts
 /**
@@ -316,7 +316,7 @@ const LinkedSystemDefinition = defineEntity({
 			title: (entity) => `Link something from ${entity}`,
 			example: linkExample,
 			handler: (input, config) => {
-				const { linked, patches } = planLink({
+				const { plan: { linked, patches }, after } = planLinkApplied({
 					config,
 					input: linkPlanInputOf(input)
 				});
@@ -325,7 +325,7 @@ const LinkedSystemDefinition = defineEntity({
 					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"]);
 				}
 				if (patches.length === 0) return config;
-				return config.applyAll(patches).withDerivedRows();
+				return after ?? config.applyAll(patches).withDerivedRows();
 			}
 		},
 		"link-plan": {

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

@@ -73,6 +73,28 @@ function declaredElsewhere({ config, slug, kind, path }) {
 * folder that holds one is declared by its other members.
 */
 function planLink({ config, input }) {
+	return planLinkApplied({
+		config,
+		input
+	}).plan;
+}
+const applied = (config, patches) => {
+	try {
+		return { config: config.applyAll(patches).withDerivedRows() };
+	} catch (error) {
+		return isConfigRejection(error) ? { refused: error } : { failed: error };
+	}
+};
+/**
+* {@link planLink}, and the config its patches leave when they apply, which is what `link` itself
+* returns.
+*
+* A take is applied once. What it leaves is where the entries it strands are read, the edits that
+* remove them are applied on top, and the outcome is read off the result, so neither the plan nor the
+* `link` that follows it applies the whole of a take again. On a config that takes a whole system
+* over another, each of those passes cost about a second.
+*/
+function planLinkApplied({ config, input }) {
 	const { path: slug } = input;
 	const source = config.sourceFor(slug);
 	if (!source) rejectData(`Cannot link through "${slug}" — nothing has resolved that link.`);
@@ -243,30 +265,36 @@ function planLink({ config, input }) {
 		...declares,
 		...shadows
 	];
-	const { dropped, patches: drops } = takes.length > 0 ? directivesTakenFrom({
+	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({
 		config,
 		slug,
-		patches: planned
+		after: result.config
 	}) : {
 		dropped: [],
 		patches: []
 	};
+	if (drops.length > 0 && result && "config" in result) result = applied(result.config, drops);
 	const patches = [...planned, ...drops];
 	return {
-		declared,
-		...outcome({
-			config,
-			slug,
-			patches,
-			named: input.data
-		}),
-		replaces: addresses.length,
-		addresses,
-		linked,
-		extended,
-		dropped,
-		shared,
-		patches
+		plan: {
+			declared,
+			...outcome({
+				config,
+				slug,
+				result,
+				named: input.data
+			}),
+			replaces: addresses.length,
+			addresses,
+			linked,
+			extended,
+			dropped,
+			shared,
+			patches
+		},
+		after: result && "config" in result ? result.config : void 0
 	};
 }
 /**
@@ -280,19 +308,9 @@ function planLink({ config, input }) {
 * itself left behind: an entry that already applied to nothing is the build's to report, not this
 * take's to remove.
 *
-* Nothing when the take is refused; `outcome` says why.
+* `after` is the config the take leaves. A take the config refuses has none, and `outcome` says why.
 */
-function directivesTakenFrom({ config, slug, patches }) {
-	let after;
-	try {
-		after = config.applyAll(patches).withDerivedRows();
-	} catch (error) {
-		if (!isConfigRejection(error)) throw error;
-		return {
-			dropped: [],
-			patches: []
-		};
-	}
+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 = [];
@@ -342,32 +360,27 @@ function refusal(error) {
 }
 const addressed = (rows) => new Set(rows.map(({ kind, path }) => `${kind}:${path}`));
 /**
-* What a link leaves, read by running its patches on a scratch config and deriving: the rows held
-* through the pin afterwards that were not before, and the paths settled afterwards that were not
-* before. When the config would refuse the patches, a collision they would leave among them,
-* nothing arrives and `blocked` says why.
+* What a link leaves, read off the scratch config its patches leave (`result`, absent when there are
+* none): the rows held through the pin afterwards that were not before, and the paths settled
+* afterwards that were not before. When the config would refuse the patches, a collision they would
+* leave among them, nothing arrives and `blocked` says why.
 */
-function outcome({ config, slug, patches, named }) {
+function outcome({ config, slug, result, named }) {
 	const nothing = {
 		arriving: [],
 		settled: []
 	};
-	if (patches.length === 0) return nothing;
+	if (!result || "failed" in result) return nothing;
+	if ("refused" in result) return {
+		...nothing,
+		...refusal(result.refused)
+	};
 	const through = (at) => {
 		const held = /* @__PURE__ */ new Set();
 		for (const kind of at.borrowableKinds(slug)) for (const item of at.list(kind)) if (item.borrowedFrom === slug) held.add(`${kind}:${item.path}`);
 		return held;
 	};
-	let after;
-	try {
-		after = config.applyAll(patches).withDerivedRows();
-	} catch (error) {
-		if (!isConfigRejection(error)) return nothing;
-		return {
-			...nothing,
-			...refusal(error)
-		};
-	}
+	const after = result.config;
 	const before = through(config);
 	const arriving = [];
 	for (const key of through(after)) {
@@ -1074,4 +1087,4 @@ function sourceRowStates({ config, slug }) {
 	return rows;
 }
 //#endregion
-export { planBreak, planExclude, planLink, planUnlink, sourceRowStates };
+export { planBreak, planExclude, planLink, planLinkApplied, planUnlink, sourceRowStates };