@yahoo/uds-create-config 4.10.2 → 4.10.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yahoo/uds-create-config",
-  "version": "4.10.2",
+  "version": "4.10.4",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -88,5 +88,5 @@
   "files": [
     "dist"
   ],
-  "udsSchemaVersion": 20260920161309
+  "udsSchemaVersion": 20260922013625
 }

package/dist/renderer/assetEntries.d.ts

@@ -1,37 +0,0 @@
-import { IconLibrary } from "./icon-library.js";
-import { AssetRenderProps } from "./assetRenderable.js";
-import { ComponentEntry } from "./componentEntry.js";
-import React from "react";
-
-//#region src/renderer/assetEntries.d.ts
-/** Plain, provider-free asset renderables indexed `slug → name → component`.
- *  Each is `makeAssetRenderable(SystemComponent, member, name)` — the SAME
- *  component identity the registry keys under the namespaced asset type, but
- *  surfaced directly so callers (e.g. the icon picker) can render a single
- *  glyph without standing up a json-render engine per cell. */
-type AssetMembers = ReadonlyMap<string, ReadonlyMap<string, React.ComponentType<AssetRenderProps>>>;
-interface AssetEntriesResult {
-  /** One ctx-shaped entry per placed glyph, keyed by its spec `type` (`icon:icons/Trophy`). */
-  entries: Record<string, ComponentEntry>;
-  /** @see AssetMembers — empty when the config registers no placeable assets. */
-  assetMembers: AssetMembers;
-}
-/**
- * Registry entries for a config's placeable asset libraries.
- *
- * Each glyph keys under the member's own ref (`icon:icons/Trophy`) — a `kind:path` key can't
- * collide with a `component:` or `package:` key, so the entries merge into the registry's
- * component map safely. In the same pass (`libraries` may be a one-shot iterator), each member is
- * indexed by slug + name so a picker can render one glyph directly.
- */
-declare function assetRegistryEntries({
-  libraries,
-  components
-}: {
-  libraries: Iterable<IconLibrary>;
-  /** The registry's own component bindings — where a group's declared system component (its
-   *  `Icon`, which owns the set-specific size/variant → glyph mapping) is resolved from. */
-  components: Record<string, React.ComponentType<any>>;
-}): AssetEntriesResult;
-//#endregion
-export { AssetEntriesResult, AssetMembers, assetRegistryEntries };

package/dist/renderer/assetEntries.js

@@ -1,38 +0,0 @@
-import { makeAssetRenderable } from "./assetRenderable.js";
-import { makeComponentEntry } from "./componentEntry.js";
-//#region src/renderer/assetEntries.ts
-/**
-* Registry entries for a config's placeable asset libraries.
-*
-* Each glyph keys under the member's own ref (`icon:icons/Trophy`) — a `kind:path` key can't
-* collide with a `component:` or `package:` key, so the entries merge into the registry's
-* component map safely. In the same pass (`libraries` may be a one-shot iterator), each member is
-* indexed by slug + name so a picker can render one glyph directly.
-*/
-function assetRegistryEntries({ libraries, components }) {
-	const entries = {};
-	const assetMembers = /* @__PURE__ */ new Map();
-	for (const group of libraries) {
-		const members = group.members;
-		if (!members) continue;
-		const SystemComponent = group.component !== void 0 ? components[group.component] : void 0;
-		const bySlug = /* @__PURE__ */ new Map();
-		for (const name of group.assetNames) {
-			const member = members[name];
-			if (member === void 0) continue;
-			const key = group.assetType(name);
-			entries[key] = makeComponentEntry({
-				component: makeAssetRenderable(void 0, member, name),
-				name: key
-			});
-			bySlug.set(name, makeAssetRenderable(SystemComponent, member, name));
-		}
-		assetMembers.set(group.name, bySlug);
-	}
-	return {
-		entries,
-		assetMembers
-	};
-}
-//#endregion
-export { assetRegistryEntries };

package/dist/renderer/assetRenderable.d.ts

@@ -1,25 +0,0 @@
-import React from "react";
-
-//#region src/renderer/assetRenderable.d.ts
-/** Props callers pass when rendering an asset member directly (icon picker
- *  grid, drag ghost). The member — or the system component it renders through —
- *  maps these to a glyph; the registry-derived `name` always wins.
- *
- *  The type is deliberately CLOSED (no index signature), so a misspelled
- *  `variant` or `size` at a render site is a compile error rather than a glyph
- *  quietly drawn with its defaults. A caller that has resolved a
- *  system-component prop from the config (e.g. the prop that binds CSS `color`,
- *  so a chrome surface can make the glyph inherit its own text color) hands it
- *  through `systemProps` — one named channel, so this contract never has to
- *  name any system's props and never has to open up to admit them. */
-type AssetRenderProps = {
-  variant?: string;
-  size?: string | number;
-  /** Props of the system component the member renders through, resolved from
-   *  the config by the caller and spread onto it verbatim. Ignored when no
-   *  system component is bound: they were resolved for that component, and a
-   *  raw glyph has no use for them. */
-  systemProps?: Readonly<Record<string, string>>;
-};
-//#endregion
-export { AssetRenderProps };

package/dist/renderer/assetRenderable.js

@@ -1,19 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-//#region src/renderer/assetRenderable.tsx
-function makeAssetRenderable(SystemComponent, member, name) {
-	if (SystemComponent === void 0) {
-		const Member = member;
-		return function RawAssetRenderable({ systemProps: _, ...props }) {
-			return /* @__PURE__ */ jsx(Member, { ...props });
-		};
-	}
-	return function AssetRenderable({ systemProps, ...props }) {
-		return /* @__PURE__ */ jsx(SystemComponent, {
-			...systemProps,
-			...props,
-			name
-		});
-	};
-}
-//#endregion
-export { makeAssetRenderable };

package/dist/spec/asset-jsx.d.ts

@@ -1,61 +0,0 @@
-//#region src/spec/asset-jsx.d.ts
-/**
- * The identifier a type is KNOWN AS in JSX — `component:buttons/Primary` → `Primary`.
- *
- * A type is a ref (`component:buttons/Primary`), and neither half of it is JSX: the kind isn't part
- * of the name, and a grouped path isn't a legal tag or import name. The leaf is what codegen names
- * the export, so `<Primary />` and `import { Primary }` agree with the module that actually exists.
- * An intrinsic tag has no kind and no group, so it passes through untouched.
- */
-declare function jsxIdentifier(type: string): string;
-/** Pull the library slug + member out of an asset node's type, or `null` for anything else — a
- *  component, a package export, an intrinsic tag. */
-declare function parseAssetType(type: string): {
-  slug: string;
-  member: string;
-} | null;
-/**
- * `slug → the component a placed member renders through` (e.g. `{ icons: 'Icon' }`).
- * Derived from the asset groups that declare a `component`; a slug missing from
- * the map has no authoring component and falls back to the bare member tag.
- * A value may be the component's bare name OR its full path (`primitives/Icon`) —
- * serialization reduces it to the JSX leaf either way ({@link jsxIdentifier}),
- * since a grouped path is not a legal tag.
- */
-type AssetComponentMap = Readonly<Record<string, string>>;
-/** How a placed asset node should appear in exported JSX. */
-interface AssetJsxForm {
-  /** The JSX tag — the authoring component (`Icon`) or the bare member. */
-  tag: string;
-  /**
-   * The `name` attribute value when the authoring component carries the
-   * member identity (`name="Trophy"`). Absent on the bare-member fallback,
-   * which IS the member.
-   */
-  nameAttr?: string;
-  /** Identifier to import — the component when mapped, else the member. */
-  importName: string;
-}
-/**
- * Resolve a spec element `type` to its exported-JSX form, or `null` when the
- * type is not an asset node (a normal component — caller serializes as usual).
- *
- *  - mapped slug → `<Icon name="Member" … />` (component-typed export);
- *  - unmapped slug → `<Member … />` (component-less fallback — a self-contained
- *    member renders itself; a bare-path glyph would need raw `<svg>`, which the
- *    string-only serializers can't synthesize, so the member tag is the best
- *    they can emit).
- */
-declare function assetJsxForm(type: string, assetComponents?: AssetComponentMap): AssetJsxForm | null;
-/**
- * Inverse of `assetJsxForm` for the editor round-trip: given a parsed JSX tag
- * and its props, reconstruct the asset-node `type` string — or `null` if the
- * tag is a genuine component, not an authoring component placing a known member.
- * The caller closes over its live config to find the group whose `component`
- * matches `tag` and whose members include the `name` value, then returns
- * `group.assetType(name)`. When it resolves, the parser drops the `name` prop
- * (the member identity lives in the type) and keeps the rest (variant, size).
- */
-type AssetNodeResolver = (tag: string, props: Readonly<Record<string, unknown>>) => string | null;
-//#endregion
-export { AssetComponentMap, AssetJsxForm, AssetNodeResolver, assetJsxForm, jsxIdentifier, parseAssetType };