@yahoo/uds-create-config 2.14.0 → 2.15.0

package/dist/native/validation.js

@@ -0,0 +1,456 @@
+import { isAssetRef, isTokenRef } from "../refs.js";
+import { isMixExpr } from "../colorExpressions.js";
+import { isOperatingSystemValue } from "./values.js";
+//#region src/native/validation.ts
+const TOP_LEVEL_KEYS = new Set([
+	"schemaVersion",
+	"platform",
+	"builtAt",
+	"namespace",
+	"modes",
+	"tokenGroups",
+	"assetGroups"
+]);
+const GROUP_KEYS = new Set([
+	"tokens",
+	"label",
+	"description"
+]);
+const ASSET_GROUP_KEYS = new Set([
+	"assetKind",
+	"members",
+	"label",
+	"description"
+]);
+const ASSET_MEMBER_KEYS = new Set(["postscriptName"]);
+const MODE_OPTION_KEYS = new Set([
+	"modifier",
+	"label",
+	"description",
+	"css",
+	"media"
+]);
+const OS_KEYS = new Set([
+	"__kind",
+	"default",
+	"ios",
+	"android"
+]);
+const TOKEN_REF_KEYS = new Set(["__kind", "ref"]);
+const MIX_KEYS = new Set([
+	"__kind",
+	"from",
+	"to",
+	"amount",
+	"colorSpace"
+]);
+const COLOR_SPACES = new Set([
+	"srgb",
+	"srgb-linear",
+	"oklab",
+	"oklch",
+	"lab",
+	"lch",
+	"hsl",
+	"hwb"
+]);
+function validateSerializedNativeConfig(input, expectedSchemaVersion = 1) {
+	const diagnostics = [];
+	const configDefinition = { kind: "config" };
+	if (!isRecord(input)) {
+		push(diagnostics, "INVALID_SCHEMA", [], configDefinition, "Native config must be a plain object.");
+		return diagnostics;
+	}
+	reportUnknownKeys(input, TOP_LEVEL_KEYS, [], configDefinition, diagnostics);
+	if (input.schemaVersion !== expectedSchemaVersion) push(diagnostics, typeof input.schemaVersion === "number" ? "UNSUPPORTED_SCHEMA_VERSION" : "INVALID_SCHEMA", ["schemaVersion"], configDefinition, `Native config schema version must be ${expectedSchemaVersion}; received ${String(input.schemaVersion)}.`);
+	if (input.platform !== "native") push(diagnostics, "PLATFORM_MISMATCH", ["platform"], configDefinition, "Native config must declare platform: \"native\".");
+	if (input.builtAt !== void 0 && typeof input.builtAt !== "string") push(diagnostics, "INVALID_SCHEMA", ["builtAt"], configDefinition, "builtAt must be a string when present.");
+	validateNamespace(input.namespace, diagnostics);
+	validateModes(input.modes, diagnostics);
+	validateAssetGroups(input.assetGroups, diagnostics);
+	validateTokenGroups(input.tokenGroups, diagnostics);
+	validateReferences(input, diagnostics);
+	validateModifierOwnership(input, diagnostics);
+	return dedupe(diagnostics);
+}
+function validateNamespace(value, diagnostics) {
+	if (value === void 0) return;
+	if (typeof value !== "string" || value.length === 0 || value.includes(":") || /\s/.test(value)) push(diagnostics, "INVALID_NAMESPACE", ["namespace"], { kind: "config" }, "Native config namespace must be a non-empty string without whitespace or \":\".");
+}
+function validateModes(value, diagnostics) {
+	if (value === void 0) return;
+	if (!isRecord(value)) {
+		push(diagnostics, "INVALID_SCHEMA", ["modes"], { kind: "config" }, "modes must be a record.");
+		return;
+	}
+	for (const [modeName, options] of Object.entries(value)) {
+		const definition = {
+			kind: "mode",
+			name: modeName
+		};
+		const modePath = ["modes", modeName];
+		if (!isRecord(options)) {
+			push(diagnostics, "INVALID_SCHEMA", modePath, definition, `Mode "${modeName}" must be an option record.`);
+			continue;
+		}
+		for (const [optionName, option] of Object.entries(options)) {
+			const optionPath = [...modePath, optionName];
+			if (!isRecord(option)) {
+				push(diagnostics, "INVALID_SCHEMA", optionPath, definition, `Mode option "${modeName}/${optionName}" must be an object.`);
+				continue;
+			}
+			reportUnknownKeys(option, MODE_OPTION_KEYS, optionPath, definition, diagnostics);
+			for (const key of [
+				"modifier",
+				"label",
+				"description"
+			]) if (option[key] !== void 0 && typeof option[key] !== "string") push(diagnostics, "INVALID_SCHEMA", [...optionPath, key], definition, `${key} must be a string when present.`);
+			for (const key of ["css", "media"]) if (option[key] !== void 0) push(diagnostics, "UNSUPPORTED_NATIVE_FIELD", [...optionPath, key], definition, `Mode option field "${key}" is web-only and is not supported by NativeConfig.`);
+		}
+	}
+}
+function validateAssetGroups(value, diagnostics) {
+	if (value === void 0) return;
+	if (!isRecord(value)) {
+		push(diagnostics, "INVALID_SCHEMA", ["assetGroups"], { kind: "config" }, "assetGroups must be a record.");
+		return;
+	}
+	for (const [groupName, group] of Object.entries(value)) {
+		const definition = {
+			kind: "asset-group",
+			name: groupName
+		};
+		const groupPath = ["assetGroups", groupName];
+		if (!isRecord(group)) {
+			push(diagnostics, "INVALID_SCHEMA", groupPath, definition, `Asset group "${groupName}" must be an object.`);
+			continue;
+		}
+		reportUnknownKeys(group, ASSET_GROUP_KEYS, groupPath, definition, diagnostics);
+		if (group.assetKind !== "font") push(diagnostics, "INVALID_SCHEMA", [...groupPath, "assetKind"], definition, `Native asset group "${groupName}" must currently use assetKind "font".`);
+		for (const key of ["label", "description"]) if (group[key] !== void 0 && typeof group[key] !== "string") push(diagnostics, "INVALID_SCHEMA", [...groupPath, key], definition, `${key} must be a string when present.`);
+		if (!isRecord(group.members)) {
+			push(diagnostics, "INVALID_SCHEMA", [...groupPath, "members"], definition, `Native font asset group "${groupName}" must have a members record.`);
+			continue;
+		}
+		for (const [memberName, member] of Object.entries(group.members)) {
+			const memberDefinition = {
+				kind: "asset",
+				name: `${groupName}/${memberName}`
+			};
+			const memberPath = [
+				...groupPath,
+				"members",
+				memberName
+			];
+			if (!isRecord(member)) {
+				push(diagnostics, "INVALID_SCHEMA", memberPath, memberDefinition, `Native font asset "${groupName}/${memberName}" must be an object.`);
+				continue;
+			}
+			reportUnknownKeys(member, ASSET_MEMBER_KEYS, memberPath, memberDefinition, diagnostics);
+			if (typeof member.postscriptName !== "string" || member.postscriptName.length === 0) push(diagnostics, "INVALID_SCHEMA", [...memberPath, "postscriptName"], memberDefinition, `Native font asset "${groupName}/${memberName}" requires a non-empty postscriptName.`);
+		}
+	}
+}
+function validateTokenGroups(value, diagnostics) {
+	if (value === void 0) return;
+	if (!isRecord(value)) {
+		push(diagnostics, "INVALID_SCHEMA", ["tokenGroups"], { kind: "config" }, "tokenGroups must be a record.");
+		return;
+	}
+	for (const [groupName, group] of Object.entries(value)) {
+		const groupDefinition = {
+			kind: "token-group",
+			name: groupName
+		};
+		const groupPath = ["tokenGroups", groupName];
+		if (!isRecord(group)) {
+			push(diagnostics, "INVALID_SCHEMA", groupPath, groupDefinition, `Token group "${groupName}" must be an object.`);
+			continue;
+		}
+		reportUnknownKeys(group, GROUP_KEYS, groupPath, groupDefinition, diagnostics);
+		for (const key of ["label", "description"]) if (group[key] !== void 0 && typeof group[key] !== "string") push(diagnostics, "INVALID_SCHEMA", [...groupPath, key], groupDefinition, `${key} must be a string when present.`);
+		if (!isRecord(group.tokens)) {
+			push(diagnostics, "INVALID_SCHEMA", [...groupPath, "tokens"], groupDefinition, `Token group "${groupName}" must have a tokens record.`);
+			continue;
+		}
+		for (const [tokenName, token] of Object.entries(group.tokens)) validateTokenDefinition(token, [
+			...groupPath,
+			"tokens",
+			tokenName
+		], {
+			kind: "token",
+			name: `${groupName}/${tokenName}`
+		}, diagnostics, true);
+	}
+}
+function validateTokenDefinition(value, path, definition, diagnostics, allowModifiers) {
+	if (!isRecord(value)) {
+		push(diagnostics, "INVALID_SCHEMA", path, definition, `Native token "${definition.name ?? ""}" must be an object.`);
+		return;
+	}
+	if (!("value" in value)) push(diagnostics, "INVALID_SCHEMA", [...path, "value"], definition, `Native token "${definition.name ?? ""}" requires a value.`);
+	else validateNativeValue(value.value, [...path, "value"], definition, diagnostics, true);
+	if (value.type !== void 0 && typeof value.type !== "string") push(diagnostics, "INVALID_SCHEMA", [...path, "type"], definition, "Token type must be a string when present.");
+	validateSystemLink(value.link, [...path, "link"], definition, diagnostics);
+	for (const [key, modifier] of Object.entries(value)) {
+		if (key === "value" || key === "type" || key === "link") continue;
+		if (!key.startsWith("_")) {
+			push(diagnostics, "INVALID_SCHEMA", [...path, key], definition, `Unknown token definition field "${key}"; modifier fields must start with "_".`);
+			continue;
+		}
+		if (!allowModifiers) push(diagnostics, "UNSUPPORTED_NATIVE_FIELD", [...path, key], definition, "Compound native token modifiers are completed by the production modes work; this config cannot emit them yet.");
+		if (looksLikeTokenDefinition(modifier)) validateTokenDefinition(modifier, [...path, key], definition, diagnostics, false);
+		else validateNativeValue(modifier, [...path, key], definition, diagnostics, true);
+	}
+}
+function validateSystemLink(value, path, definition, diagnostics) {
+	if (value === void 0) return;
+	if (!isRecord(value)) {
+		push(diagnostics, "INVALID_SCHEMA", path, definition, "Token link provenance must be an object.");
+		return;
+	}
+	reportUnknownKeys(value, new Set([
+		"kind",
+		"systemId",
+		"systemVersion",
+		"sourceKey"
+	]), path, definition, diagnostics);
+	if (value.kind !== "token") push(diagnostics, "INVALID_SCHEMA", [...path, "kind"], definition, "Token link provenance must use kind \"token\".");
+	for (const key of [
+		"systemId",
+		"systemVersion",
+		"sourceKey"
+	]) if (typeof value[key] !== "string" || value[key].length === 0) push(diagnostics, "INVALID_SCHEMA", [...path, key], definition, `Token link provenance requires a non-empty ${key}.`);
+}
+function validateNativeValue(value, path, definition, diagnostics, allowOperatingSystem) {
+	if (typeof value === "string" || typeof value === "boolean") return;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) push(diagnostics, "INVALID_NATIVE_VALUE", path, definition, "Native numeric values must be finite.");
+		return;
+	}
+	if (!isRecord(value)) {
+		push(diagnostics, "INVALID_NATIVE_VALUE", path, definition, "Native token values must be serializable strings, numbers, booleans, references, supported color expressions, or operatingSystem() values.");
+		return;
+	}
+	if (isTokenRef(value) || isAssetRef(value)) {
+		reportUnknownKeys(value, TOKEN_REF_KEYS, path, definition, diagnostics);
+		if (typeof value.ref !== "string" || value.ref.length === 0) push(diagnostics, "INVALID_REFERENCE", [...path, "ref"], definition, "Reference markers require a non-empty ref string.");
+		return;
+	}
+	if (isOperatingSystemValue(value)) {
+		if (!allowOperatingSystem) {
+			push(diagnostics, "NESTED_OS_VALUE", path, definition, "An operatingSystem() branch cannot contain another operatingSystem() value.");
+			return;
+		}
+		validateOperatingSystem(value, path, definition, diagnostics);
+		return;
+	}
+	if (isMixExpr(value)) {
+		validateMix(value, path, definition, diagnostics);
+		return;
+	}
+	const kind = typeof value.__kind === "string" ? value.__kind : void 0;
+	if (kind === "darken" || kind === "lighten" || kind === "linear-gradient" || kind === "radial-gradient") {
+		push(diagnostics, "UNSUPPORTED_COLOR_EXPRESSION", path, definition, `Color expression "${kind}" does not yet have cross-platform native semantics; use mix(), alpha(), or a resolved native color.`);
+		return;
+	}
+	push(diagnostics, "INVALID_NATIVE_VALUE", path, definition, "Native token values do not support arbitrary objects or arrays.");
+}
+function validateOperatingSystem(value, path, definition, diagnostics) {
+	reportUnknownKeys(value, OS_KEYS, path, definition, diagnostics);
+	if (value.default === void 0 && (value.ios === void 0 || value.android === void 0)) push(diagnostics, "INCOMPLETE_OS_VALUE", path, definition, "operatingSystem() requires a default value or explicit ios and android values.");
+	for (const key of [
+		"default",
+		"ios",
+		"android"
+	]) if (value[key] !== void 0) validateNativeValue(value[key], [...path, key], definition, diagnostics, false);
+}
+function validateMix(value, path, definition, diagnostics) {
+	reportUnknownKeys(value, MIX_KEYS, path, definition, diagnostics);
+	validateColorOperand(value.from, [...path, "from"], definition, diagnostics);
+	validateColorOperand(value.to, [...path, "to"], definition, diagnostics);
+	const amount = typeof value.amount === "string" ? /^(-?(?:\d+(?:\.\d+)?|\.\d+))%$/.exec(value.amount) : null;
+	const amountNumber = amount ? Number(amount[1]) : NaN;
+	if (!Number.isFinite(amountNumber) || amountNumber < 0 || amountNumber > 100) push(diagnostics, "INVALID_NATIVE_VALUE", [...path, "amount"], definition, "mix() amount must be a percentage between 0% and 100%.");
+	if (value.colorSpace !== void 0 && !COLOR_SPACES.has(value.colorSpace)) push(diagnostics, "INVALID_NATIVE_VALUE", [...path, "colorSpace"], definition, `mix() colorSpace "${String(value.colorSpace)}" is unsupported.`);
+}
+function validateColorOperand(value, path, definition, diagnostics) {
+	if (typeof value === "string") return;
+	if (isTokenRef(value)) {
+		validateNativeValue(value, path, definition, diagnostics, false);
+		return;
+	}
+	if (isMixExpr(value)) {
+		validateMix(value, path, definition, diagnostics);
+		return;
+	}
+	push(diagnostics, "INVALID_NATIVE_VALUE", path, definition, "Native color expressions accept color strings, token references, or nested mix() expressions.");
+}
+function validateReferences(config, diagnostics) {
+	if (!isRecord(config.tokenGroups)) return;
+	const tokens = /* @__PURE__ */ new Map();
+	for (const [groupName, group] of Object.entries(config.tokenGroups)) {
+		if (!isRecord(group) || !isRecord(group.tokens)) continue;
+		for (const [tokenName, definition] of Object.entries(group.tokens)) {
+			if (!isRecord(definition)) continue;
+			tokens.set(`${groupName}/${tokenName}`, {
+				definition,
+				path: [
+					"tokenGroups",
+					groupName,
+					"tokens",
+					tokenName
+				]
+			});
+		}
+	}
+	const assets = isRecord(config.assetGroups) ? config.assetGroups : {};
+	const modifiers = /* @__PURE__ */ new Set();
+	for (const { definition } of tokens.values()) for (const key of Object.keys(definition)) if (key.startsWith("_")) modifiers.add(key);
+	const contexts = [void 0, ...modifiers];
+	for (const [tokenRef, token] of tokens) {
+		collectAllReferences(token.definition, token.path, {
+			kind: "token",
+			name: tokenRef
+		}, tokens, assets, diagnostics);
+		for (const modifier of contexts) resolveTokenContext(tokenRef, modifier, tokens, diagnostics, [], token.path);
+	}
+}
+function collectAllReferences(value, path, definition, tokens, assets, diagnostics) {
+	walkValues(value, path, (entry, entryPath) => {
+		if (isTokenRef(entry)) {
+			if (typeof entry.ref === "string" && !tokens.has(entry.ref)) push(diagnostics, "UNRESOLVED_TOKEN_REFERENCE", entryPath, definition, `Token reference "${entry.ref}" does not resolve within this native config.`);
+			return;
+		}
+		if (!isAssetRef(entry) || typeof entry.ref !== "string") return;
+		const slash = entry.ref.indexOf("/");
+		const groupName = slash > 0 ? entry.ref.slice(0, slash) : "";
+		const memberName = slash > 0 ? entry.ref.slice(slash + 1) : "";
+		const group = assets[groupName];
+		if (!groupName || !memberName || !group || group.assetKind !== "font" || !isRecord(group.members) || !group.members[memberName]) push(diagnostics, "UNRESOLVED_ASSET_REFERENCE", entryPath, definition, `Asset reference "${entry.ref}" does not resolve to a registered native font asset.`);
+	});
+}
+function resolveTokenContext(ref, modifier, tokens, diagnostics, stack, sourcePath) {
+	if (stack.includes(ref)) {
+		const cycle = [...stack.slice(stack.indexOf(ref)), ref].join(" -> ");
+		push(diagnostics, "TOKEN_REFERENCE_CYCLE", sourcePath, {
+			kind: "token",
+			name: stack[0] ?? ref
+		}, `Native token reference cycle detected: ${cycle}.`);
+		return;
+	}
+	const token = tokens.get(ref);
+	if (!token) return;
+	const selected = selectTokenValue(token.definition, token.path, modifier);
+	const nextStack = [...stack, ref];
+	walkValues(selected.value, selected.path, (entry, entryPath) => {
+		if (isTokenRef(entry) && typeof entry.ref === "string") resolveTokenContext(entry.ref, modifier, tokens, diagnostics, nextStack, entryPath);
+	});
+}
+function selectTokenValue(definition, path, modifier) {
+	const override = modifier ? definition[modifier] : void 0;
+	if (override === void 0) return {
+		value: definition.value,
+		path: [...path, "value"]
+	};
+	if (looksLikeTokenDefinition(override)) return {
+		value: override.value,
+		path: [
+			...path,
+			modifier,
+			"value"
+		]
+	};
+	return {
+		value: override,
+		path: [...path, modifier]
+	};
+}
+function validateModifierOwnership(config, diagnostics) {
+	const owned = /* @__PURE__ */ new Set();
+	if (isRecord(config.modes)) for (const options of Object.values(config.modes)) {
+		if (!isRecord(options)) continue;
+		for (const [optionName, option] of Object.entries(options)) {
+			if (!isRecord(option)) continue;
+			owned.add(typeof option.modifier === "string" ? option.modifier : `_${optionName}`);
+		}
+	}
+	if (!isRecord(config.tokenGroups)) return;
+	for (const [groupName, group] of Object.entries(config.tokenGroups)) {
+		if (!isRecord(group) || !isRecord(group.tokens)) continue;
+		for (const [tokenName, definition] of Object.entries(group.tokens)) {
+			if (!isRecord(definition)) continue;
+			for (const key of Object.keys(definition)) {
+				if (!key.startsWith("_") || owned.has(key)) continue;
+				push(diagnostics, "UNOWNED_MODIFIER", [
+					"tokenGroups",
+					groupName,
+					"tokens",
+					tokenName,
+					key
+				], {
+					kind: "token",
+					name: `${groupName}/${tokenName}`
+				}, `Modifier "${key}" is not owned by a registered mode option.`);
+			}
+		}
+	}
+}
+function walkValues(value, path, visit) {
+	if (!isRecord(value)) return;
+	if (isTokenRef(value) || isAssetRef(value)) {
+		visit(value, path);
+		return;
+	}
+	if (isOperatingSystemValue(value)) {
+		for (const key of [
+			"default",
+			"ios",
+			"android"
+		]) if (value[key] !== void 0) walkValues(value[key], [...path, key], visit);
+		return;
+	}
+	if (isMixExpr(value)) {
+		walkValues(value.from, [...path, "from"], visit);
+		walkValues(value.to, [...path, "to"], visit);
+		return;
+	}
+	if (looksLikeTokenDefinition(value)) {
+		walkValues(value.value, [...path, "value"], visit);
+		for (const [key, nested] of Object.entries(value)) if (key.startsWith("_")) walkValues(nested, [...path, key], visit);
+		return;
+	}
+	for (const [key, nested] of Object.entries(value)) if (key.startsWith("_")) walkValues(nested, [...path, key], visit);
+}
+function looksLikeTokenDefinition(value) {
+	return isRecord(value) && "value" in value && !("__kind" in value);
+}
+function reportUnknownKeys(value, allowed, path, definition, diagnostics) {
+	for (const key of Object.keys(value)) {
+		if (allowed.has(key)) continue;
+		push(diagnostics, "INVALID_SCHEMA", [...path, key], definition, `Unknown native config field "${key}".`);
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function push(diagnostics, code, path, definition, reason) {
+	diagnostics.push({
+		code,
+		severity: "error",
+		path,
+		definition,
+		reason
+	});
+}
+function dedupe(diagnostics) {
+	const seen = /* @__PURE__ */ new Set();
+	return diagnostics.filter((diagnostic) => {
+		const key = `${diagnostic.code}:${diagnostic.path.join(".")}:${diagnostic.reason}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+//#endregion
+export { validateSerializedNativeConfig };

package/dist/native/values.d.ts

@@ -0,0 +1,7 @@
+import { OperatingSystemInput, OperatingSystemValue } from "./types.js";
+
+//#region src/native/values.d.ts
+declare function operatingSystem(input: OperatingSystemInput): OperatingSystemValue;
+declare function isOperatingSystemValue(value: unknown): value is OperatingSystemValue;
+//#endregion
+export { isOperatingSystemValue, operatingSystem };

package/dist/native/values.js

@@ -0,0 +1,15 @@
+//#region src/native/values.ts
+function operatingSystem(input) {
+	if (input.default === void 0 && (input.ios === void 0 || input.android === void 0)) throw new Error("operatingSystem() requires a default value or explicit ios and android values.");
+	return {
+		__kind: "operatingSystem",
+		...input.default !== void 0 ? { default: input.default } : {},
+		...input.ios !== void 0 ? { ios: input.ios } : {},
+		...input.android !== void 0 ? { android: input.android } : {}
+	};
+}
+function isOperatingSystemValue(value) {
+	return typeof value === "object" && value !== null && value.__kind === "operatingSystem";
+}
+//#endregion
+export { isOperatingSystemValue, operatingSystem };

package/dist/native.d.ts

@@ -1,4 +1,11 @@
-import { TokenRef, token } from "./refs.js";
-import { ModeDefinition } from "./types.js";
-import { DefinedNativeTokenGroup, NativeConfig, NativeLiteral, NativeSelectableValue, NativeTokenDefinition, NativeTokenGroupDefinition, NativeTokenGroupMetadata, NativeTokenModifierValue, NativeTokenValue, OperatingSystemInput, OperatingSystemValue, SerializedNativeConfig, defineMode, defineTokenGroup, isOperatingSystemValue, operatingSystem } from "./native/index.js";
-export { DefinedNativeTokenGroup, ModeDefinition, NativeConfig, NativeLiteral, NativeSelectableValue, NativeTokenDefinition, NativeTokenGroupDefinition, NativeTokenGroupMetadata, NativeTokenModifierValue, NativeTokenValue, OperatingSystemInput, OperatingSystemValue, SerializedNativeConfig, TokenRef, defineMode, defineTokenGroup, isOperatingSystemValue, operatingSystem, token };
+import { AssetRef, TokenRef, asset, token } from "./refs.js";
+import { ColorSpace, MixExpr, alpha, mix } from "./colorExpressions.js";
+import { ModeDefinition, SystemLink, TokenType } from "./types.js";
+import { defineMode } from "./factories.js";
+import { NativeAssetGroupDefinition, NativeColorExpression, NativeFontAssetGroupDefinition, NativeFontAssetMember, NativeLiteral, NativeSelectableValue, NativeTokenDefinition, NativeTokenGroupDefinition, NativeTokenValue, OperatingSystemInput, OperatingSystemValue, SerializedNativeConfig } from "./native/types.js";
+import { NativeAssetGroupBuilder, NativeFontAssetGroupConfig, defineAssetGroup } from "./native/assets.js";
+import { NativeConfigDiagnostic, NativeConfigDiagnosticCode, validateSerializedNativeConfig } from "./native/validation.js";
+import { NativeConfig, NativeConfigValidationError } from "./native/NativeConfig.js";
+import { isOperatingSystemValue, operatingSystem } from "./native/values.js";
+import { DefinedNativeTokenGroup, defineTokenGroup } from "./native/index.js";
+export { AssetRef, ColorSpace, DefinedNativeTokenGroup, MixExpr, ModeDefinition, NativeAssetGroupBuilder, NativeAssetGroupDefinition, NativeColorExpression, NativeConfig, NativeConfigDiagnostic, NativeConfigDiagnosticCode, NativeConfigValidationError, NativeFontAssetGroupConfig, NativeFontAssetGroupDefinition, NativeFontAssetMember, NativeLiteral, NativeSelectableValue, NativeTokenDefinition, NativeTokenGroupDefinition, NativeTokenValue, OperatingSystemInput, OperatingSystemValue, SerializedNativeConfig, SystemLink, TokenRef, TokenType, alpha, asset, defineAssetGroup, defineMode, defineTokenGroup, isOperatingSystemValue, mix, operatingSystem, token, validateSerializedNativeConfig };

package/dist/native.js

@@ -1,3 +1,9 @@
-import { token } from "./refs.js";
-import { NativeConfig, defineMode, defineTokenGroup, isOperatingSystemValue, operatingSystem } from "./native/index.js";
-export { NativeConfig, defineMode, defineTokenGroup, isOperatingSystemValue, operatingSystem, token };
+import { asset, token } from "./refs.js";
+import { alpha, mix } from "./colorExpressions.js";
+import { defineMode } from "./factories.js";
+import { defineAssetGroup } from "./native/assets.js";
+import { isOperatingSystemValue, operatingSystem } from "./native/values.js";
+import { validateSerializedNativeConfig } from "./native/validation.js";
+import { NativeConfig, NativeConfigValidationError } from "./native/NativeConfig.js";
+import { defineTokenGroup } from "./native/index.js";
+export { NativeConfig, NativeConfigValidationError, alpha, asset, defineAssetGroup, defineMode, defineTokenGroup, isOperatingSystemValue, mix, operatingSystem, token, validateSerializedNativeConfig };