@yahoo/uds-create-config 5.41.7 → 5.41.8

package/dist/framework/Config.js

@@ -6,7 +6,7 @@ import { applyPathDelta, isPlainObject, namedFields, pathSegments, sectionDelta,
 import { METADATA_KEYS, declaredField } from "./utils/field-schema.js";
 import { dataSchema, resolveInputSchema } from "./schemas.js";
 import { isComposedValue } from "../entities/system/composed-values.js";
-import { borrowedSlug, classifyOverlay } from "./source-integrity.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";
@@ -6095,19 +6095,6 @@ function layerOverlay({ onto, patch, theirs, union }) {
 	}
 	return merged;
 }
-/** A union that keeps the existing order and drops a repeat. Entries are refs and small literals, so
-*  identity is what they serialize to rather than reference equality. */
-function uniteEntries(existing, added) {
-	const out = Array.isArray(existing) ? [...existing] : [];
-	const seen = new Set(out.map((entry) => JSON.stringify(entry)));
-	for (const entry of added) {
-		const key = JSON.stringify(entry);
-		if (seen.has(key)) continue;
-		seen.add(key);
-		out.push(entry);
-	}
-	return out;
-}
 function derivedItemChange(kind, path, base, extend = {}) {
 	return {
 		kind,

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

@@ -117,6 +117,9 @@ interface MisdeclaredOverlay {
   declared: 'override' | 'extend';
   /** The field it was wrong about, addressed from the entity body as segments. */
   field: readonly string[];
+  /** For an `extend` of a list, the entries the list it lays onto already holds. The entries are what
+   *  the extension is judged on, so a list the source defines is not wrong to extend. */
+  entries?: readonly unknown[];
 }
 /**
  * A leaf address: dotted, or spelled as segments where a member key can itself contain a dot (a
@@ -136,6 +139,9 @@ type OverlayVerb = 'override' | 'extend';
  * nothing local sits there or the two agree. A leaf carried along unchanged is not overlaid: a sub-op
  * copies the whole record it touched into the delta, so a token given one local condition holds the
  * source's other conditions beside it.
+ *
+ * A list is the one leaf with members. One that keeps all of theirs and adds to it is an `extend`,
+ * since that is what an `extend` of the added entries reads back as.
  */
 declare function leafVerb({
   ours,
@@ -162,6 +168,10 @@ declare function overlayVerb(overlay: LocalOverlay, field: LeafAddress): Overlay
  * Judged leaf by leaf, because one entity legitimately carries both — a token overridden under one
  * modifier and extended under another is one body with two verbs, and a whole-entity comparison would
  * have to call it one or the other.
+ *
+ * A list is judged by its entries: an `extend` of one the source defines adds to it, and is wrong only
+ * in the entries the list beneath already holds. That is the same moving source one level down — they
+ * added a value this config was extending with.
  */
 declare function misdeclaredOverlays(config: Config): MisdeclaredOverlay[];
 /**

package/dist/framework/source-integrity.js

@@ -243,17 +243,50 @@ function valueAt(body, field) {
 function isRuleCondition(address) {
 	return address.length >= 3 && address[0] === "styles" && address[2] === "when";
 }
+/** A list entry's identity. Entries are refs and small literals, so it is what they serialize to
+*  rather than reference equality. */
+const entryKey = (entry) => JSON.stringify(entry);
+/**
+* A union that keeps the existing order and drops a repeat — what an `extend` of a list lays onto the
+* list beneath it.
+*/
+function uniteEntries(existing, added) {
+	const out = Array.isArray(existing) ? [...existing] : [];
+	const seen = new Set(out.map(entryKey));
+	for (const entry of added) {
+		const key = entryKey(entry);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(entry);
+	}
+	return out;
+}
+/**
+* The entries `ours` adds to `theirs`, where uniting them onto `theirs` gives back `ours` exactly —
+* their list whole and in order, with ours after it. `undefined` where it doesn't: a list that drops
+* or reorders one of theirs replaces it, and so does anything that isn't a list on both sides.
+*/
+function addedEntries(ours, theirs) {
+	if (!Array.isArray(ours) || !Array.isArray(theirs)) return void 0;
+	const listed = new Set(theirs.map(entryKey));
+	const added = ours.filter((entry) => !listed.has(entryKey(entry)));
+	return sameValue(uniteEntries(theirs, added), ours) ? added : void 0;
+}
 /**
 * The verb one local leaf is against the source's value at the same address: `extend` where the
 * source has nothing there, `override` where it has something different, and `undefined` where
 * nothing local sits there or the two agree. A leaf carried along unchanged is not overlaid: a sub-op
 * copies the whole record it touched into the delta, so a token given one local condition holds the
 * source's other conditions beside it.
+*
+* A list is the one leaf with members. One that keeps all of theirs and adds to it is an `extend`,
+* since that is what an `extend` of the added entries reads back as.
 */
 function leafVerb({ ours, theirs }) {
 	if (ours === void 0) return void 0;
 	if (theirs === void 0) return "extend";
-	return sameValue(ours, theirs) ? void 0 : "override";
+	if (sameValue(ours, theirs)) return void 0;
+	return addedEntries(ours, theirs)?.length ? "extend" : "override";
 }
 /**
 * Which verb this config's value at `field` is, in the pin's vocabulary — `override` where the source
@@ -286,6 +319,10 @@ function sameValue(a, b) {
 * Judged leaf by leaf, because one entity legitimately carries both — a token overridden under one
 * modifier and extended under another is one body with two verbs, and a whole-entity comparison would
 * have to call it one or the other.
+*
+* A list is judged by its entries: an `extend` of one the source defines adds to it, and is wrong only
+* in the entries the list beneath already holds. That is the same moving source one level down — they
+* added a value this config was extending with.
 */
 function misdeclaredOverlays(config) {
 	const found = [];
@@ -299,7 +336,29 @@ function misdeclaredOverlays(config) {
 			const theirs = source.resolve(kind, path)?.toJSON();
 			for (const field of leafAddresses(overlay.extend)) {
 				if (isRuleCondition(field)) continue;
-				if (valueAt(theirs, field) !== void 0) found.push({
+				const defined = valueAt(theirs, field);
+				if (defined === void 0) continue;
+				const added = valueAt(overlay.extend, field);
+				if (Array.isArray(added) && Array.isArray(defined)) {
+					const replaced = valueAt(overlay.override, field);
+					const beneath = Array.isArray(replaced) ? replaced : valueAt(config.copyOf({
+						slug,
+						kind,
+						path
+					}), field);
+					const listed = new Set((Array.isArray(beneath) ? beneath : defined).map(entryKey));
+					const entries = added.filter((entry) => listed.has(entryKey(entry)));
+					if (entries.length > 0) found.push({
+						slug,
+						kind,
+						path,
+						declared: "extend",
+						field,
+						entries
+					});
+					continue;
+				}
+				found.push({
 					slug,
 					kind,
 					path,
@@ -336,12 +395,16 @@ function classifyOverlay(local, theirs) {
 	for (const [address, value] of leafEntries(local)) {
 		if (address.length === 0) continue;
 		if (isRuleCondition(address)) continue;
+		const defined = valueAt(theirs, address);
 		const verb = leafVerb({
 			ours: value,
-			theirs: valueAt(theirs, address)
+			theirs: defined
 		});
 		if (verb === "override") override = setAtPath(override, address, value);
-		else if (verb === "extend") extend = setAtPath(extend, address, value);
+		else if (verb === "extend") {
+			const added = addedEntries(value, defined) ?? value;
+			extend = setAtPath(extend, address, added);
+		}
 	}
 	const rules = local.styles;
 	if (isWalkable(rules)) for (const [key, rule] of Object.entries(rules)) {
@@ -594,4 +657,4 @@ function borrowedSlug(body) {
 	return isRef(body) ? sourceOf(body) : void 0;
 }
 //#endregion
-export { borrowedSlug, classifyOverlay, danglingDirectives, danglingSourcedRefs, excludedCondition, leafAddresses, leafVerb, misdeclaredOverlays, overlayVerb, redundantQualifiers, sourceSlugs, unadoptedDirectives, unreadableBorrows, unstatableConditions, unstatableOverrides, valueAt };
+export { borrowedSlug, classifyOverlay, danglingDirectives, danglingSourcedRefs, excludedCondition, leafAddresses, leafVerb, misdeclaredOverlays, overlayVerb, redundantQualifiers, sourceSlugs, unadoptedDirectives, uniteEntries, unreadableBorrows, unstatableConditions, unstatableOverrides, valueAt };