@yahoo/uds-create-config 5.32.10 → 5.34.0

package/dist/entities/canvas/node-gestures.js

@@ -242,15 +242,41 @@ function remove(config, input) {
 		path
 	}))];
 }
+/** The annotations on `paths`, oldest first, as a layer lists them. */
+function annotationsOn({ config, paths }) {
+	return config.list("annotation").map((note) => ({
+		...note.body,
+		path: note.path
+	})).filter((note) => paths.has(pathOf(note.target))).sort((left, right) => (left.authoredAt ?? "").localeCompare(right.authoredAt ?? "") || left.path.localeCompare(right.path));
+}
+/**
+* Each copy of a duplicated element carries copies of the annotations on it. A copy names no author: the
+* writer who duplicates is its author, and stamps it where the write lands.
+*/
 function duplicate(config, input) {
 	const place = placeOf(config, input.path, ["path"]);
 	const fresh = freshPaths(config, rootOf(input.path));
 	const subtree = subtreeOf(config, input.path);
+	const notes = annotationsOn({
+		config,
+		paths: new Set(subtree)
+	});
 	const count = input.data?.count ?? 1;
 	const patches = [];
+	const annotationPatches = [];
 	const copies = [];
 	for (let n = 0; n < count; n++) {
 		const pathFor = new Map(subtree.map((path) => [path, fresh(path.split("/").at(-1) ?? path)]));
+		for (const note of notes) annotationPatches.push({
+			kind: "annotation",
+			operation: "create",
+			path: crypto.randomUUID(),
+			data: {
+				target: ref("node", pathFor.get(pathOf(note.target))),
+				...note.layer ? { layer: note.layer } : {},
+				content: note.content
+			}
+		});
 		const remap = (entry) => {
 			const to = pathFor.get(pathOf(entry));
 			return to ? ref("node", to) : entry;
@@ -272,7 +298,7 @@ function duplicate(config, input) {
 	}
 	const list = [...place.list];
 	list.splice(place.index + 1, 0, ...copies);
-	patches.push(placeUpdate(place, list));
+	patches.push(placeUpdate(place, list), ...annotationPatches);
 	return patches;
 }
 function unwrap(config, input) {
@@ -537,7 +563,7 @@ const nodeGestureOps = {
 		input: duplicateInput,
 		readOnly: false,
 		label: "Duplicate an element",
-		description: "Copy this element and everything inside it (\"duplicate\", \"make 3 more of these\"): each copy lands right after it among its siblings, `count` of them.",
+		description: "Copy this element and everything inside it (\"duplicate\", \"make 3 more of these\"): each copy lands right after it among its siblings, `count` of them, with a copy of each annotation on the copied elements.",
 		scope: "item",
 		title: (entity) => `Duplicate ${entity}`,
 		example: () => ({

package/dist/entities/system/motion-presets.d.ts

@@ -4,7 +4,8 @@ import { ReducedMotion } from "./reduced-motion.js";
 //#region src/entities/system/motion-presets.d.ts
 /**
  * A value a JS preset holds that `motion/react` cannot be handed as written: a token a mode or state
- * decides (`conditional`), which a preset animates as its base value; a token that comes to nothing a
+ * decides (`conditional`), or one a style rule sets that sits inside a composed value (`rule-set`),
+ * either of which a preset animates as its base value; a token that comes to nothing a
  * preset can carry (`unresolved`); or an `ease` that is no easing `motion/react` reads (`easing`),
  * from a token or written in place. The last two leave the field out.
  */
@@ -14,12 +15,13 @@ interface MotionPresetToken {
   readonly at: string;
   /** The token the value comes from; absent for an `ease` written in place. */
   readonly token?: string;
-  readonly problem: 'conditional' | 'unresolved' | 'easing';
+  readonly problem: 'conditional' | 'rule-set' | 'unresolved' | 'easing';
 }
 /**
  * Every JS-runtime preset, by path, as the props the wrapper spreads onto the animated component.
  * A token a preset names reaches `motion/react` as its value — `Token.ref('springStiffness/snappy')`
- * as `400`, a `200ms` duration as `0.2` — since it reads numbers and seconds, not variables.
+ * as `400`, a `200ms` duration as `0.2` — since it reads numbers and seconds, not variables. A token
+ * a style rule sets is the one exception: it reaches `motion/react` as its `var()`.
  */
 declare function jsMotionPresets(config: Config): Record<string, Record<string, unknown>>;
 /** Every JS preset a style rule writes in place, by its id, resolved as {@link jsMotionPresets} are. */

package/dist/entities/system/motion-presets.js

@@ -1,4 +1,4 @@
-import { collectRefs, isRef, kindOf, pathOf } from "../../framework/utils/refs.js";
+import { collectRefs, isRef, kindOf, pathOf, refOfKey } from "../../framework/utils/refs.js";
 import { composedValueFormOf } from "./composed-values.js";
 import { createSliceMemo } from "../../framework/memo.js";
 import { tokenValueRow } from "./token-values.js";
@@ -43,12 +43,48 @@ function motionEasing(value) {
 		return easings.length > 0 && easings.every((e) => e !== void 0) ? easings : void 0;
 	}
 }
+/** The tokens under a bag's `{token:…}` keys, at any depth: a state's bag nests in the layer's. */
+function collectKeyedTokens(bag, into) {
+	if (typeof bag !== "object" || bag === null || Array.isArray(bag)) return;
+	for (const [key, inner] of Object.entries(bag)) {
+		const keyed = refOfKey(key);
+		if (keyed && kindOf(keyed) === "token") into.add(pathOf(keyed));
+		collectKeyedTokens(inner, into);
+	}
+}
+/**
+* The tokens whose variable a style rule or a global style sets, under the token's own key
+* (`{ [Token.ref('switch/travel').cssVariable.name()]: … }`). Such a token holds a different value on
+* each element a rule reaches, so no one literal stands for it.
+*/
+const ruleSetTokens = createSliceMemo({
+	kinds: ["component", "global-style"],
+	compute: (config) => {
+		const tokens = /* @__PURE__ */ new Set();
+		for (const component of config.list("component")) {
+			const { styles = {} } = component.toJSON();
+			for (const entry of Object.values(styles)) collectKeyedTokens(entry?.layers, tokens);
+		}
+		for (const style of config.list("global-style")) {
+			const { declarations } = style.toJSON();
+			collectKeyedTokens(declarations, tokens);
+		}
+		return tokens;
+	}
+});
 /**
 * A preset's value with every token it names resolved, or `undefined` when one of them resolves to
 * nothing. Values and keyframe lists are walked; a ref, a string with refs in it and a composed value
 * are each read to their literal. A token a mode decides is read as its base value and reported.
+*
+* With `variables`, a value a preset animates to that is a bare ref to a token a style rule sets
+* ({@link ruleSetTokens}) is its `var()`, which `motion/react` reads off the element it animates as
+* the animation starts, so it lands where the rule put it. In a composed value such a token is read as
+* its base value and reported, since `motion/react` reads a `var()` only as the whole value. A
+* `transition` is timing, not a value animated to, so a ref under one is read to its literal either
+* way.
 */
-function resolvePresetValue({ config, value, at, report }) {
+function resolvePresetValue({ config, value, at, report, variables = false }) {
 	const refs = collectRefs(value).filter((target) => kindOf(target) === "token");
 	const container = Array.isArray(value) || typeof value === "object" && value !== null && !isRef(value) && !composedValueFormOf(value);
 	if (refs.length === 0 && !container) return { value };
@@ -57,6 +93,7 @@ function resolvePresetValue({ config, value, at, report }) {
 			config,
 			target: value.__ref
 		});
+		if (variables && row?.variable && ruleSetTokens(config).has(row.path)) return { value: `var(${row.variable})` };
 		if (row?.state.kind === "value") return { value: motionValue(row.state.value.css) };
 	}
 	if (Array.isArray(value)) {
@@ -66,7 +103,8 @@ function resolvePresetValue({ config, value, at, report }) {
 				config,
 				value: item,
 				at: `${at}.${index}`,
-				report
+				report,
+				variables
 			});
 			if (!resolved) return void 0;
 			items.push(resolved.value);
@@ -80,7 +118,8 @@ function resolvePresetValue({ config, value, at, report }) {
 				config,
 				value: inner,
 				at: `${at}.${key}`,
-				report
+				report,
+				variables: variables && key !== "transition"
 			});
 			if (!resolved) continue;
 			if (key !== "ease") {
@@ -105,14 +144,22 @@ function resolvePresetValue({ config, value, at, report }) {
 		}
 		return { value: fields };
 	}
-	for (const target of refs) if (tokenValueRow({
-		config,
-		target
-	})?.state.kind === "conditional") report({
-		at,
-		token: pathOf(target),
-		problem: "conditional"
-	});
+	for (const target of refs) {
+		const row = tokenValueRow({
+			config,
+			target
+		});
+		if (variables && row !== void 0 && ruleSetTokens(config).has(row.path)) report({
+			at,
+			token: pathOf(target),
+			problem: "rule-set"
+		});
+		else if (row?.state.kind === "conditional") report({
+			at,
+			token: pathOf(target),
+			problem: "conditional"
+		});
+	}
 	const literal = renderValue({
 		config,
 		value,
@@ -147,7 +194,8 @@ function resolveBody(config, preset, body, tokens) {
 			report: (problem) => tokens.push({
 				preset,
 				...problem
-			})
+			}),
+			variables: field !== "transition"
 		});
 		if (resolved) props[field] = resolved.value;
 	}
@@ -165,7 +213,8 @@ const resolveJsMotionPresets = createSliceMemo({
 		"component",
 		"token",
 		"settings",
-		"font"
+		"font",
+		"global-style"
 	],
 	compute: (config) => {
 		const presets = {};
@@ -187,7 +236,8 @@ const resolveJsMotionPresets = createSliceMemo({
 /**
 * Every JS-runtime preset, by path, as the props the wrapper spreads onto the animated component.
 * A token a preset names reaches `motion/react` as its value — `Token.ref('springStiffness/snappy')`
-* as `400`, a `200ms` duration as `0.2` — since it reads numbers and seconds, not variables.
+* as `400`, a `200ms` duration as `0.2` — since it reads numbers and seconds, not variables. A token
+* a style rule sets is the one exception: it reaches `motion/react` as its `var()`.
 */
 function jsMotionPresets(config) {
 	return resolveJsMotionPresets(config).presets;

package/dist/framework/Config.js

@@ -5864,7 +5864,7 @@ var Config = class Config {
 		const claimed = schemaVersionOf(stored);
 		if (claimed > 20261013201548) throw new SchemaVersionTooNew(claimed);
 		const wire = upgradeSerializedConfig(stored);
-		if (!Array.isArray(wire.ownedKinds) || typeof wire.items !== "object" || wire.items === null) throw new ConfigFormatError(`Config "${stored.name ?? "system-config"}" cannot be hydrated: this is not a serialized config-v2 config (no "ownedKinds"/"items"). A pre-cutover build artifact converts through the registered cutover migration — import the config type's module (e.g. \`configs/system\`) before hydrating, or port the repo once with \`uds migrate\`.`);
+		if (!Array.isArray(wire.ownedKinds) || typeof wire.items !== "object" || wire.items === null) throw new ConfigFormatError(`Config "${stored.name ?? "system-config"}" cannot be hydrated: this is not a serialized config-v2 config (no "ownedKinds"/"items"). A pre-cutover build artifact converts through the registered cutover migration — import the config type's module (e.g. \`configs/system\`) before hydrating.`);
 		const leftover = wire.options;
 		if (isPlainObject(leftover) && Object.keys(leftover).length > 0) throw new ConfigFormatError(`Config "${stored.name ?? "system-config"}" carries an \`options\` slot holding ${Object.keys(leftover).map((key) => `"${key}"`).join(", ")} after every migration ran — this config type has nowhere to keep them. Rebuild it: \`uds build\` and \`uds push\` for a system with a repo; for a system created in Create, reset the local database that holds it.`);
 		const meta = this.metaDraft();

package/dist/migrations/2.0.0/v1-artifact.js

@@ -19,18 +19,16 @@ import { parseRawCss } from "./raw-css.js";
 import { System } from "../../configs/system.js";
 //#region src/migrations/2.0.0/v1-artifact.ts
 /**
-* The v1 → config-v2 reader, for `uds migrate` and nothing else.
+* The v1 → config-v2 reader, run by the cutover schema migration in `configs/system.ts`.
 *
 * A v1 system's authoring vocabulary is gone, so its `uds.config.ts` cannot be imported — but what
-* that config DESCRIBED survives in the flat `config.json` its last build wrote. This reads that
-* artifact into a config-v2 `System`, which `uds migrate` then renders back out as v2 source.
+* that config described survives in the flat `config.json` its last build wrote. This reads that
+* artifact into a config-v2 `System`.
 *
-* **Runtime code must not come through here.** Every stored artifact is the config-v2 wire form and
-* `Config.fromJSON` is the one door to it; this exists for the one-time port of a repo that never
-* built on the new version. It is also best-effort in a way a runtime path must not be: the few old
-* shapes config-v2 doesn't model (color expressions, component `preview`) pass through or drop
-* rather than failing the load, so a config read through here is the
-* starting point for a migration, not a faithful copy of a system.
+* Runtime code doesn't come through here directly. `Config.fromJSON` is the one door to a stored
+* artifact, and it reaches this only for one stamped before config-v2. It is best-effort: the few
+* old shapes config-v2 doesn't model (color expressions, component `preview`) pass through or drop
+* rather than failing the load, so a config read through here is not a faithful copy of a system.
 */
 /**
 * Default authoring guidance seeded onto a system that declares none — the stop-gap that fills