@yahoo/uds-create-config 5.35.0 → 5.35.2

package/dist/entities/system/Component.js

@@ -664,10 +664,11 @@ function canonicalWhen(when) {
 function styleBagValue({ config, declaration, name = "<prop>", glyphLibraries }) {
 	const domain = valueSchemaOf(declaration, config);
 	const bound = declaration?.value;
-	if (glyphLibraries && glyphLibraries.length > 0) return z.union([glyphMemberRefIn({
+	if (glyphLibraries && glyphLibraries.length > 0) return glyphMemberRefIn({
 		config,
-		libraries: glyphLibraries
-	}), domain]);
+		libraries: glyphLibraries,
+		otherwise: domain
+	});
 	if (declaration?.type === "slot" && !isValueSlot(declaration)) return z.union([domain, z.never()], { error: () => `\`${name}\` is a slot, so a rule may set it to a string of content and nothing else. A glyph or a nested element is an anatomy node under the layer's node — \`{ "element": { "__ref": "icon:<library>/<Name>" }, "visible": { "$state": "<prop>", "eq": "<value>" } }\` to show one per variant value — and the instance's own content arrives through the prop.` });
 	if (!isRef(bound) || kindOf(bound.__ref) !== "style-property") return domain;
 	const property = pathOf(bound.__ref);
@@ -1140,10 +1141,14 @@ const Preview = defineSubEntity({
 				for (const [name, decl] of Object.entries(body.states ?? {})) when[name] = stateConditionValue(decl).optional();
 				return z.strictObject({
 					when: z.strictObject(when, { error: previewShapeError }).nullable().default(null),
-					props: z.record(z.string(), z.unknown()).transform((props) => bindPreviewGlyphs({
+					props: z.record(z.string(), z.unknown()).transform((props, ctx) => bindPreviewGlyphs({
 						config,
 						props,
-						glyphProps
+						glyphProps,
+						refuse: (message) => ctx.addIssue({
+							code: "custom",
+							message
+						})
 					}))
 				}, { error: previewShapeError });
 			}

package/dist/entities/system/glyph-identity.js

@@ -173,15 +173,55 @@ function glyphOfLibrary({ library, module, leaves }) {
 		return identity.name;
 	});
 }
+/** Why a string under a glyph key is refused: it names no member of the libraries the key reaches. */
+function notAMember({ spelled, libraries }) {
+	return `\`${spelled}\` is not a member of ${libraries.map((library) => `the icon library "${library}"`).join(" or ")}, which this key draws from.`;
+}
+/**
+* The member ref a written glyph name spells under `libraries`: the member's name (`StarIcon`), its
+* path (`phosphor/StarIcon`) or its ref's spelling (`icon:phosphor/StarIcon`). A bare name resolves
+* under the first listed library holding it, in the order the key's declaration names them.
+* `undefined` when no listed library holds what the string names.
+*/
+function spelledGlyphRef({ config, libraries, spelled }) {
+	const colon = spelled.indexOf(":");
+	const path = colon !== -1 && spelled.slice(0, colon) === "icon" ? spelled.slice(colon + 1) : spelled;
+	for (const library of libraries) {
+		const name = path.startsWith(`${library}/`) ? path.slice(library.length + 1) : path;
+		if (memberLeaves(config, `icon:${library}`).includes(name)) return { __ref: `icon:${library}/${name}` };
+	}
+}
 /**
-* The glyph form for a key that reaches a library through a forward (`icon` → `icon/name`): the
-* component, its `package:` ref, the member's name a surface writes, or the member ref a stored
-* config already holds, answered as the member ref `icon:<library>/<name>`. The ref names its library, so a key reaching several resolves
-* without a lookup. Each library's arm refuses by cause, so a glyph of a library the key does not
-* reach says so.
+* The glyph form for a key that reaches a library through a forward (`icon` → `icon/name`),
+* answered as the member ref `icon:<library>/<name>`: the component, its `package:` ref, the member
+* ref a stored config holds, or a string spelling a member ({@link spelledGlyphRef}). The ref names
+* its library, so a key reaching several resolves without a lookup.
+*
+* Every string is answered here, so a string that names no member is refused rather than stored as
+* text the receiving prop cannot draw. The empty string is the one exception: it is how a surface
+* clears a glyph over a default, and passes through as written. Each library's component arm refuses
+* by cause, so a glyph of a library the key does not reach says so. `otherwise` takes every value
+* that is not a string.
 */
-function glyphMemberRefIn({ config, libraries }) {
-	const arms = libraries.map((library) => {
+function glyphMemberRefIn({ config, libraries, otherwise }) {
+	const spelledArm = z.string().transform((spelled, ctx) => {
+		if (spelled === "") return spelled;
+		const ref = spelledGlyphRef({
+			config,
+			libraries,
+			spelled
+		});
+		if (ref) return ref;
+		ctx.addIssue({
+			code: "custom",
+			message: notAMember({
+				spelled,
+				libraries
+			})
+		});
+		return z.NEVER;
+	});
+	const componentArms = libraries.map((library) => {
 		const facts = libraryGlyphFacts({
 			config,
 			target: `icon:${library}`
@@ -193,14 +233,14 @@ function glyphMemberRefIn({ config, libraries }) {
 			const name = path.slice(library.length + 1);
 			return path.startsWith(`${library}/`) && facts.leaves.includes(name) ? name : void 0;
 		};
-		return z.union([
-			z.custom((value) => memberOfRef(value) !== void 0).transform((value) => toRef(memberOfRef(value))),
-			z.string().refine((name) => facts.leaves.includes(name)).transform(toRef),
-			glyphOfLibrary(facts).transform((name) => toRef(name))
-		]);
+		return z.union([z.custom((value) => memberOfRef(value) !== void 0).transform((value) => toRef(memberOfRef(value))), glyphOfLibrary(facts).transform((name) => toRef(name))]);
 	});
-	if (arms.length === 1) return arms[0];
-	return z.union(arms);
+	const nonString = z.custom((value) => typeof value !== "string").pipe(otherwise);
+	return z.union([
+		spelledArm,
+		...componentArms,
+		nonString
+	]);
 }
 /** `icon:<library>/<name>` for a glyph identity a library of this config claims; `undefined` when
 *  none does. */
@@ -218,11 +258,11 @@ function glyphMemberRefOf(config, identity) {
 * way `defaultProps` are. Once an owner is known, this pass binds each such ref to
 * `icon:<library>/<name>` through the library whose package ships it, at the top level and inside a
 * stored element's props, which is the spelling the build writes when it reads `.preview()` from
-* source. A member's name written under one of the owner's glyph props (`glyphProps`) binds through
-* the first of that prop's libraries holding it. A `package:` ref no library claims is another
-* package's export and stays as written.
+* source. A string spelling a member under one of the owner's glyph props (`glyphProps`) binds
+* through that prop's libraries ({@link spelledGlyphRef}), and one naming no member is refused. A
+* `package:` ref no library claims is another package's export and stays as written.
 */
-function bindPreviewGlyphs({ config, props, glyphProps = {} }) {
+function bindPreviewGlyphs({ config, props, glyphProps = {}, refuse }) {
 	const bind = (value) => {
 		if (typeof value !== "object" || value === null) return value;
 		if (Array.isArray(value)) return value.map(bind);
@@ -234,10 +274,18 @@ function bindPreviewGlyphs({ config, props, glyphProps = {} }) {
 	};
 	const out = bind(props);
 	for (const [prop, libraries] of Object.entries(glyphProps)) {
-		const name = out[prop];
-		if (typeof name !== "string") continue;
-		const library = libraries.find((path) => memberLeaves(config, `icon:${path}`).includes(name));
-		if (library) out[prop] = { __ref: `icon:${library}/${name}` };
+		const spelled = out[prop];
+		if (typeof spelled !== "string" || spelled === "") continue;
+		const ref = spelledGlyphRef({
+			config,
+			libraries,
+			spelled
+		});
+		if (ref) out[prop] = ref;
+		else refuse?.(notAMember({
+			spelled,
+			libraries
+		}));
 	}
 	return out;
 }

package/dist/entities/system/style-bag.js

@@ -59,10 +59,11 @@ const Style = defineSubEntity({
 				config,
 				body: parent
 			})[key];
-			if (libraries && libraries.length > 0) return z.union([glyphMemberRefIn({
+			if (libraries && libraries.length > 0) return glyphMemberRefIn({
 				config,
-				libraries
-			}), styleValue]);
+				libraries,
+				otherwise: styleValue
+			});
 		}
 		if (declared) return styleValue;
 		if (!config.resolve("style-property", key)) return styleValue;

package/dist/framework/render-spec.d.ts

@@ -389,7 +389,8 @@ declare function withoutTruthyTerm({
  * rather than 51 conditioned siblings copying a library's index into every component that draws a
  * glyph.
  *
- * Two ways the domain is known, in order: the prop delegates it (`value` is a ref to the library, or
+ * A member ref (`icon:phosphor/StarIcon`), the form a glyph is stored in, names the type itself when
+ * its library is one the prop draws from ({@link memberRefType}). A name is looked up in the prop's domain, which is known two ways, in order: the prop delegates it (`value` is a ref to the library, or
  * a list of refs for a host drawing from several, which is the shape that keeps 1,530 names in one
  * place), or the prop enumerates its values and the member is found by asking which group declares
  * it. The second exists because a config migrated from v1 spells an icon prop as an enumeration, and

package/dist/framework/render-spec.js

@@ -869,18 +869,24 @@ function spentBy({ condition, prop }) {
 * rather than 51 conditioned siblings copying a library's index into every component that draws a
 * glyph.
 *
-* Two ways the domain is known, in order: the prop delegates it (`value` is a ref to the library, or
+* A member ref (`icon:phosphor/StarIcon`), the form a glyph is stored in, names the type itself when
+* its library is one the prop draws from ({@link memberRefType}). A name is looked up in the prop's domain, which is known two ways, in order: the prop delegates it (`value` is a ref to the library, or
 * a list of refs for a host drawing from several, which is the shape that keeps 1,530 names in one
 * place), or the prop enumerates its values and the member is found by asking which group declares
 * it. The second exists because a config migrated from v1 spells an icon prop as an enumeration, and
 * a glyph is no less resolvable for it.
 */
 function boundElementType(config, componentPath, prop, value) {
-	if (typeof value !== "string" || !value) return void 0;
-	if (value.includes("/")) return void 0;
 	const decl = resolveComponentProps(config, componentPath)[prop];
 	const single = refOf(decl?.value);
 	const targets = refListOf(decl?.value) ?? (single ? [single] : []);
+	if (isRef(value) && kindOf(value) === "icon") return memberRefType({
+		config,
+		targets,
+		value
+	});
+	if (typeof value !== "string" || !value) return void 0;
+	if (value.includes("/")) return void 0;
 	if (targets.length > 0) {
 		for (const target of targets) {
 			if (memberOf(target) !== void 0) continue;
@@ -893,6 +899,17 @@ function boundElementType(config, componentPath, prop, value) {
 	return matches.length === 1 ? `icon:${matches[0]?.path}` : void 0;
 }
 /**
+* The type a member ref names, when the member exists and belongs to one of the prop's libraries
+* (`targets`); a prop that delegates no domain takes any member the config holds. A ref outside
+* them is `undefined`, so the node falls back as it does for a name no library holds.
+*/
+function memberRefType({ config, targets, value }) {
+	if (!config.resolveRef(value.__ref)) return void 0;
+	if (targets.length === 0) return value.__ref;
+	const path = pathOf(value);
+	return targets.some((target) => kindOf(target) === "icon" && memberOf(target) === void 0 && path.startsWith(`${pathOf(target)}/`)) ? value.__ref : void 0;
+}
+/**
 * The props of an instance that the component CONSUMES rather than passes on — the same split the
 * emitted module's destructuring makes (`downlevel.ts`, `styleRuleBindings`).
 *