@yahoo/uds-create-config 5.70.0 → 5.72.0

package/dist/spec/prop-mapping.d.ts

@@ -15,10 +15,19 @@ interface PropMappingRule {
   readonly unset?: readonly string[];
 }
 interface PropMapping {
-  /** The component whose instances it rewrites, as a path. */
+  /** The component whose instances it rewrites, as a path. With `from`, the one they become. */
   readonly component: string;
+  /** The component whose instances become `component`'s, as a path; it needn't exist anymore. */
+  readonly from?: string;
+  /** Limits it to some nodes of one design file, by its canvas id and their ids: Create's alone. */
+  readonly only?: MappingScope;
   readonly rules: readonly PropMappingRule[];
 }
+/** Some nodes of one design file. */
+interface MappingScope {
+  readonly canvas: string;
+  readonly nodes: readonly string[];
+}
 /** A rule as a tool takes it: the shape every surface that applies a mapping parses its input with. */
 declare const propMappingRuleSchema: z.ZodObject<{
   when: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
@@ -31,6 +40,29 @@ declare const propMappingRulesSchema: z.ZodArray<z.ZodObject<{
   set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   unset: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>>;
+/** A swap's rules: none is a swap that keeps every prop, and `when: {}` reaches every swapped instance. */
+declare const swapMappingRulesSchema: z.ZodArray<z.ZodObject<{
+  when: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+  set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  unset: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>;
+/**
+ * A mapping's rules as `map-props` takes them: at least one for a mapping, any number for a swap
+ * (`from`), where none keeps the swapped instances' props and `when: {}` reaches every one of them.
+ * Required by the op's own check rather than the schema, so one shape serves both.
+ */
+declare const mapPropsRulesSchema: z.ZodDefault<z.ZodArray<z.ZodObject<{
+  when: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+  set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  unset: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>>;
+/** `only` as a tool takes it. */
+declare const mappingScopeSchema: z.ZodObject<{
+  canvas: z.ZodString;
+  nodes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/** `from` as a tool takes it. */
+declare const mappingFromSchema: z.ZodString;
 /**
  * The mappings a batch of edits carries, in order: each `component/map-props` op as the mapping it
  * applies. The op changes nothing in the config, so the host that ran the batch applies these to the
@@ -94,4 +126,4 @@ type MappedProps = {
  */
 declare function mapComponentProps(config: Config, mapping: PropMapping, instances: readonly Record<string, unknown>[]): MappedProps;
 //#endregion
-export { MappedInstance, MappedProps, MatchedValue, PropMapping, PropMappingConflict, PropMappingResult, PropMappingRule, applyPropMapping, mapComponentProps, onlyMapsProps, propMappingErrors, propMappingRuleSchema, propMappingRulesSchema, propMappingsIn };
+export { MappedInstance, MappedProps, MappingScope, MatchedValue, PropMapping, PropMappingConflict, PropMappingResult, PropMappingRule, applyPropMapping, mapComponentProps, mapPropsRulesSchema, mappingFromSchema, mappingScopeSchema, onlyMapsProps, propMappingErrors, propMappingRuleSchema, propMappingRulesSchema, propMappingsIn, swapMappingRulesSchema };

package/dist/spec/prop-mapping.js

@@ -22,6 +22,11 @@ import { z } from "zod";
 * Positions follow the rename rewriter's: an element's own props, every modifier block nested in
 * them (`_hover: { variant: … }` is the same element's props under a condition), and each
 * `layerProps` bag whose layer renders the component.
+*
+* A mapping with `from` also swaps the component: instances of `from`, a component the system
+* may no longer have (the Bridge's `SelectContent`, after a take made in code replaced it), become
+* instances of `component`, and the rules move their props onto it. Which component replaces which
+* is as much a decision as a prop's new spelling, so it comes from the person too.
 */
 /** A rule as a tool takes it: the shape every surface that applies a mapping parses its input with. */
 const propMappingRuleSchema = z.object({
@@ -35,6 +40,21 @@ const propMappingRuleSchema = z.object({
 });
 /** The rules of a mapping, as a tool takes them. */
 const propMappingRulesSchema = z.array(propMappingRuleSchema).min(1).describe("Every rule whose `when` matches an instance as stored applies to it, so separate props are mapped by separate rules, and a combination by one rule naming both.");
+/** A swap's rules: none is a swap that keeps every prop, and `when: {}` reaches every swapped instance. */
+const swapMappingRulesSchema = z.array(propMappingRuleSchema).describe("The rules for the swapped instances, as a mapping has them. `when: {}` applies to every one of them (to `unset` a prop the new component lacks), and none keeps their props as they are.");
+/**
+* A mapping's rules as `map-props` takes them: at least one for a mapping, any number for a swap
+* (`from`), where none keeps the swapped instances' props and `when: {}` reaches every one of them.
+* Required by the op's own check rather than the schema, so one shape serves both.
+*/
+const mapPropsRulesSchema = z.array(propMappingRuleSchema).default([]).describe("Every rule whose `when` matches an instance as stored applies to it, so separate props are mapped by separate rules, and a combination by one rule naming both. A mapping needs at least one. With `from`, none keeps the swapped instances' props, and `when: {}` reaches every swapped instance.");
+/** `only` as a tool takes it. */
+const mappingScopeSchema = z.object({
+	canvas: z.string().min(1).describe("The design file's canvas id."),
+	nodes: z.array(z.string().min(1)).min(1).describe("The ids of the nodes it reaches, in that design file.")
+}).describe("Create only: limits the mapping to these nodes of one design file, for fixing one instance before asking about the rest. A checkout's call sites aren't nodes, so there it isn't taken.");
+/** `from` as a tool takes it. */
+const mappingFromSchema = z.string().min(1).describe("The component whose instances become this one's, as a path: the one a design file still names after the system lost it (`SelectContent`, replaced by `SelectMenu`). It needn't exist. Which component replaces which is the user's call: propose it, and apply it only once they confirm.");
 /**
 * The mappings a batch of edits carries, in order: each `component/map-props` op as the mapping it
 * applies. The op changes nothing in the config, so the host that ran the batch applies these to the
@@ -45,10 +65,15 @@ function propMappingsIn(edits) {
 	return edits.flatMap((edit) => {
 		const { op } = editOp(edit);
 		if (op.kind !== "component" || op.operation !== "map-props") return [];
-		const rules = propMappingRulesSchema.safeParse(op.data?.rules);
+		const data = op.data;
+		const from = typeof data?.from === "string" ? data.from : void 0;
+		const only = mappingScopeSchema.safeParse(data?.only);
+		const rules = (from ? swapMappingRulesSchema : propMappingRulesSchema).safeParse(data?.rules ?? (from ? [] : void 0));
 		if (!rules.success || typeof op.path !== "string") return [];
 		return [{
 			component: op.path.replace(/^component:/, ""),
+			...from ? { from: from.replace(/^component:/, "") } : {},
+			...only.success ? { only: only.data } : {},
 			rules: rules.data
 		}];
 	});
@@ -81,9 +106,10 @@ function valueRefusal(config, component, prop, value) {
 */
 function propMappingErrors(config, mapping) {
 	if (!config.resolve("component", mapping.component)) return [`No component "${mapping.component}"`];
+	if (mapping.from === mapping.component) return [`"${mapping.component}" can't replace itself: \`from\` names the component its instances are now`];
 	const errors = [];
 	mapping.rules.forEach((rule, i) => {
-		if (Object.keys(rule.when).length === 0) errors.push(`Rule ${i + 1} matches every instance: name what it matches in \`when\``);
+		if (Object.keys(rule.when).length === 0 && mapping.from === void 0) errors.push(`Rule ${i + 1} matches every instance: name what it matches in \`when\``);
 		for (const [name, value] of Object.entries(rule.set ?? {})) {
 			const prop = surfaceProp(config, mapping.component, name);
 			if (!prop) {
@@ -125,6 +151,11 @@ function mapBag(bag, rules) {
 		bag: next
 	};
 }
+/** A stored type naming `to` in place of what it names, keeping the source it was placed through. */
+function retyped(type, to) {
+	const at = type.lastIndexOf("@");
+	return `component:${to}${type.includes(":") && at > 0 ? type.slice(at) : ""}`;
+}
 /**
 * A props bag on `component`, with the mapping applied to it when it's the mapped component's, and
 * to the modifier blocks and layer overrides inside it either way. `undefined` when nothing moved.
@@ -192,8 +223,10 @@ function applyPropMapping(config, spec, mapping) {
 	let elements;
 	let changed = 0;
 	const conflicts = [];
+	const reached = mapping.only ? new Set(mapping.only.nodes) : void 0;
 	for (const [key, element] of Object.entries(spec.elements ?? {})) {
-		if (!element?.props) continue;
+		if (!element) continue;
+		if (reached && !reached.has(key)) continue;
 		const walk = {
 			config,
 			mapping,
@@ -201,14 +234,18 @@ function applyPropMapping(config, spec, mapping) {
 			conflicts,
 			changed: 0
 		};
-		const props = mapProps(walk, componentOf(element.type), element.props, "props");
-		if (!props) continue;
+		const component = componentOf(element.type);
+		const swapped = mapping.from !== void 0 && component === mapping.from && typeof element.type === "string";
+		if (!swapped && !element.props) continue;
+		const props = mapProps(walk, swapped ? mapping.component : component, element.props ?? {}, "props");
+		if (!props && !swapped) continue;
 		elements ??= { ...spec.elements };
 		elements[key] = {
 			...element,
-			props
+			...swapped ? { type: retyped(element.type, mapping.component) } : {},
+			...props ? { props } : {}
 		};
-		changed += walk.changed;
+		changed += walk.changed + (swapped && walk.changed === 0 ? 1 : 0);
 	}
 	return elements ? {
 		spec: {
@@ -236,7 +273,7 @@ function mapComponentProps(config, mapping, instances) {
 		errors
 	};
 	const { spec, conflicts } = applyPropMapping(config, { elements: Object.fromEntries(instances.map((props, i) => [String(i), {
-		type: `component:${mapping.component}`,
+		type: `component:${mapping.from ?? mapping.component}`,
 		props
 	}])) }, mapping);
 	return {
@@ -245,11 +282,11 @@ function mapComponentProps(config, mapping, instances) {
 			const after = spec.elements?.[String(i)]?.props ?? props;
 			return {
 				props: after,
-				changed: after !== props,
+				changed: after !== props || mapping.from !== void 0,
 				conflicts: conflicts.filter((conflict) => conflict.element === String(i)).flatMap((conflict) => conflict.props)
 			};
 		})
 	};
 }
 //#endregion
-export { applyPropMapping, mapComponentProps, onlyMapsProps, propMappingErrors, propMappingRuleSchema, propMappingRulesSchema, propMappingsIn };
+export { applyPropMapping, mapComponentProps, mapPropsRulesSchema, mappingFromSchema, mappingScopeSchema, onlyMapsProps, propMappingErrors, propMappingRuleSchema, propMappingRulesSchema, propMappingsIn, swapMappingRulesSchema };