@yahoo/uds-create-config 2.24.0 → 2.25.0

package/dist/CompositeStyle.d.ts

@@ -1,4 +1,4 @@
-import { CompositeStyleDefinition, CompositeStyleObject } from "./types.js";
+import { CompositeStyleDefinition, CompositeStyleObject, SystemLink } from "./types.js";
 import { CssClassName, CssVar } from "./brands.js";
 
 //#region src/CompositeStyle.d.ts
@@ -8,6 +8,9 @@ declare class CompositeStyle {
   readonly label: string;
   readonly description?: string;
   readonly styles: ReadonlyMap<string, CompositeStyleObject>;
+  /** Provenance when this composite is linked from another system; `undefined`
+   *  for local ones. Round-trips through `toJSON` so a stored config keeps it. */
+  readonly link?: SystemLink;
   constructor(args: {
     name: string;
     definition: CompositeStyleDefinition;

package/dist/CompositeStyle.js

@@ -5,12 +5,16 @@ var CompositeStyle = class {
 	label;
 	description;
 	styles;
+	/** Provenance when this composite is linked from another system; `undefined`
+	*  for local ones. Round-trips through `toJSON` so a stored config keeps it. */
+	link;
 	#prefixGetter;
 	#derived;
 	constructor(args) {
 		this.name = args.name;
 		this.label = args.definition.label;
 		this.description = args.definition.description;
+		this.link = args.definition.link;
 		this.#prefixGetter = args.prefixGetter ?? (() => "uds");
 		const styles = /* @__PURE__ */ new Map();
 		for (const [variant, bag] of Object.entries(args.definition.styles)) styles.set(variant, bag);
@@ -43,7 +47,10 @@ var CompositeStyle = class {
 		return {
 			name: this.name,
 			label: this.label,
-			...compact({ description: this.description }),
+			...compact({
+				description: this.description,
+				link: this.link
+			}),
 			styles
 		};
 	}

package/dist/native/NativeConfig.d.ts

@@ -1,6 +1,7 @@
 import { LinkedSystemPin, LinkedSystemsInput } from "../types.js";
 import { ConfigValidationError } from "../config-diagnostics.js";
-import { NativeAssetGroupDefinition, NativeDefaultModes, NativeFontAssetGroupDefinition, NativeModeDefinition, NativeStyleEngine, NativeTokenGroupDefinition, SerializedNativeConfig } from "./types.js";
+import { NativeComponentDefinition, NativeComponentGroupDefinition, NativeComponentPropMarker, NativeComponentPropsFromMarkers, NativeComponentStyles, NativeLayerDefinition, NativeLayerKind, SerializedNativeComponentGroup } from "./components.js";
+import { NativeAssetGroupDefinition, NativeBuildOptions, NativeDefaultModes, NativeFontAssetGroupDefinition, NativeModeDefinition, NativeStyleEngine, NativeTokenGroupDefinition, SerializedNativeConfig } from "./types.js";
 import { NativeConfigDiagnostic } from "./validation.js";
 
 //#region src/native/NativeConfig.d.ts
@@ -13,28 +14,36 @@ declare class NativeConfig {
   readonly platform: "native";
   namespace?: string;
   styleEngine?: NativeStyleEngine;
+  buildOptions?: NativeBuildOptions;
   defaultModes?: NativeDefaultModes;
   readonly modes: Map<string, NativeModeDefinition>;
   readonly tokenGroups: Map<string, NativeTokenGroupDefinition>;
   readonly assetGroups: Map<string, NativeFontAssetGroupDefinition>;
+  readonly components: Map<string, NativeComponentDefinition<string, Record<string, NativeLayerDefinition<NativeLayerKind, string | undefined>>, Record<string, NativeComponentPropMarker>, Partial<NativeComponentPropsFromMarkers<Record<string, NativeComponentPropMarker>>>, NativeComponentStyles<Record<string, NativeLayerDefinition<NativeLayerKind, string | undefined>>>>>;
+  readonly componentGroups: Map<string, SerializedNativeComponentGroup>;
   /** Source systems pinned via {@link registerLinkedSystems} — same
    *  contract as the web `Config`: one exact version per system UUID. */
   readonly linkedSystems: Map<string, LinkedSystemPin>;
+  /** Build-only source pointers. They are intentionally absent from JSON. */
+  readonly componentSources: Map<string, {
+    definitionPath?: string;
+    renderPath: string;
+  }>;
   configure(options: {
     namespace?: string;
     styleEngine?: NativeStyleEngine;
+    buildOptions?: NativeBuildOptions;
     defaultModes?: NativeDefaultModes;
   }): this;
   registerModes(modes: Record<string, NativeModeDefinition>): this;
   /**
-   * Pin source systems this config links values from — the platform of the
-   * SOURCE system is not constrained: a native config may pin a web system
-   * and register its token groups (token envelopes are shared). Pins must
-   * appear before the `register*` calls that use them.
+   * Pin source systems this config links values from. Pins must appear before
+   * the `register*` calls that use them.
    */
   registerLinkedSystems(input: LinkedSystemsInput): this;
   registerTokenGroups(groups: Record<string, NativeTokenGroupDefinition>): this;
   registerAssetGroups(groups: Record<string, NativeAssetGroupDefinition>): this;
+  registerComponentGroups(groups: Record<string, NativeComponentGroupDefinition>): this;
   validate(): NativeConfigDiagnostic[];
   toJSON(meta?: {
     builtAt?: string;

package/dist/native/NativeConfig.js

@@ -1,3 +1,4 @@
+import { readSourcePath } from "../captureCallerPath.js";
 import { assertLinkedTokenPinned, validateLinkedSystemPin } from "../linked-system-pins.js";
 import { ConfigValidationError } from "../config-diagnostics.js";
 import { validateSerializedNativeConfig } from "./validation.js";
@@ -13,13 +14,18 @@ var NativeConfig = class NativeConfig {
 	platform = "native";
 	namespace;
 	styleEngine;
+	buildOptions;
 	defaultModes;
 	modes = /* @__PURE__ */ new Map();
 	tokenGroups = /* @__PURE__ */ new Map();
 	assetGroups = /* @__PURE__ */ new Map();
+	components = /* @__PURE__ */ new Map();
+	componentGroups = /* @__PURE__ */ new Map();
 	/** Source systems pinned via {@link registerLinkedSystems} — same
 	*  contract as the web `Config`: one exact version per system UUID. */
 	linkedSystems = /* @__PURE__ */ new Map();
+	/** Build-only source pointers. They are intentionally absent from JSON. */
+	componentSources = /* @__PURE__ */ new Map();
 	configure(options) {
 		if (options.namespace !== void 0) {
 			const diagnostics = validateSerializedNativeConfig({
@@ -39,6 +45,7 @@ var NativeConfig = class NativeConfig {
 			if (diagnostics.length > 0) throw new NativeConfigValidationError(diagnostics);
 			this.styleEngine = options.styleEngine;
 		}
+		if (options.buildOptions !== void 0) this.buildOptions = { ...options.buildOptions };
 		if (options.defaultModes !== void 0) this.defaultModes = { ...options.defaultModes };
 		return this;
 	}
@@ -47,10 +54,8 @@ var NativeConfig = class NativeConfig {
 		return this;
 	}
 	/**
-	* Pin source systems this config links values from — the platform of the
-	* SOURCE system is not constrained: a native config may pin a web system
-	* and register its token groups (token envelopes are shared). Pins must
-	* appear before the `register*` calls that use them.
+	* Pin source systems this config links values from. Pins must appear before
+	* the `register*` calls that use them.
 	*/
 	registerLinkedSystems(input) {
 		for (const [systemId, pin] of Object.entries(input)) {
@@ -73,6 +78,29 @@ var NativeConfig = class NativeConfig {
 		for (const [name, definition] of Object.entries(groups)) this.assetGroups.set(name, definition);
 		return this;
 	}
+	registerComponentGroups(groups) {
+		for (const [groupName, group] of Object.entries(groups)) {
+			const componentNames = [];
+			for (const [componentName, component] of Object.entries(group.components)) {
+				const existing = this.components.get(componentName);
+				if (existing !== void 0 && existing !== component) throw new Error(`Native component "${componentName}" is registered more than once.`);
+				const duplicateId = [...this.components].find(([name, value]) => name !== componentName && value.id === component.id);
+				if (duplicateId !== void 0) throw new Error(`Native component id "${component.id}" is already used by "${duplicateId[0]}".`);
+				this.components.set(componentName, component);
+				this.componentSources.set(componentName, {
+					definitionPath: readSourcePath(component),
+					renderPath: component.__renderPath
+				});
+				componentNames.push(componentName);
+			}
+			this.componentGroups.set(groupName, {
+				components: componentNames,
+				...group.label !== void 0 ? { label: group.label } : {},
+				...group.description !== void 0 ? { description: group.description } : {}
+			});
+		}
+		return this;
+	}
 	validate() {
 		return validateSerializedNativeConfig(this.#serialize());
 	}
@@ -89,10 +117,13 @@ var NativeConfig = class NativeConfig {
 		const config = new NativeConfig();
 		config.namespace = json.namespace;
 		config.styleEngine = json.styleEngine;
+		config.buildOptions = json.buildOptions ? { ...json.buildOptions } : void 0;
 		config.defaultModes = json.defaultModes ? { ...json.defaultModes } : void 0;
 		for (const [name, mode] of Object.entries(json.modes ?? {})) config.modes.set(name, mode);
 		for (const [name, group] of Object.entries(json.tokenGroups ?? {})) config.tokenGroups.set(name, group);
 		for (const [name, group] of Object.entries(json.assetGroups ?? {})) config.assetGroups.set(name, group);
+		for (const [name, component] of Object.entries(json.components ?? {})) config.components.set(name, component);
+		for (const [name, group] of Object.entries(json.componentGroups ?? {})) config.componentGroups.set(name, group);
 		for (const [systemId, pin] of Object.entries(json.linkedSystems ?? {})) config.linkedSystems.set(systemId, { ...pin });
 		return config;
 	}
@@ -104,10 +135,13 @@ var NativeConfig = class NativeConfig {
 		if (meta?.builtAt !== void 0) out.builtAt = meta.builtAt;
 		if (this.namespace !== void 0) out.namespace = this.namespace;
 		if (this.styleEngine !== void 0) out.styleEngine = this.styleEngine;
+		if (this.buildOptions !== void 0) out.buildOptions = { ...this.buildOptions };
 		if (this.defaultModes !== void 0) out.defaultModes = { ...this.defaultModes };
 		if (this.modes.size > 0) out.modes = Object.fromEntries(this.modes);
 		if (this.tokenGroups.size > 0) out.tokenGroups = Object.fromEntries(this.tokenGroups);
 		if (this.assetGroups.size > 0) out.assetGroups = Object.fromEntries(this.assetGroups);
+		if (this.components.size > 0) out.components = Object.fromEntries(this.components);
+		if (this.componentGroups.size > 0) out.componentGroups = Object.fromEntries(this.componentGroups);
 		if (this.linkedSystems.size > 0) out.linkedSystems = Object.fromEntries([...this.linkedSystems].map(([id, pin]) => [id, { ...pin }]));
 		return out;
 	}

package/dist/native/components.d.ts

@@ -0,0 +1,139 @@
+import { TokenRef } from "../refs.js";
+import { BooleanMarker, NumberMarker, RequiredBrand, SlotMarker, StringMarker, VariantMarkerArray } from "../markers.js";
+import { NativeTokenValue } from "./types.js";
+import { ReactNode } from "react";
+
+//#region src/native/components.d.ts
+type RequiredBuilder<T extends {
+  readonly __required?: boolean;
+}> = T & {
+  required(): T & RequiredBrand;
+};
+type NativeStringSlotMarker = Omit<SlotMarker, 'required'> & {
+  readonly __valueType: 'string';
+  required(): NativeStringSlotMarker & RequiredBrand;
+};
+type NativeComponentPropMarker = SlotMarker | BooleanMarker | StringMarker | NumberMarker | VariantMarkerArray;
+interface NativeComponentPropHelpers {
+  slot(): SlotMarker;
+  slot(options: {
+    type: 'string';
+  }): NativeStringSlotMarker;
+  boolean(): RequiredBuilder<BooleanMarker>;
+  string(): RequiredBuilder<StringMarker>;
+  number(): RequiredBuilder<NumberMarker>;
+  variant<const TValues extends readonly (string | number)[]>(values: TValues): RequiredBuilder<VariantMarkerArray<TValues>>;
+}
+type NativeSlotValue<TMarker extends SlotMarker> = TMarker['__valueType'] extends 'string' ? string : ReactNode;
+type NativePropValue<TMarker> = TMarker extends SlotMarker ? NativeSlotValue<TMarker> : TMarker extends BooleanMarker ? boolean : TMarker extends StringMarker ? string : TMarker extends NumberMarker ? number : TMarker extends VariantMarkerArray<infer TValues> ? TValues[number] : never;
+type RequiredNativePropKeys<TProps> = { [K in keyof TProps]: TProps[K] extends {
+  readonly __required: true;
+} ? K : never }[keyof TProps];
+type NativeComponentPropsFromMarkers<TProps> = { [K in RequiredNativePropKeys<TProps>]-?: NativePropValue<TProps[K]> } & { [K in Exclude<keyof TProps, RequiredNativePropKeys<TProps>>]?: NativePropValue<TProps[K]> };
+type ResolvedNativeComponentProps<TProps extends Record<string, NativeComponentPropMarker>, TDefaults> = { [K in keyof TProps as K extends keyof TDefaults ? K : TProps[K] extends {
+  readonly __required: true;
+} ? K : never]-?: NativePropValue<TProps[K]> } & { [K in keyof TProps as K extends keyof TDefaults ? never : TProps[K] extends {
+  readonly __required: true;
+} ? never : K]?: NativePropValue<TProps[K]> };
+type NativeLayerKind = 'view' | 'text' | 'image';
+interface NativeLayerDefinition<TKind extends NativeLayerKind = NativeLayerKind, TPublicStyle extends string | undefined = string | undefined> {
+  readonly kind: TKind;
+  readonly styleProp?: TPublicStyle;
+}
+interface NativeLayerBuilder<TKind extends NativeLayerKind> extends NativeLayerDefinition<TKind, undefined> {
+  publicStyle<const TName extends string = 'style'>(name?: TName): NativeLayerDefinition<TKind, TName>;
+}
+/** Define a React Native style target. */
+declare function nativeLayer<const TKind extends NativeLayerKind>(kind: TKind): NativeLayerBuilder<TKind>;
+type NativeStyleValue = NativeTokenValue | readonly NativeStyleValue[] | {
+  readonly [key: string]: NativeStyleValue;
+};
+type NativeLayerStyle = Readonly<Record<string, NativeStyleValue>>;
+type NativeLayerStyles = Readonly<Record<string, NativeLayerStyle>>;
+type NativeLayerNames<TLayers> = keyof TLayers & string;
+type LayerStylesFor<TLayers> = Partial<Record<NativeLayerNames<TLayers>, NativeLayerStyle>>;
+interface NativeComponentStyles<TLayers extends Record<string, NativeLayerDefinition> = Record<string, NativeLayerDefinition>> {
+  readonly base?: LayerStylesFor<TLayers>;
+  readonly variants?: Readonly<Record<string, Readonly<Record<string, LayerStylesFor<TLayers>>>>>;
+  readonly booleans?: Readonly<Record<string, Readonly<{
+    true?: LayerStylesFor<TLayers>;
+    false?: LayerStylesFor<TLayers>;
+  }>>>;
+  readonly runtimeStates?: Readonly<Record<string, LayerStylesFor<TLayers>>>;
+  /** Scalar design values exposed to render code through `values.*()`. */
+  readonly values?: Readonly<Record<string, NativeTokenValue>>;
+}
+interface NativeComponentStyleHelpers {
+  token(name: string): TokenRef;
+}
+/** Serializable design data for one first-class native component. */
+interface NativeComponentDefinition<TId extends string = string, TLayers extends Record<string, NativeLayerDefinition> = Record<string, NativeLayerDefinition>, TProps extends Record<string, NativeComponentPropMarker> = Record<string, NativeComponentPropMarker>, TDefaults extends Partial<NativeComponentPropsFromMarkers<TProps>> = Partial<NativeComponentPropsFromMarkers<TProps>>, TStyles extends NativeComponentStyles<TLayers> = NativeComponentStyles<TLayers>> {
+  readonly id: TId;
+  readonly layers: TLayers;
+  readonly props: TProps;
+  readonly defaultProps?: TDefaults;
+  readonly label?: string;
+  readonly description?: string;
+  readonly styles: TStyles;
+}
+type RegisteredNativeComponent<TId extends string = string, TLayers extends Record<string, NativeLayerDefinition> = Record<string, NativeLayerDefinition>, TProps extends Record<string, NativeComponentPropMarker> = Record<string, NativeComponentPropMarker>, TDefaults extends Partial<NativeComponentPropsFromMarkers<TProps>> = Partial<NativeComponentPropsFromMarkers<TProps>>, TStyles extends NativeComponentStyles<TLayers> = NativeComponentStyles<TLayers>> = NativeComponentDefinition<TId, TLayers, TProps, TDefaults, TStyles> & {
+  readonly __nativeComponent: true;
+  readonly __renderPath: string;
+};
+type RuntimeStateNames<TComponent> = TComponent extends NativeComponentDefinition<string, Record<string, NativeLayerDefinition>, Record<string, NativeComponentPropMarker>, Partial<NativeComponentPropsFromMarkers<Record<string, NativeComponentPropMarker>>>, infer TStyles> ? TStyles extends {
+  runtimeStates: infer TStates;
+} ? keyof TStates & string : string : string;
+type NamedValues<TComponent> = TComponent extends NativeComponentDefinition<string, Record<string, NativeLayerDefinition>, Record<string, NativeComponentPropMarker>, Partial<NativeComponentPropsFromMarkers<Record<string, NativeComponentPropMarker>>>, infer TStyles> ? TStyles extends {
+  values: infer TValues;
+} ? keyof TValues & string : never : never;
+type LayersOf<TComponent> = TComponent extends {
+  readonly layers: infer TLayers extends Record<string, NativeLayerDefinition>;
+} ? TLayers : never;
+type PropMarkersOf<TComponent> = TComponent extends {
+  readonly props: infer TProps extends Record<string, NativeComponentPropMarker>;
+} ? TProps : never;
+type DefaultsOf<TComponent> = TComponent extends {
+  readonly defaultProps?: infer TDefaults;
+} ? TDefaults : Record<never, never>;
+type NativeComponentProps<TComponent> = NativeComponentPropsFromMarkers<PropMarkersOf<TComponent>>;
+type NativeGeneratedRenderProps<TComponent, TStyleByLayer extends Record<NativeLayerNames<LayersOf<TComponent>>, unknown>> = ResolvedNativeComponentProps<PropMarkersOf<TComponent>, DefaultsOf<TComponent>> & {
+  styles: { [K in NativeLayerNames<LayersOf<TComponent>>]: (state?: Partial<Record<RuntimeStateNames<TComponent>, boolean>>) => TStyleByLayer[K] };
+  values: { [K in NamedValues<TComponent>]: () => string | number | boolean };
+};
+/** Props the copied native render receives from its generated wrapper. */
+type NativeRenderProps<TComponent, TStyleByLayer extends Record<NativeLayerNames<LayersOf<TComponent>>, unknown>, TRuntimeProps extends object = Record<never, never>> = TRuntimeProps extends unknown ? Omit<TRuntimeProps, keyof NativeComponentProps<TComponent>> & NativeGeneratedRenderProps<TComponent, TStyleByLayer> : never;
+interface NativeComponentStyledBuilder<TId extends string, TLayers extends Record<string, NativeLayerDefinition>, TProps extends Record<string, NativeComponentPropMarker>, TDefaults extends Partial<NativeComponentPropsFromMarkers<TProps>>, TStyles extends NativeComponentStyles<TLayers>> extends NativeComponentDefinition<TId, TLayers, TProps, TDefaults, TStyles> {
+  render(path: string): RegisteredNativeComponent<TId, TLayers, TProps, TDefaults, TStyles>;
+}
+interface NativeComponentBuilder<TId extends string, TLayers extends Record<string, NativeLayerDefinition>, TProps extends Record<string, NativeComponentPropMarker>, TDefaults extends Partial<NativeComponentPropsFromMarkers<TProps>>> {
+  styles<const TStyles extends NativeComponentStyles<TLayers>>(callback: (helpers: NativeComponentStyleHelpers) => TStyles): NativeComponentStyledBuilder<TId, TLayers, TProps, TDefaults, TStyles>;
+}
+/**
+ * Define a first-class React Native component. The render path remains a
+ * build-only source pointer and is never serialized into native config data.
+ */
+declare function defineNativeComponent<const TId extends string, const TLayers extends Record<string, NativeLayerDefinition>, const TProps extends Record<string, NativeComponentPropMarker>, const TDefaults extends Partial<NativeComponentPropsFromMarkers<TProps>> = Record<never, never>>(definition: {
+  id: TId;
+  layers: TLayers;
+  props: (helpers: NativeComponentPropHelpers) => TProps;
+  defaultProps?: TDefaults;
+  label?: string;
+  description?: string;
+}): NativeComponentBuilder<TId, TLayers, TProps, TDefaults>;
+interface NativeComponentGroupDefinition<TComponents extends Record<string, RegisteredNativeComponent> = Record<string, RegisteredNativeComponent>> {
+  readonly components: TComponents;
+  readonly label?: string;
+  readonly description?: string;
+}
+declare function defineNativeComponentGroup<const TComponents extends Record<string, RegisteredNativeComponent>>(definition: {
+  components: TComponents;
+  label?: string;
+  description?: string;
+}): NativeComponentGroupDefinition<TComponents>;
+interface SerializedNativeComponentGroup {
+  readonly components: readonly string[];
+  readonly label?: string;
+  readonly description?: string;
+}
+//#endregion
+export { NativeComponentBuilder, NativeComponentDefinition, NativeComponentGroupDefinition, NativeComponentPropMarker, NativeComponentProps, NativeComponentPropsFromMarkers, NativeComponentStyleHelpers, NativeComponentStyledBuilder, NativeComponentStyles, NativeLayerDefinition, NativeLayerKind, NativeLayerStyle, NativeLayerStyles, NativeRenderProps, NativeStyleValue, RegisteredNativeComponent, SerializedNativeComponentGroup, defineNativeComponent, defineNativeComponentGroup, nativeLayer };

package/dist/native/components.js

@@ -0,0 +1,66 @@
+import { attachSourcePath, captureCallerPath } from "../captureCallerPath.js";
+import { token } from "../refs.js";
+import { boolean, number, slot, string, variant } from "../factories.js";
+//#region src/native/components.ts
+const nativeComponentPropHelpers = {
+	slot(options) {
+		return options === void 0 ? slot() : slot(options);
+	},
+	boolean,
+	string,
+	number,
+	variant
+};
+/** Define a React Native style target. */
+function nativeLayer(kind) {
+	const layer = { kind };
+	Object.defineProperty(layer, "publicStyle", {
+		enumerable: false,
+		configurable: true,
+		value(name = "style") {
+			Object.defineProperty(layer, "styleProp", {
+				enumerable: true,
+				configurable: true,
+				value: name
+			});
+			return layer;
+		}
+	});
+	return layer;
+}
+/**
+* Define a first-class React Native component. The render path remains a
+* build-only source pointer and is never serialized into native config data.
+*/
+function defineNativeComponent(definition) {
+	const sourcePath = captureCallerPath();
+	const props = definition.props(nativeComponentPropHelpers);
+	return { styles(callback) {
+		const component = attachSourcePath({
+			id: definition.id,
+			layers: definition.layers,
+			props,
+			...definition.defaultProps !== void 0 ? { defaultProps: definition.defaultProps } : {},
+			...definition.label !== void 0 ? { label: definition.label } : {},
+			...definition.description !== void 0 ? { description: definition.description } : {},
+			styles: callback({ token })
+		}, sourcePath);
+		Object.defineProperty(component, "render", {
+			enumerable: false,
+			configurable: true,
+			value(renderPath) {
+				Object.defineProperties(component, {
+					__nativeComponent: { value: true },
+					__renderPath: { value: renderPath }
+				});
+				return component;
+			}
+		});
+		return component;
+	} };
+}
+function defineNativeComponentGroup(definition) {
+	return attachSourcePath(definition, captureCallerPath());
+}
+//#endregion
+export { defineNativeComponent, defineNativeComponentGroup, nativeLayer };

package/dist/native/index.d.ts

@@ -2,7 +2,8 @@ import { AssetRef, TokenRef, asset, token } from "../refs.js";
 import { ColorSpace, MixExpr, alpha, mix } from "../colorExpressions.js";
 import { SystemLink, TokenType } from "../types.js";
 import { DefinedTokenGroupValue } from "../factories.js";
-import { ModeDefinition, NativeAppearanceModeOption, NativeAssetGroupDefinition, NativeColorExpression, NativeDefaultModes, NativeFontAssetGroupDefinition, NativeFontAssetMember, NativeLiteral, NativeModeDefinition, NativeModeOptionDefinition, NativeSelectableValue, NativeStyleEngine, NativeTokenDefinition, NativeTokenGroupDefinition, NativeTokenValue, NativeViewportModeOption, OperatingSystemInput, OperatingSystemValue, SerializedNativeConfig } from "./types.js";
+import { NativeComponentBuilder, NativeComponentDefinition, NativeComponentGroupDefinition, NativeComponentProps, NativeComponentStyleHelpers, NativeComponentStyledBuilder, NativeComponentStyles, NativeLayerDefinition, NativeLayerKind, NativeLayerStyle, NativeLayerStyles, NativeRenderProps, NativeStyleValue, RegisteredNativeComponent, SerializedNativeComponentGroup, defineNativeComponent, defineNativeComponentGroup, nativeLayer } from "./components.js";
+import { ModeDefinition, NativeAppearanceModeOption, NativeAssetGroupDefinition, NativeBuildOptions, NativeColorExpression, NativeDefaultModes, NativeFontAssetGroupDefinition, NativeFontAssetMember, NativeLiteral, NativeModeDefinition, NativeModeOptionDefinition, NativeSelectableValue, NativeStyleEngine, NativeTokenDefinition, NativeTokenGroupDefinition, NativeTokenValue, NativeViewportModeOption, OperatingSystemInput, OperatingSystemValue, SerializedNativeConfig } from "./types.js";
 import { NativeAssetGroupBuilder, NativeFontAssetGroupConfig, defineAssetGroup } from "./assets.js";
 import { defineMode } from "./modes.js";
 import { NativeConfigDiagnostic, NativeConfigDiagnosticCode, validateSerializedNativeConfig } from "./validation.js";

package/dist/native/index.js

@@ -2,6 +2,7 @@ import "../refs.js";
 import "../colorExpressions.js";
 import { defineTokenGroupValue } from "../factories.js";
 import "./assets.js";
+import "./components.js";
 import "./modes.js";
 import "./values.js";
 import "./validation.js";

package/dist/native/types.d.ts

@@ -1,6 +1,7 @@
 import { AssetRef, TokenRef } from "../refs.js";
 import { MixExpr } from "../colorExpressions.js";
 import { LinkedSystemPin, TokenDefinitionFor, TokenGroupDefinitionFor, TokenModifierKey } from "../types.js";
+import { NativeComponentDefinition, SerializedNativeComponentGroup } from "./components.js";
 
 //#region src/native/types.d.ts
 type NativeLiteral = string | number | boolean;
@@ -51,6 +52,10 @@ type ModeDefinition = NativeModeDefinition;
 type NativeDefaultModes = Record<string, string>;
 /** Styling runtime selected for generated native component and adapter files. */
 type NativeStyleEngine = 'react-native' | 'unistyles';
+interface NativeBuildOptions {
+  /** Trusted root containing native component definitions and render source. */
+  componentsDir?: string;
+}
 interface NativeFontAssetMember {
   /** Family identifier React Native consumes after the app registers the font. */
   fontFamily: string;
@@ -68,12 +73,15 @@ interface SerializedNativeConfig {
   builtAt?: string;
   namespace?: string;
   styleEngine?: NativeStyleEngine;
+  buildOptions?: NativeBuildOptions;
   defaultModes?: NativeDefaultModes;
   modes?: Record<string, NativeModeDefinition>;
   tokenGroups?: Record<string, NativeTokenGroupDefinition>;
   assetGroups?: Record<string, NativeAssetGroupDefinition>;
+  components?: Record<string, NativeComponentDefinition>;
+  componentGroups?: Record<string, SerializedNativeComponentGroup>;
   /** Source-system pins, same contract as the web `SerializedConfig`. */
   linkedSystems?: Record<string, LinkedSystemPin>;
 }
 //#endregion
-export { ModeDefinition, NativeAppearanceModeOption, NativeAssetGroupDefinition, NativeColorExpression, NativeDefaultModes, NativeFontAssetGroupDefinition, NativeFontAssetMember, NativeLiteral, NativeModeDefinition, NativeModeOptionDefinition, NativeSelectableValue, NativeStyleEngine, NativeTokenDefinition, NativeTokenGroupDefinition, NativeTokenValue, NativeViewportModeOption, OperatingSystemInput, OperatingSystemValue, SerializedNativeConfig };
+export { ModeDefinition, NativeAppearanceModeOption, NativeAssetGroupDefinition, NativeBuildOptions, NativeColorExpression, NativeDefaultModes, NativeFontAssetGroupDefinition, NativeFontAssetMember, NativeLiteral, NativeModeDefinition, NativeModeOptionDefinition, NativeSelectableValue, NativeStyleEngine, NativeTokenDefinition, NativeTokenGroupDefinition, NativeTokenValue, NativeViewportModeOption, OperatingSystemInput, OperatingSystemValue, SerializedNativeConfig };