@yahoo/uds-create-config 2.44.0 → 3.0.0

package/dist/defineAssetGroup.d.ts

@@ -1,200 +0,0 @@
-import { ComponentRef } from "./refs.js";
-import { FontAssetMember } from "./types.js";
-
-//#region src/defineAssetGroup.d.ts
-/**
- * Static metadata an icon-class member may carry (the UDS v3 generated
- * icons stamp this shape). All fields optional — metadata-less
- * libraries (Phosphor) fall back to the documented harvest convention
- * (PascalCase export key + component-shaped value).
- */
-interface IconAssetMetadata {
-  readonly name?: string;
-  readonly isSvgIcon?: boolean;
-  readonly variants?: readonly string[];
-  readonly category?: string;
-  readonly tags?: readonly string[];
-  /**
-   * Variants whose glyph paints a literal white fill by design (a "knockout"
-   * meant for dark or branded surfaces) rather than `currentColor`. Such a
-   * glyph is invisible on a light surface, so pickers and catalogs preview
-   * these variants on a dark surface. Rendering is untouched — the flag is
-   * presentation advice for browsing UIs only.
-   */
-  readonly knockoutVariants?: readonly string[];
-}
-/**
- * Author-supplied metadata layered over a harvested member. `name` is the
- * member's identity, `isSvgIcon` controls the harvest itself, and `variants`
- * states what the glyph can actually render — none of those can be overlaid
- * (an overlaid `variants` would silently hide real variants from the picker).
- * The descriptive fields are fair game for annotating a third-party library
- * whose own `.metadata` doesn't carry them.
- */
-type IconAssetMetadataOverlay = Pick<IconAssetMetadata, 'category' | 'tags' | 'knockoutVariants'>;
-/**
- * One icon-class member — a React component (plain function or a
- * forwardRef/memo exotic) optionally carrying static `.metadata`.
- * Typed structurally so `@yahoo/uds-create-config` doesn't depend on React types
- * here; the renderer casts at the registry boundary.
- */
-type IconAssetMember = ((props: never) => unknown) & {
-  readonly metadata?: IconAssetMetadata;
-};
-/**
- * Icon branch — `type` is optional so icon authors never declare the
- * class. `sizes` is required unless `props` is used (which normalizes
- * into the flat fields). It's load-bearing render data (the `<svg>`
- * shell reads px from it) and the picker's size-option list is derived
- * from its keys.
- */
-interface IconAssetGroupConfig<P = Record<string, unknown>> {
-  type?: 'icon';
-  /** Named size → px (`{ sm: 16, md: 24 }`). Picker options = keys. */
-  sizes?: Readonly<Record<string, number>>;
-  /**
-   * Group-level variant superset the picker starts from. Omitted ⇒
-   * harvested union of members' `.metadata.variants` (first-seen
-   * order), which by construction can't drift behind the library.
-   * Required (in practice) for metadata-less libraries.
-   */
-  variants?: readonly string[];
-  /** Display label. Defaults to the title-cased registration key. */
-  label?: string;
-  /**
-   * Source-library version shown in the Assets UI (e.g. `2.1.1`). Authored,
-   * not derived — a set's published version rarely matches the npm package
-   * that ships its glyphs. Omitted ⇒ no version is shown.
-   */
-  version?: string;
-  description?: string;
-  /**
-   * Filter harvested members by their export key — return `false` to skip one.
-   * A large third-party package often ships more than its canonical glyph set
-   * (Phosphor exports both `HouseIcon` and a deprecated bare `House` alias, plus
-   * non-glyph `IconBase`/`IconContext`). Passing the package wildcard is required
-   * for codegen to bundle live members, so this predicate is how you narrow that
-   * wildcard to the real icons (e.g. `(n) => n.endsWith('Icon')`). Applied before
-   * the PascalCase / component-shape checks; runs over every export key.
-   */
-  include?: (name: string) => boolean;
-  /**
-   * Per-member metadata layered over the harvested `.metadata`, keyed by asset
-   * name. Use it to annotate a third-party library whose glyphs don't carry a
-   * field themselves — e.g. flag `knockoutVariants` from a list the package
-   * exports separately. Overlay fields win over harvested ones. A key that
-   * exists in the member map but wasn't harvested (filtered by `include`, or
-   * skipped by the naming rules) is ignored; a key that names nothing in the
-   * member map is a typo and throws.
-   */
-  memberMetadata?: Readonly<Record<string, IconAssetMetadataOverlay>>;
-  /**
-   * Authoring sugar mirroring the member component's own prop axes. Each entry
-   * is a picker value-set, NOT a style map: keys are the member's
-   * prop names, values are the allowed choices. Exactly ONE entry must be a
-   * named→px MAP (the size axis); at most one entry may be an ARRAY (the variant
-   * axis). Normalized at config-eval into the flat `sizes`/`variants` fields.
-   * Cannot be combined with those flat fields. Type the members via
-   * `defineAssetGroup<IconProps>(...)` to constrain keys to the component's
-   * props (e.g. `variant` → its enum).
-   */
-  props?: { [K in keyof P]?: Readonly<Record<string, number>> | readonly NonNullable<P[K]>[] };
-  /**
-   * The component that authors this group's members in exported code —
-   * e.g. `'Icon'` so a placed asset node `yahoo-os:asset:icons/Trophy`
-   * round-trips through code views as `<Icon name="Trophy" … />`. There
-   * is no implicit link between a group and a component (a group's members
-   * and a component's `name` enum are decoupled even when built from the
-   * same package), so the authoring component is declared explicitly.
-   * It is also the component a placed member *renders through* on the canvas:
-   * the resolved `Icon` owns the set-specific size/variant→glyph mapping. Omit
-   * it for a component-less system: members render bare and exporters fall back
-   * to the bare member tag. Accepts a typed `ComponentRef` (from
-   * `component()`) or a bare string.
-   */
-  component?: string | ComponentRef;
-}
-/**
- * Font branch — `type: 'font'` declares the class. The `never` fields
- * make icon-class props a compile error inside a `{ type: 'font' }`
- * literal regardless of property order (the union is ordering-free,
- * unlike the chained-methods spelling it replaced).
- */
-interface FontAssetGroupConfig {
-  type: 'font';
-  label?: string;
-  /** Source-library version shown in the Assets UI (e.g. `2.1.1`). */
-  version?: string;
-  description?: string;
-  /**
-   * FontIDs to fold in as deprecated at registration — each listed
-   * member is stamped `deprecated: true`. Deprecated fonts stay fully
-   * selectable (no hard block); the flag only lets the picker badge them.
-   * An id not present in the member map is ignored.
-   */
-  deprecated?: readonly string[];
-  /** Icon-class prop — excluded on the font branch at the type level. */
-  sizes?: never;
-  /** Icon-class prop — excluded on the font branch at the type level. */
-  variants?: never;
-  /** Icon-class prop — excluded on the font branch at the type level. */
-  props?: never;
-  /** Icon-class prop — excluded on the font branch at the type level. */
-  component?: never;
-}
-type AssetGroupConfig = IconAssetGroupConfig<Record<string, unknown>> | FontAssetGroupConfig;
-interface AssetGroupDefinitionBase {
-  /** Invariant ref tag — identical for every asset class. */
-  readonly __kind: 'assetGroup';
-  /**
-   * The group's slug — late-bound from the `registerAssetGroups`
-   * record key. Reading before registration throws.
-   */
-  readonly ref: string;
-  readonly label?: string;
-  readonly version?: string;
-  readonly description?: string;
-}
-interface IconAssetGroupDefinition extends AssetGroupDefinitionBase {
-  readonly assetKind: 'icon';
-  /** Harvested members, keyed by asset name (the `${assetName}` id segment). */
-  readonly members: Readonly<Record<string, IconAssetMember>>;
-  /** Per-member harvested `.metadata` (name/variants/category/tags). */
-  readonly memberMetadata: Readonly<Record<string, IconAssetMetadata>>;
-  readonly sizes: Readonly<Record<string, number>>;
-  /** Resolved variant superset — declared, or the harvested union. */
-  readonly variants: readonly string[];
-  /** Authoring component for code export (`'Icon'`), if declared. */
-  readonly component?: string;
-}
-interface FontAssetGroupDefinition extends AssetGroupDefinitionBase {
-  readonly assetKind: 'font';
-  /** Members keyed by `FontID` (kebab-case) — pure-JSON data records. */
-  readonly members: Readonly<Record<string, FontAssetMember>>;
-}
-type AssetGroupDefinition = IconAssetGroupDefinition | FontAssetGroupDefinition;
-/**
- * `defineAssetGroup(members)` return value — the only thing you can do
- * with it is `.config({...})`, which completes the definition. The
- * overloads branch the return type on the config union's discriminant.
- * The phantom `P` generic flows from `defineAssetGroup<P>(...)` and
- * constrains the `props` block keys/values to the member component's
- * own props.
- */
-interface AssetGroupBuilder<P = Record<string, unknown>> {
-  config(config: IconAssetGroupConfig<P>): IconAssetGroupDefinition;
-  config(config: FontAssetGroupConfig): FontAssetGroupDefinition;
-}
-/**
- * Attach icon metadata to a single one-off icon and hand it back
- * unchanged. `isSvgIcon: true` is implied —
- * the point of the call is to mark the component as an icon so the
- * group harvest picks it up. Slots still point at the *group*, never
- * at this.
- */
-declare function defineAssetIcon<T>(component: T, metadata: Omit<IconAssetMetadata, 'isSvgIcon'>): T & {
-  readonly metadata: IconAssetMetadata;
-};
-declare function defineAssetGroup<P = Record<string, unknown>>(members: Readonly<Record<string, unknown>>): AssetGroupBuilder<P>;
-//#endregion
-export { AssetGroupBuilder, AssetGroupConfig, AssetGroupDefinition, FontAssetGroupConfig, FontAssetGroupDefinition, IconAssetGroupConfig, IconAssetGroupDefinition, IconAssetMember, IconAssetMetadata, IconAssetMetadataOverlay, defineAssetGroup, defineAssetIcon };

package/dist/defineAssetGroup.js

@@ -1,323 +0,0 @@
-import { attachSourcePath, captureCallerPath } from "./captureCallerPath.js";
-import { isComponentRef } from "./refs.js";
-//#region src/defineAssetGroup.ts
-/**
-* `defineAssetGroup(members).config({...})` — the asset registration
-* factory. Members are positional (matching
-* `defineTokenGroup(tokens)`, wildcard-import friendly); everything
-* else lives in one chained `.config({...})` discriminated-union.
-*
-* The return value does double duty, the same way `BoundComponent` is
-* both a `ComponentDefinition` and an `FC`:
-*
-*  - it is the registerable group (`uds.registerAssetGroups({ icons })`
-*    reads `members` + config fields off it), and
-*  - it carries the embedded `__kind: 'assetGroup'` / `ref` tag that
-*    `isAssetGroupRef()` / `slot().accepts(...)` read.
-*
-* The `ref` slug is bound late: `registerAssetGroups` stamps the
-* registration key onto the object (the key IS the slug — same
-* late-binding precedent as `Component.registryKey`'s namespace
-* getter). Reading `ref` before registration throws — an unregistered
-* group has no identity to point at.
-*/
-/** Icon-class asset names are PascalCase identifiers — each asset class has its own naming rule (fonts use kebab-case below). */
-const PASCAL_CASE = /^[A-Z][A-Za-z0-9]*$/;
-/** Font-class asset names are kebab-case `FontID`s (`yas`, `centra-no2`). */
-const KEBAB_CASE = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
-/**
-* Component-shaped: a plain function component, or a forwardRef/memo
-* exotic (an object stamped with React's `$$typeof` symbol).
-*/
-function isComponentShaped(value) {
-	if (typeof value === "function") return true;
-	return typeof value === "object" && value !== null && typeof value.$$typeof === "symbol";
-}
-/**
-* Read and *sanitize* a member's static `.metadata`. The harvest is the
-* trust boundary for arbitrary wildcard imports, so loosely-shaped
-* fields are dropped rather than cast — `variants: 'outline'` must not
-* iterate char-by-char into `['o','u','t',…]` downstream.
-*/
-function readIconMetadata(value) {
-	if (typeof value !== "function" && typeof value !== "object") return;
-	if (value === null) return void 0;
-	const metadata = value.metadata;
-	if (metadata === null || typeof metadata !== "object") return void 0;
-	const raw = metadata;
-	const out = {};
-	if (typeof raw.name === "string" && raw.name.length > 0) out.name = raw.name;
-	if (typeof raw.isSvgIcon === "boolean") out.isSvgIcon = raw.isSvgIcon;
-	if (isStringArray(raw.variants)) out.variants = raw.variants;
-	Object.assign(out, sanitizeOverlayFields(raw));
-	return out;
-}
-/**
-* The author-overlayable subset of icon metadata, sanitized the same way the
-* harvest sanitizes a member's own `.metadata`: loosely-shaped values are
-* dropped, never cast. Shared by {@link readIconMetadata} and the
-* `memberMetadata` overlay so the two entry points into the wire form can't
-* disagree about what a well-formed field is.
-*/
-function sanitizeOverlayFields(raw) {
-	const out = {};
-	if (typeof raw.category === "string") out.category = raw.category;
-	if (isStringArray(raw.tags)) out.tags = raw.tags;
-	if (isStringArray(raw.knockoutVariants)) out.knockoutVariants = raw.knockoutVariants;
-	return out;
-}
-/**
-* Layer the author's `memberMetadata` overlay onto the harvested metadata.
-* Only well-formed overlay fields replace harvested ones, so a sparse entry
-* (`{ knockoutVariants: [...] }`) leaves the library's category/tags intact.
-*
-* Keys are asset names (post-rename). A key that names nothing in the source
-* export map is a typo and throws by name. A key that IS an export but was not
-* harvested — filtered out by `include`, or skipped by the naming rules — is
-* ignored, so an author narrowing a wildcard doesn't also have to prune a
-* boilerplate overlay (the emitted v3 config lists the package's knockout
-* glyphs unconditionally).
-*/
-function applyMetadataOverlay(harvested, overlay, sourceKeys) {
-	if (overlay === void 0) return harvested;
-	const out = { ...harvested };
-	for (const [name, fields] of Object.entries(overlay)) {
-		if (out[name] === void 0) {
-			if (sourceKeys.has(name)) continue;
-			throw new Error(`defineAssetGroup: \`memberMetadata.${name}\` names an asset that does not exist in the member map — overlay keys must match a member's asset name.`);
-		}
-		out[name] = {
-			...out[name],
-			...sanitizeOverlayFields(fields)
-		};
-	}
-	return out;
-}
-function isStringArray(value) {
-	return Array.isArray(value) && value.every((entry) => typeof entry === "string");
-}
-/**
-* Icon-class harvest. Wildcard `import * as` carries everything a
-* package exports — helpers, constants, possibly `default` — so
-* non-matching exports are *skipped*, not errors:
-*
-*  - `.metadata.isSvgIcon === true` is definitive — the member is an
-*    icon (named via `.metadata.name`, falling back to the export key).
-*  - `.metadata.isSvgIcon === false` is the explicit opt-out — skipped.
-*    Unrelated metadata (no `isSvgIcon` field) does NOT opt out; the
-*    convention below still applies, so one foreign metadata shape
-*    can't silently shrink the harvest.
-*  - Otherwise the documented convention applies: PascalCase export
-*    key + component-shaped value (covers metadata-less Phosphor-style
-*    libraries).
-*  - `default` is never registered literally — it registers only when
-*    explicit icon metadata supplies a usable PascalCase name (i.e. it
-*    gets renamed), and is otherwise skipped as wildcard noise. This
-*    deliberately includes an explicit-icon `default` whose
-*    `.metadata.name` fails the PascalCase rule: it is *skipped*, not
-*    thrown — unlike the same mistake on a named export (below). A
-*    `default` carries no authored intent to register under a literal
-*    name, so an unusable name on it is noise, not an author error.
-*
-* The loud failures inside the skip-friendly walk: an explicit icon
-* (`isSvgIcon: true`) on a *named* export whose resolved name fails the
-* PascalCase rule, or two members resolving to the same name — both
-* are author errors, not wildcard noise.
-*/
-function harvestIconMembers(raw, include) {
-	const members = {};
-	const memberMetadata = {};
-	for (const [key, value] of Object.entries(raw)) {
-		if (include && !include(key)) continue;
-		if (!isComponentShaped(value)) continue;
-		const metadata = readIconMetadata(value);
-		const isExplicitIcon = metadata?.isSvgIcon === true;
-		if (metadata?.isSvgIcon === false) continue;
-		const name = isExplicitIcon ? metadata?.name ?? key : key;
-		if (key === "default") {
-			if (!isExplicitIcon || !PASCAL_CASE.test(name)) continue;
-		} else if (!isExplicitIcon) {
-			if (!PASCAL_CASE.test(key)) continue;
-		} else if (!PASCAL_CASE.test(name)) throw new Error(`defineAssetGroup: icon member "${key}" resolves to asset name "${name}", which is not a PascalCase identifier — icon asset names become the asset-id name segment. Rename the export or set \`.metadata.name\`.`);
-		if (members[name] !== void 0) throw new Error(`defineAssetGroup: two icon members resolve to the asset name "${name}" — asset names must be unique within a group.`);
-		members[name] = value;
-		memberMetadata[name] = metadata ?? {};
-	}
-	if (Object.keys(members).length === 0) throw new Error("defineAssetGroup: no icon members harvested — expected PascalCase component exports (or components carrying `.metadata.isSvgIcon`). For a font group, declare `.config({ type: 'font' })`.");
-	return {
-		members,
-		memberMetadata
-	};
-}
-/**
-* Font-class guard. Unlike the icon wildcard filter, font members come
-* from an explicit data map where every entry is intended — a member
-* failing the class contract (`fontFamily` + `declarations[]`) is a
-* named config-load error, never a silent skip.
-*/
-function guardFontMembers(raw) {
-	const members = {};
-	for (const [key, value] of Object.entries(raw)) {
-		if (!KEBAB_CASE.test(key)) throw new Error(`defineAssetGroup: font member "${key}" is not a kebab-case FontID — font asset names become the asset-id name segment (e.g. "yas", "centra-no2").`);
-		const record = value;
-		const fontFamily = record?.fontFamily;
-		const declarations = record?.declarations;
-		if (typeof fontFamily !== "string" || fontFamily.length === 0) throw new Error(`defineAssetGroup: font member "${key}" fails the 'font' class contract — missing a non-empty \`fontFamily\` string.`);
-		if (!Array.isArray(declarations)) throw new Error(`defineAssetGroup: font member "${key}" fails the 'font' class contract — missing a \`declarations\` array.`);
-		members[key] = value;
-	}
-	if (Object.keys(members).length === 0) throw new Error("defineAssetGroup: font group has no members — pass the font declarations map (e.g. FONT_DECLARATIONS_MAP).");
-	return members;
-}
-/**
-* Stamp `deprecated: true` on each member named in the `deprecated` list.
-* Shallow-copies only the affected records so the caller's source map is
-* never mutated; ids not in the member map are ignored (governance lists
-* routinely outlive the fonts they name).
-*/
-function foldInDeprecated(members, deprecated) {
-	if (!deprecated?.length) return members;
-	const flagged = new Set(deprecated);
-	for (const id of flagged) {
-		const member = members[id];
-		if (member) members[id] = {
-			...member,
-			deprecated: true
-		};
-	}
-	return members;
-}
-/**
-* Variant superset when `config.variants` is omitted: the harvested
-* union of members' `.metadata.variants`, first-seen order.
-*/
-function deriveVariantUnion(memberMetadata) {
-	const union = [];
-	for (const metadata of Object.values(memberMetadata)) for (const variant of metadata.variants ?? []) if (!union.includes(variant)) union.push(variant);
-	return union;
-}
-/** Internal slug slot the late-bound `ref` getter reads. @internal */
-const ASSET_GROUP_SLUG_KEY = "__slug";
-/**
-* Safe slug read for error messages — never throws, unlike the `ref`
-* getter. Returns `undefined` for an unregistered group. @internal
-*/
-function readAssetGroupSlug(value) {
-	if (typeof value !== "object" || value === null) return void 0;
-	const slug = value[ASSET_GROUP_SLUG_KEY];
-	return typeof slug === "string" ? slug : void 0;
-}
-function defineHidden(target, key, value) {
-	Object.defineProperty(target, key, {
-		enumerable: false,
-		configurable: true,
-		writable: true,
-		value
-	});
-}
-/**
-* Stamp the invariant `__kind: 'assetGroup'` ref tag. Deliberately
-* deferred to the end of `.config()` so an unconfigured builder never
-* passes `isAssetGroupRef()` — the guard's truth implies a complete,
-* registerable group.
-*/
-function stampRefTag(target) {
-	Object.defineProperty(target, "__kind", {
-		enumerable: false,
-		configurable: true,
-		writable: false,
-		value: "assetGroup"
-	});
-}
-/**
-* Attach icon metadata to a single one-off icon and hand it back
-* unchanged. `isSvgIcon: true` is implied —
-* the point of the call is to mark the component as an icon so the
-* group harvest picks it up. Slots still point at the *group*, never
-* at this.
-*/
-function defineAssetIcon(component, metadata) {
-	Object.defineProperty(component, "metadata", {
-		enumerable: true,
-		configurable: true,
-		writable: true,
-		value: {
-			isSvgIcon: true,
-			...metadata
-		}
-	});
-	return component;
-}
-function defineAssetGroup(members) {
-	const out = {};
-	attachSourcePath(out, captureCallerPath());
-	Object.defineProperty(out, ASSET_GROUP_SLUG_KEY, {
-		enumerable: false,
-		configurable: true,
-		writable: true,
-		value: void 0
-	});
-	Object.defineProperty(out, "ref", {
-		enumerable: false,
-		configurable: true,
-		get() {
-			const slug = readAssetGroupSlug(out);
-			if (slug === void 0) throw new Error("AssetGroup.ref read before registration — the slug is late-bound from the `registerAssetGroups({ <slug>: group })` record key. Register the group first.");
-			return slug;
-		}
-	});
-	Object.defineProperty(out, "config", {
-		enumerable: false,
-		configurable: true,
-		writable: true,
-		value(config) {
-			if (out.assetKind !== void 0) throw new Error("defineAssetGroup: .config({...}) may only be called once per group.");
-			if (config.label !== void 0) out.label = config.label;
-			if (config.version !== void 0) out.version = config.version;
-			if (config.description !== void 0) out.description = config.description;
-			if (config.type === "font") {
-				const fontMembers = foldInDeprecated(guardFontMembers(members), config.deprecated);
-				out.assetKind = "font";
-				defineHidden(out, "members", fontMembers);
-				stampRefTag(out);
-				return out;
-			}
-			let resolvedSizes = config.sizes;
-			let resolvedVariants = config.variants;
-			if (config.props !== void 0) {
-				if (config.sizes !== void 0 || config.variants !== void 0) throw new Error("defineAssetGroup: `props` cannot be combined with the flat `sizes`/`variants` fields — use one or the other.");
-				const mapEntries = [];
-				const arrayEntries = [];
-				for (const [key, value] of Object.entries(config.props)) {
-					if (value === void 0) continue;
-					if (Array.isArray(value)) arrayEntries.push([key, value]);
-					else if (typeof value === "object" && value !== null) mapEntries.push([key, value]);
-					else throw new Error(`defineAssetGroup: \`props.${key}\` must be a named→px map (size axis) or an array (variant axis).`);
-				}
-				if (mapEntries.length !== 1) throw new Error("defineAssetGroup: `props` requires exactly one named→px map entry (the size axis).");
-				if (arrayEntries.length > 1) throw new Error("defineAssetGroup: `props` supports at most one array entry (the variant axis) — the serialized format holds a single variant axis.");
-				const [, sizeMap] = mapEntries[0];
-				resolvedSizes = sizeMap;
-				if (arrayEntries.length === 1) {
-					const [, variantValues] = arrayEntries[0];
-					resolvedVariants = variantValues;
-				}
-			}
-			if (resolvedSizes === void 0 || Object.keys(resolvedSizes).length === 0) throw new Error("defineAssetGroup: icon groups require a non-empty `sizes` map (named size → px) — declare it via `props: { size: {…} }` or the flat `sizes` field. The picker derives its size options from the keys.");
-			const { members: harvested, memberMetadata: harvestedMetadata } = harvestIconMembers(members, config.include);
-			const memberMetadata = applyMetadataOverlay(harvestedMetadata, config.memberMetadata, new Set(Object.keys(members)));
-			out.assetKind = "icon";
-			defineHidden(out, "members", harvested);
-			defineHidden(out, "memberMetadata", memberMetadata);
-			out.sizes = { ...resolvedSizes };
-			out.variants = resolvedVariants ? [...resolvedVariants] : deriveVariantUnion(memberMetadata);
-			const componentName = isComponentRef(config.component) ? config.component.ref : config.component;
-			if (componentName !== void 0) out.component = componentName;
-			stampRefTag(out);
-			return out;
-		}
-	});
-	return out;
-}
-//#endregion
-export { ASSET_GROUP_SLUG_KEY, defineAssetGroup, defineAssetIcon, readAssetGroupSlug };

package/dist/defineProvider.d.ts

@@ -1,29 +0,0 @@
-import { ProviderComponent, ProviderRenderFn } from "./factories.js";
-
-//#region src/defineProvider.d.ts
-/**
- * Pair a React context with a Provider component + matching hook in
- * one declaration. The render-fn receives the props, returns
- * `{ context, render }` — `context` is what the hook returns; `render`
- * is the JSX (typically `<>{children}<Portal /></>` and similar).
- *
- *     export const [ToastProvider, useToast] = defineProvider<ToastCtx>(
- *       ({ children }) => {
- *         const [toasts, setToasts] = useState<ToastItem[]>([]);
- *         return {
- *           context: { addToast, dismissToast, updateToast },
- *           render: <>{children}<Portal /></>,
- *         };
- *       },
- *     );
- *
- *     uds.registerProviders({ ToastProvider });
- *
- * Lives in its own module so the React (`createContext`) imports don't
- * land in the static graph of every consumer importing `@yahoo/uds-create-config`
- * — Turbopack flags `createContext` reaching a server-component module
- * as an error.
- */
-declare function defineProvider<TContext, TProps = Record<never, never>>(renderFn: ProviderRenderFn<TContext, TProps>): [ProviderComponent<TProps>, () => TContext];
-//#endregion
-export { defineProvider };

package/dist/defineProvider.js

@@ -1,60 +0,0 @@
-"use client";
-import { attachSourcePath, captureCallerPath } from "./captureCallerPath.js";
-import { createContext, createElement, useContext } from "react";
-//#region src/defineProvider.ts
-/**
-* Pair a React context with a Provider component + matching hook in
-* one declaration. The render-fn receives the props, returns
-* `{ context, render }` — `context` is what the hook returns; `render`
-* is the JSX (typically `<>{children}<Portal /></>` and similar).
-*
-*     export const [ToastProvider, useToast] = defineProvider<ToastCtx>(
-*       ({ children }) => {
-*         const [toasts, setToasts] = useState<ToastItem[]>([]);
-*         return {
-*           context: { addToast, dismissToast, updateToast },
-*           render: <>{children}<Portal /></>,
-*         };
-*       },
-*     );
-*
-*     uds.registerProviders({ ToastProvider });
-*
-* Lives in its own module so the React (`createContext`) imports don't
-* land in the static graph of every consumer importing `@yahoo/uds-create-config`
-* — Turbopack flags `createContext` reaching a server-component module
-* as an error.
-*/
-function defineProvider(renderFn) {
-	const Context = createContext(null);
-	const marker = {};
-	function Provider(props) {
-		const result = renderFn(props);
-		return createElement(Context.Provider, { value: result.context }, result.render);
-	}
-	Provider.displayName = "Provider";
-	Object.defineProperty(Provider, "__udsProvider", {
-		enumerable: false,
-		configurable: true,
-		writable: false,
-		value: marker
-	});
-	function useProviderContext() {
-		let ctx;
-		try {
-			ctx = useContext(Context);
-		} catch {
-			return {};
-		}
-		if (ctx === null) {
-			const name = marker.name ?? "Provider";
-			const hookName = name.replace(/Provider$/, "");
-			throw new Error(`use${hookName} must be used within ${name}`);
-		}
-		return ctx;
-	}
-	attachSourcePath(Provider, captureCallerPath());
-	return [Provider, useProviderContext];
-}
-//#endregion
-export { defineProvider };

package/dist/element-marker.d.ts

@@ -1,63 +0,0 @@
-//#region src/element-marker.d.ts
-declare const ELEMENT_MARKER_KIND = "element";
-/** Serializable stand-in for a React element authored as a preview prop value. */
-interface ElementMarker {
-  readonly __kind: typeof ELEMENT_MARKER_KIND;
-  /**
-   * Registry-resolvable type — `foreign:<Name>` for a third-party leaf,
-   * a registered UDS component's name, or an intrinsic tag (`'svg'`).
-   */
-  readonly type: string;
-  /** Author-set element key (preserved so revived list children stay keyed). */
-  readonly key?: string;
-  /** Serialized props; a nested element value is itself an `ElementMarker`. */
-  readonly props?: Record<string, unknown>;
-}
-declare function isElementMarker(value: unknown): value is ElementMarker;
-/**
- * A live React element or its `$$typeof`-less husk. `Config.toJSON` runs on the
- * in-memory config, where preview elements are still live (carry `$$typeof`);
- * the husk shape (`_owner`/`_store`, no live `type`) only appears after a
- * structuredClone/JSON round-trip and is matched here defensively.
- */
-declare function isElementLikeValue(value: unknown): boolean;
-/**
- * Deeply convert every React element value to an {@link ElementMarker},
- * preserving the surrounding plain data (axis markers, primitive props, nested
- * arrays/objects). A value that can't be named drops out (`undefined`), so an
- * anonymous wrapper or a clone-stripped husk is removed rather than serialized
- * into something unrenderable. Already-serialized markers carry none of the
- * element internals {@link isElementLikeValue} matches, so they pass through.
- */
-declare function serializeElementsDeep(value: unknown): unknown;
-/**
- * Treat a matched object as an opaque leaf the deep walk stops at, rather than
- * recursing into it. The walks run at render time, where a prop may already
- * hold a live React element whose `_owner` fiber chain is circular — descending
- * into one never terminates, and it can't contain an un-revived marker anyway.
- * Defaults to {@link isElementLikeValue}.
- */
-type OpaqueLeafPredicate = (value: object) => boolean;
-/**
- * Does `value` hold an {@link ElementMarker} anywhere in its plain-data subtree?
- * Lets a caller skip the revive walk entirely (and keep prop references stable)
- * when there's nothing to revive.
- */
-declare function hasElementMarkerDeep(value: unknown, isOpaqueLeaf?: OpaqueLeafPredicate): boolean;
-/**
- * Inverse of {@link serializeElementsDeep}: deep-walk `value` and turn each
- * {@link ElementMarker} into a renderable node via `renderMarker`, preserving
- * the surrounding plain data (arrays, objects). A marker's OWN props are left
- * for `renderMarker` to handle — they are not pre-revived here, so a marker
- * nested inside another marker's props stays inert until its enclosing marker
- * renders. This mirrors how `$slot` resolution defers and avoids handing a live
- * element (circular `_owner`) back into a renderer that deep-walks props.
- *
- * `renderMarker` is the framework seam — studio renders each marker through its
- * preview `UdsRenderer`; the playground does the same with its bundled renderer.
- * Guard with {@link hasElementMarkerDeep} to preserve referential stability for
- * marker-free values (this walk always rebuilds the containers it descends).
- */
-declare function reviveElementMarkersDeep(value: unknown, renderMarker: (marker: ElementMarker) => unknown, isOpaqueLeaf?: OpaqueLeafPredicate): unknown;
-//#endregion
-export { ELEMENT_MARKER_KIND, ElementMarker, OpaqueLeafPredicate, hasElementMarkerDeep, isElementLikeValue, isElementMarker, reviveElementMarkersDeep, serializeElementsDeep };