@yahoo/uds-create-config 2.34.0 → 2.36.0

package/dist/linkedNodePrefixes.js

@@ -0,0 +1,99 @@
+import { slugifyLinkedName } from "./registry-aliases.js";
+//#region src/linkedNodePrefixes.ts
+/**
+* Node-scoped CSS-prefix assignment for materialized linked systems.
+*
+* Every linked node (`{systemId}@{version}`) regenerates its CSS at consumer
+* build time from its sealed `config.json`, with its `prefix` overridden to a
+* composed, collision-free identity: `<consumerPrefix>-linked-<slug>`. One
+* prefix per NODE (not per link path) — the module graph resolves each node's
+* files once, so its lowered class names can only carry one prefix; sharing a
+* node between parents shares byte-identical sealed content, so sharing the
+* prefix is correct.
+*
+* The assignment must be identical everywhere it's consumed (pull-time shim
+* generation, `uds build` CSS regeneration, the bundler loaders), so every
+* consumer derives it from the same inputs with the same pure functions:
+* node identities from the registry tree, display names from the declaring
+* configs' `registerLinkedSystems` entries ({@link resolveDeclaredNames}),
+* and the consumer's own prefix. Nothing is persisted — the registry tree is
+* the source of truth.
+*/
+/** CSS identifiers can't start with a digit (or a hyphen-digit pair) —
+*  prepend a letter sentinel when a candidate would. */
+function ensureCssIdentStart(candidate) {
+	return /^[a-zA-Z_]/.test(candidate) ? candidate : `x${candidate}`;
+}
+/** `1.5.0` → `v1-5-0` — a CSS-safe version fragment. */
+function versionFragment(version) {
+	return `v${version.replace(/[^a-zA-Z0-9]+/g, "-")}`;
+}
+function nodeKey(node) {
+	return `${node.systemId}@${node.version}`;
+}
+/**
+* Assign each node in a linked closure its slug + composed CSS prefix,
+* keyed by `{systemId}@{version}`.
+*
+* Deterministic and input-order independent: nodes are processed sorted by
+* `(systemId, version)`. Within a slug-collision group the first sorted node
+* keeps the bare slug; a different system appends `-x<systemId[0..8]>`; the
+* same system at another version appends `-v<version>` — so every node in
+* the closure gets a unique, stable prefix.
+*
+* `consumerPrefix` is the consuming system's own `Config.prefix`. An empty
+* prefix is disallowed as a base (a bare `linked-…` could collide with the
+* consumer's unprefixed classes) — the node's own uuid fragment substitutes.
+*/
+function assignLinkedNodePrefixes(nodes, consumerPrefix) {
+	const sorted = [...nodes].sort((a, b) => a.systemId.localeCompare(b.systemId) || a.version.localeCompare(b.version));
+	const byslug = /* @__PURE__ */ new Map();
+	for (const node of sorted) {
+		const slug = slugifyLinkedName(node.name);
+		const group = byslug.get(slug);
+		if (group) group.push(node);
+		else byslug.set(slug, [node]);
+	}
+	const out = /* @__PURE__ */ new Map();
+	const usedSlugs = /* @__PURE__ */ new Set();
+	for (const [slug, group] of byslug) {
+		const systemsInOrder = [];
+		for (const node of group) if (!systemsInOrder.includes(node.systemId)) systemsInOrder.push(node.systemId);
+		for (const node of group) {
+			const systemRank = systemsInOrder.indexOf(node.systemId);
+			const versionsOfSystem = group.filter((n) => n.systemId === node.systemId);
+			let finalSlug = slug;
+			if (systemRank > 0) finalSlug += `-x${node.systemId.slice(0, 8)}`;
+			if (versionsOfSystem.length > 1 && versionsOfSystem.indexOf(node) > 0) finalSlug += `-${versionFragment(node.version)}`;
+			const collisionBase = finalSlug;
+			let collisionIndex = 2;
+			while (usedSlugs.has(finalSlug)) {
+				finalSlug = `${collisionBase}-${collisionIndex}`;
+				collisionIndex++;
+			}
+			usedSlugs.add(finalSlug);
+			const base = ensureCssIdentStart(consumerPrefix === "" ? `x${node.systemId.slice(0, 8)}` : consumerPrefix);
+			out.set(nodeKey(node), {
+				slug: finalSlug,
+				cssPrefix: `${base}-linked-${finalSlug}`
+			});
+		}
+	}
+	return out;
+}
+/**
+* Resolve each node's display name from the closure's declarations. A node
+* can be declared by several parents under different name snapshots; the
+* winner is the declaration with the lowest `declarerKey` in sort order (the
+* consumer's own declarations sort first as `''`), so every tool that walks
+* the same closure derives the same names — and therefore the same slugs and
+* CSS prefixes — without any persisted mapping.
+*/
+function resolveDeclaredNames(declarations) {
+	const sorted = [...declarations].sort((a, b) => a.key.localeCompare(b.key) || a.declarerKey.localeCompare(b.declarerKey));
+	const names = /* @__PURE__ */ new Map();
+	for (const decl of sorted) if (!names.has(decl.key)) names.set(decl.key, decl.name);
+	return names;
+}
+//#endregion
+export { assignLinkedNodePrefixes, resolveDeclaredNames };

package/dist/refs.d.ts

@@ -85,6 +85,18 @@ type TagName = string;
 interface TokenRef<TName extends string = string> {
   readonly __kind: 'token';
   readonly ref: TName;
+  /**
+   * Namespace scope for refs authored in extension payloads. Absent on
+   * source-authored refs (they resolve in their own system's namespace).
+   * `'consumer'` is stamped by the extension merge on plain `token()` refs
+   * — a consumer-authored ref always means the consumer's own tokens.
+   */
+  readonly scope?: 'consumer';
+  /** Pinned-system scope from a registry barrel's `token()` utility. */
+  readonly system?: {
+    readonly id: string;
+    readonly version: string;
+  };
 }
 interface TokenGroupRef<TName extends string = string> {
   readonly __kind: 'tokenGroup';
@@ -153,6 +165,13 @@ type AnyRef = TokenRef | TokenGroupRef | CompositeRef | ModeRef | StylePropRef |
 /** Doc-alignment alias kept for ergonomic import. */
 type TokenQualifiedName = TokenName;
 declare function token<TName extends TokenName>(ref: TName): TokenRef<TName>;
+/**
+ * Curried factory behind a registry barrel's `token()` utility —
+ * `yahooOs.token('color/red-1')` names THAT system's token, letting a
+ * consumer mix references across pinned systems unambiguously. The plain
+ * `token()` import always means the consumer's own namespace.
+ */
+declare function systemToken(systemId: string, version: string): <TName extends TokenName>(ref: TName) => TokenRef<TName>;
 declare function tokenGroup<TName extends TokenGroupName>(ref: TName): TokenGroupRef<TName>;
 /**
  * `composite(ref)` returns a bare `CompositeRef` plus an `.on(layer)`
@@ -182,4 +201,4 @@ declare function isComponentRef(value: unknown): value is ComponentRef;
 declare function isAssetGroupRef(value: unknown): value is AssetGroupRef;
 declare function isAssetRef(value: unknown): value is AssetRef;
 //#endregion
-export { AnyRef, AssetGroupName, AssetGroupRef, AssetName, AssetRef, ComponentName, ComponentRef, CompositeName, CompositeRef, CompositeRefBuilder, ModeName, ModeRef, MotionName, RegisteredAssetGroups, RegisteredComponents, RegisteredCompositeStyles, RegisteredModes, RegisteredModifiers, RegisteredMotion, RegisteredStyleProps, RegisteredTokenGroups, StylePropName, StylePropRef, TagName, TagRef, TokenGroupName, TokenGroupRef, TokenName, TokenQualifiedName, TokenRawNameRegistry, TokenRef, asset, assetGroup, component, composite, isAssetGroupRef, isAssetRef, isComponentRef, isCompositeRef, isModeRef, isStylePropRef, isTagRef, isTokenGroupRef, isTokenRef, mode, styleProp, tag, token, tokenGroup };
+export { AnyRef, AssetGroupName, AssetGroupRef, AssetName, AssetRef, ComponentName, ComponentRef, CompositeName, CompositeRef, CompositeRefBuilder, ModeName, ModeRef, MotionName, RegisteredAssetGroups, RegisteredComponents, RegisteredCompositeStyles, RegisteredModes, RegisteredModifiers, RegisteredMotion, RegisteredStyleProps, RegisteredTokenGroups, StylePropName, StylePropRef, TagName, TagRef, TokenGroupName, TokenGroupRef, TokenName, TokenQualifiedName, TokenRawNameRegistry, TokenRef, asset, assetGroup, component, composite, isAssetGroupRef, isAssetRef, isComponentRef, isCompositeRef, isModeRef, isStylePropRef, isTagRef, isTokenGroupRef, isTokenRef, mode, styleProp, systemToken, tag, token, tokenGroup };

package/dist/refs.js

@@ -5,6 +5,22 @@ function token(ref) {
 		ref
 	};
 }
+/**
+* Curried factory behind a registry barrel's `token()` utility —
+* `yahooOs.token('color/red-1')` names THAT system's token, letting a
+* consumer mix references across pinned systems unambiguously. The plain
+* `token()` import always means the consumer's own namespace.
+*/
+function systemToken(systemId, version) {
+	return (ref) => ({
+		__kind: "token",
+		ref,
+		system: {
+			id: systemId,
+			version
+		}
+	});
+}
 function tokenGroup(ref) {
 	return {
 		__kind: "tokenGroup",
@@ -110,4 +126,4 @@ function isAssetRef(value) {
 	return isRefOf(value, "asset");
 }
 //#endregion
-export { asset, assetGroup, component, composite, isAssetGroupRef, isAssetRef, isComponentRef, isCompositeRef, isModeRef, isStylePropRef, isTagRef, isTokenGroupRef, isTokenRef, mode, styleProp, tag, token, tokenGroup };
+export { asset, assetGroup, component, composite, isAssetGroupRef, isAssetRef, isComponentRef, isCompositeRef, isModeRef, isStylePropRef, isTagRef, isTokenGroupRef, isTokenRef, mode, styleProp, systemToken, tag, token, tokenGroup };