@digdir/designsystemet 0.0.0-deps-tsdown-20260421103939

package/dist/src/tokens/create/generators/themes/theme.js

@@ -0,0 +1,112 @@
+import { baseColorNames } from "../../../../colors/colorMetadata.js";
+import { semanticColorMap } from "../../../../colors/types.js";
+import * as R from "ramda";
+//#region src/tokens/create/generators/themes/theme.ts
+const generateTheme = (colors, themeName, borderRadius) => {
+	const mainColorNames = Object.keys(colors.main);
+	const supportColorNames = Object.keys(colors.support);
+	const customColors = [
+		...mainColorNames,
+		"neutral",
+		...supportColorNames,
+		...baseColorNames
+	];
+	const themeColorTokens = Object.fromEntries(customColors.map((colorName) => [colorName, generateColorScaleTokens(colorName, themeName)]));
+	const { color: themeBaseFileColor, ...remainingThemeFile } = generateBase(themeName);
+	const themeFile = {
+		color: {
+			...themeColorTokens,
+			...themeBaseFileColor,
+			link: { visited: {
+				$type: "color",
+				$value: `{${themeName}.link.visited}`
+			} },
+			focus: {
+				"inner-color": {
+					$type: "color",
+					$value: `{${themeName}.focus.inner}`
+				},
+				"outer-color": {
+					$type: "color",
+					$value: `{${themeName}.focus.outer}`
+				}
+			}
+		},
+		...remainingThemeFile
+	};
+	const baseBorderRadius = R.lensPath([
+		"border-radius",
+		"base",
+		"$value"
+	]);
+	const updatedThemeFile = R.set(baseBorderRadius, String(borderRadius), themeFile);
+	return JSON.parse(JSON.stringify(updatedThemeFile, (key, value) => {
+		if (key === "$value") return value.replace("<theme>", themeName);
+		return value;
+	}, 2));
+};
+const generateBase = (themeName) => ({
+	color: {},
+	"font-family": {
+		$type: "fontFamilies",
+		$value: `{${themeName}.font-family}`
+	},
+	"font-weight": {
+		medium: {
+			$type: "fontWeights",
+			$value: `{${themeName}.font-weight.medium}`
+		},
+		semibold: {
+			$type: "fontWeights",
+			$value: `{${themeName}.font-weight.semibold}`
+		},
+		regular: {
+			$type: "fontWeights",
+			$value: `{${themeName}.font-weight.regular}`
+		}
+	},
+	"border-radius": {
+		"1": {
+			$type: "dimension",
+			$value: "min({border-radius.base}*0.5,{border-radius.scale})"
+		},
+		"2": {
+			$type: "dimension",
+			$value: "min({border-radius.base},{border-radius.scale}*2)"
+		},
+		"3": {
+			$type: "dimension",
+			$value: "min({border-radius.base}*2,{border-radius.scale}*5)"
+		},
+		"4": {
+			$type: "dimension",
+			$value: "min({border-radius.base}*3,{border-radius.scale}*7)"
+		},
+		"5": {
+			$type: "dimension",
+			$value: "{border-radius.base}"
+		},
+		"6": {
+			$type: "dimension",
+			$value: "9999"
+		},
+		base: {
+			$type: "dimension",
+			$value: "4"
+		},
+		scale: {
+			$type: "dimension",
+			$value: "4"
+		}
+	}
+});
+const generateColorScaleTokens = (colorName, themeName) => {
+	const colorScale = {};
+	for (const [_, colorNumber] of R.toPairs(semanticColorMap)) colorScale[colorNumber] = {
+		$type: "color",
+		$value: `{${themeName}.${colorName}.${colorNumber}}`
+	};
+	return colorScale;
+};
+//#endregion
+export { generateTheme };

package/dist/src/tokens/create.d.ts

@@ -0,0 +1,21 @@
+import type { Theme, TokenSets } from './types.js';
+export declare const cliOptions: {
+    readonly outDir: "out-dir";
+    readonly clean: "clean";
+    readonly tailwind: "tailwind";
+    readonly theme: {
+        readonly colors: {
+            readonly main: "main-colors";
+            readonly support: "support-colors";
+            readonly neutral: "neutral-color";
+        };
+        readonly typography: {
+            readonly fontFamily: "font-family";
+        };
+        readonly borderRadius: "border-radius";
+    };
+};
+export declare const createTokens: (theme: Theme) => Promise<{
+    tokenSets: TokenSets;
+}>;
+//# sourceMappingURL=create.d.ts.map

package/dist/src/tokens/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/tokens/create.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAa,KAAK,EAAY,SAAS,EAAE,MAAM,YAAY,CAAC;AAExE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;CAeb,CAAC;AAEX,eAAO,MAAM,YAAY,GAAU,OAAO,KAAK;;EA4B9C,CAAC"}

package/dist/src/tokens/create.js

@@ -0,0 +1,47 @@
+import { generateColorScheme } from "./create/generators/primitives/color-scheme.js";
+import { generateGlobals } from "./create/generators/primitives/globals.js";
+import { generateSize, generateSizeGlobal } from "./create/generators/primitives/size.js";
+import { generateFontSizes, generateTypography } from "./create/generators/primitives/typography.js";
+import { generateSemanticColors } from "./create/generators/semantic/color.js";
+import { generateColorModes } from "./create/generators/semantic/color-modes.js";
+import { generateSemanticStyle } from "./create/generators/semantic/style.js";
+import { generateTheme } from "./create/generators/themes/theme.js";
+//#region src/tokens/create.ts
+const cliOptions = {
+	outDir: "out-dir",
+	clean: "clean",
+	tailwind: "tailwind",
+	theme: {
+		colors: {
+			main: "main-colors",
+			support: "support-colors",
+			neutral: "neutral-color"
+		},
+		typography: { fontFamily: "font-family" },
+		borderRadius: "border-radius"
+	}
+};
+const createTokens = async (theme) => {
+	const { colors, typography, name, borderRadius, overrides } = theme;
+	const colorSchemes = ["light", "dark"];
+	const sizeModes = [
+		"small",
+		"medium",
+		"large"
+	];
+	return { tokenSets: new Map([
+		["primitives/globals", generateGlobals()],
+		...sizeModes.map((size) => [`primitives/modes/size/${size}`, generateSize(size)]),
+		["primitives/modes/size/global", generateSizeGlobal()],
+		...sizeModes.map((size) => [`primitives/modes/typography/size/${size}`, generateFontSizes(size)]),
+		[`primitives/modes/typography/primary/${name}`, generateTypography(name, typography)],
+		[`primitives/modes/typography/secondary/${name}`, generateTypography(name, typography)],
+		...colorSchemes.flatMap((scheme) => [[`primitives/modes/color-scheme/${scheme}/${name}`, generateColorScheme(name, scheme, colors, overrides)]]),
+		[`themes/${name}`, generateTheme(colors, name, borderRadius)],
+		["semantic/color", generateSemanticColors(colors, name)],
+		...Object.entries(generateColorModes(colors, name)).flatMap(([mode, colors]) => Object.entries(colors).map(([key, colorSet]) => [`semantic/modes/${mode}/${key}`, colorSet])),
+		[`semantic/style`, generateSemanticStyle()]
+	]) };
+};
+//#endregion
+export { cliOptions, createTokens };

package/dist/src/tokens/format.d.ts

@@ -0,0 +1,15 @@
+import { type FormatOptions } from './process/platform.js';
+import type { Theme } from './types.js';
+export declare const formatTokens: (options: Omit<FormatOptions, "type" | "buildTokenFormats">) => Promise<import("./process/platform.js").ProcessReturn>;
+export declare const formatTheme: (themeConfig: Theme) => Promise<import("./process/platform.js").ProcessReturn>;
+/**
+ * Formats a theme configuration into CSS.
+ *
+ * This function takes a `Theme` configuration object, processes it using the
+ * `formatTheme` function, and then generates CSS using the `createThemeCSS` function.
+ *
+ * @param themeConfig - The theme configuration object to be formatted.
+ * @returns A promise that resolves to the generated CSS string.
+ */
+export declare const formatThemeCSS: (themeConfig: Theme) => Promise<string>;
+//# sourceMappingURL=format.d.ts.map

package/dist/src/tokens/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../src/tokens/format.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,aAAa,EAAmB,MAAM,uBAAuB,CAAC;AAE5E,OAAO,KAAK,EAAa,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnD,eAAO,MAAM,YAAY,GAAU,SAAS,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,mBAAmB,CAAC,2DAQ5F,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,aAAa,KAAK,2DAcnD,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,GAAU,aAAa,KAAK,oBAItD,CAAC"}

package/dist/src/tokens/format.js

@@ -0,0 +1,41 @@
+import { createTokens } from "./create.js";
+import { processThemeObject } from "./process/utils/getMultidimensionalThemes.js";
+import { processPlatform } from "./process/platform.js";
+import { createThemeCSSFiles } from "./process/output/theme.js";
+import { generate$Themes } from "./create/generators/$themes.js";
+import * as R from "ramda";
+//#region src/tokens/format.ts
+const formatTokens = async (options) => {
+	return await processPlatform({
+		type: "format",
+		buildTokenFormats: {},
+		...options
+	});
+};
+const formatTheme = async (themeConfig) => {
+	const { tokenSets } = await createTokens(themeConfig);
+	return await formatTokens({
+		tokenSets,
+		processed$themes: (await generate$Themes(["dark", "light"], [themeConfig.name], themeConfig.colors, [
+			"small",
+			"medium",
+			"large"
+		])).map(processThemeObject),
+		verbose: false
+	});
+};
+/**
+* Formats a theme configuration into CSS.
+*
+* This function takes a `Theme` configuration object, processes it using the
+* `formatTheme` function, and then generates CSS using the `createThemeCSS` function.
+*
+* @param themeConfig - The theme configuration object to be formatted.
+* @returns A promise that resolves to the generated CSS string.
+*/
+const formatThemeCSS = async (themeConfig) => {
+	const themeCSSFiles = createThemeCSSFiles({ processedBuilds: await formatTheme(themeConfig) });
+	return R.head(themeCSSFiles)?.output ?? "";
+};
+//#endregion
+export { formatTheme, formatThemeCSS, formatTokens };

package/dist/src/tokens/generate-config.d.ts

@@ -0,0 +1,10 @@
+import type { CreateConfigSchema } from '../config.js';
+export type GenerateConfigOptions = {
+    tokensDir: string;
+    outFile?: string;
+};
+/**
+ * Generates a config file from existing design tokens
+ */
+export declare function generateConfigFromTokens(options: GenerateConfigOptions): Promise<CreateConfigSchema>;
+//# sourceMappingURL=generate-config.d.ts.map

package/dist/src/tokens/generate-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-config.d.ts","sourceRoot":"","sources":["../../../src/tokens/generate-config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AA6MvD,MAAM,MAAM,qBAAqB,GAAG;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;GAEG;AACH,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA6E1G"}

package/dist/src/tokens/generate-config.js

@@ -0,0 +1,178 @@
+import { dsfs } from "../utils/filesystem.js";
+import pc from "picocolors";
+import path from "node:path";
+//#region src/tokens/generate-config.ts
+/**
+* Reads a JSON file and returns its content as an object
+*/
+async function readJsonFile(filePath) {
+	try {
+		const content = await dsfs.readFile(filePath);
+		return JSON.parse(content);
+	} catch (err) {
+		throw new Error(`Failed to read token file at ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+/**
+* Extract the base hex color from a color scale (color.12)
+*/
+function extractBaseColor(colorScale) {
+	if ("12" in colorScale && typeof colorScale["12"] === "object" && "$value" in colorScale["12"]) {
+		const token = colorScale["12"];
+		if (token.$type === "color") return token.$value;
+	}
+	return null;
+}
+/**
+* Discovers theme names from the primitives/modes/color-scheme/light/
+*/
+async function discoverThemes(tokensDir) {
+	const lightModePath = path.join(tokensDir, "themes");
+	try {
+		return (await dsfs.readdir(lightModePath)).filter((file) => file.endsWith(".json")).map((file) => file.replace(".json", ""));
+	} catch {
+		throw new Error(`Could not find themes. Make sure ${pc.blue(lightModePath)} exists and contains theme JSON files.`);
+	}
+}
+/**
+* Reads token information for a specific theme from primitives/modes/color-scheme/light/<theme>.json
+*/
+async function readThemeTokens(tokensDir, themeName) {
+	return readJsonFile(path.join(tokensDir, "primitives", "modes", "color-scheme", "light", `${themeName}.json`));
+}
+/**
+* Reads the theme configuration from themes/<theme>.json
+*/
+async function readThemeConfig(tokensDir, themeName) {
+	const themeConfigPath = path.join(tokensDir, "themes", `${themeName}.json`);
+	try {
+		return await readJsonFile(themeConfigPath);
+	} catch {
+		return null;
+	}
+}
+/**
+* Extract border-radius base value from theme config
+*/
+function extractBorderRadius(themeConfig) {
+	if (!themeConfig || !("border-radius" in themeConfig)) return;
+	const borderRadius = themeConfig["border-radius"];
+	if ("base" in borderRadius && typeof borderRadius.base === "object" && "$value" in borderRadius.base) {
+		const token = borderRadius.base;
+		return Number(token.$value);
+	}
+}
+/**
+* Extract font family from theme config
+*/
+function extractFontFamily(themeConfig) {
+	if (!themeConfig || !("font-family" in themeConfig)) return;
+	const fontFamily = themeConfig["font-family"];
+	if (typeof fontFamily === "object" && "$value" in fontFamily) {
+		const value = fontFamily.$value;
+		if (value.startsWith("{") && value.endsWith("}")) return;
+		return value;
+	}
+}
+/**
+* Reads the typography configuration from primitives/modes/typography/primary/<theme>.json
+*/
+async function readTypographyConfig(tokensDir, themeName) {
+	const typographyConfigPath = path.join(tokensDir, "primitives", "modes", "typography", "primary", `${themeName}.json`);
+	try {
+		return await readJsonFile(typographyConfigPath);
+	} catch {
+		return null;
+	}
+}
+/**
+* Extract font family from typography primitives
+*/
+function extractFontFamilyFromPrimitives(typographyConfig, themeName) {
+	if (!typographyConfig) return;
+	const themeTypography = typographyConfig[themeName];
+	if (!themeTypography || !("font-family" in themeTypography)) return;
+	const fontFamily = themeTypography["font-family"];
+	if (typeof fontFamily === "object" && "$value" in fontFamily) return fontFamily.$value;
+}
+/**
+* Categorizes colors into main, support, and neutral based on color names
+*/
+function categorizeColors(themeTokens, themeName) {
+	const main = {};
+	const support = {};
+	let neutral = null;
+	const builtInColors = [
+		"neutral",
+		"info",
+		"success",
+		"warning",
+		"danger"
+	];
+	const specialKeys = ["link"];
+	const themeColors = themeTokens[themeName];
+	if (!themeColors) return {
+		main,
+		support,
+		neutral
+	};
+	for (const [colorName, colorValue] of Object.entries(themeColors)) {
+		if (specialKeys.includes(colorName)) continue;
+		if (typeof colorValue === "object" && !("$value" in colorValue)) {
+			const baseColor = extractBaseColor(colorValue);
+			if (baseColor) if (colorName === "neutral") neutral = baseColor;
+			else if (builtInColors.includes(colorName)) {} else if (colorName === "accent") main[colorName] = baseColor;
+			else support[colorName] = baseColor;
+		}
+	}
+	return {
+		main,
+		support,
+		neutral
+	};
+}
+/**
+* Generates a config file from existing design tokens
+*/
+async function generateConfigFromTokens(options) {
+	const { tokensDir } = options;
+	console.log(`\nReading tokens from ${pc.blue(tokensDir)}`);
+	const themes = await discoverThemes(tokensDir);
+	if (themes.length === 0) throw new Error(`\nNo themes found in ${pc.blue(tokensDir)}`);
+	console.log(`\nFound ${pc.green(String(themes.length))} theme(s): ${themes.map((t) => pc.cyan(t)).join(", ")}`);
+	const config = {
+		outDir: tokensDir,
+		themes: {}
+	};
+	for (const themeName of themes) {
+		console.log(`\nProcessing theme ${pc.cyan(themeName)}...`);
+		const themeTokens = await readThemeTokens(tokensDir, themeName);
+		const themeConfig = await readThemeConfig(tokensDir, themeName);
+		const typographyConfig = await readTypographyConfig(tokensDir, themeName);
+		const { main, support, neutral } = categorizeColors(themeTokens, themeName);
+		if (Object.keys(main).length === 0) console.warn(pc.yellow(`\nWarning: No main colors found for theme ${themeName}`));
+		if (!neutral) {
+			console.warn(pc.yellow(`\nWarning: No neutral color found for theme ${themeName}`));
+			continue;
+		}
+		const borderRadius = extractBorderRadius(themeConfig);
+		const fontFamily = extractFontFamily(themeConfig) ?? extractFontFamilyFromPrimitives(typographyConfig, themeName);
+		config.themes[themeName] = {
+			colors: {
+				main,
+				support,
+				neutral
+			},
+			borderRadius,
+			typography: fontFamily ? { fontFamily } : void 0
+		};
+		console.log(`\n✅ Main colors: ${Object.keys(main).map((c) => pc.cyan(c)).join(", ") || pc.dim("none")}`);
+		console.log(`\n✅ Support colors: ${Object.keys(support).map((c) => pc.cyan(c)).join(", ") || pc.dim("none")}`);
+		console.log(`\n✅ Neutral: ${pc.cyan(neutral)}`);
+		if (borderRadius !== void 0) console.log(`\n✅ Border radius: ${pc.cyan(String(borderRadius))}`);
+		if (fontFamily) console.log(`\n✅ Font family: ${pc.cyan(fontFamily)}`);
+	}
+	return config;
+}
+//#endregion
+export { generateConfigFromTokens };

package/dist/src/tokens/index.d.ts

@@ -0,0 +1,4 @@
+export { cliOptions, createTokens } from './create.js';
+export { formatThemeCSS, formatTokens } from './format.js';
+export type { Theme as CreateTokensOptions } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/tokens/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tokens/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3D,YAAY,EAAE,KAAK,IAAI,mBAAmB,EAAE,MAAM,YAAY,CAAC"}

package/dist/src/tokens/index.js

@@ -0,0 +1,3 @@
+import { cliOptions, createTokens } from "./create.js";
+import { formatThemeCSS, formatTokens } from "./format.js";
+export { cliOptions, createTokens, formatThemeCSS, formatTokens };

package/dist/src/tokens/process/configs/color.d.ts

@@ -0,0 +1,12 @@
+import type { BuiltInColors, ColorCategories } from '../../types.js';
+import { type GetStyleDictionaryConfig } from './shared.js';
+export declare const colorSchemeVariables: GetStyleDictionaryConfig;
+type ColorCategoryOpts = {
+    category: ColorCategories;
+} | {
+    category: 'builtin';
+    color: BuiltInColors;
+};
+export declare const colorCategoryVariables: (opts: ColorCategoryOpts) => GetStyleDictionaryConfig;
+export {};
+//# sourceMappingURL=color.d.ts.map

package/dist/src/tokens/process/configs/color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../../../../src/tokens/process/configs/color.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKrE,OAAO,EAAkB,KAAK,wBAAwB,EAAU,MAAM,aAAa,CAAC;AAEpF,eAAO,MAAM,oBAAoB,EAAE,wBA8BlC,CAAC;AAEF,KAAK,iBAAiB,GAAG;IAAE,QAAQ,EAAE,eAAe,CAAA;CAAE,GAAG;IAAE,QAAQ,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,aAAa,CAAA;CAAE,CAAC;AAEvG,eAAO,MAAM,sBAAsB,GAChC,MAAM,iBAAiB,KAAG,wBAgD1B,CAAC"}

package/dist/src/tokens/process/configs/color.js

@@ -0,0 +1,51 @@
+import { isColorCategoryToken, isSemanticColorToken, typeEquals } from "../../utils.js";
+import { dsTransformers } from "./shared.js";
+import { formats } from "../formats/css.js";
+import { buildOptions } from "../platform.js";
+import * as R from "ramda";
+//#region src/tokens/process/configs/color.ts
+const colorSchemeVariables = ({ "color-scheme": colorScheme = "light", theme }) => {
+	return {
+		preprocessors: ["tokens-studio"],
+		platforms: { css: {
+			colorScheme,
+			theme,
+			selector: `${colorScheme === "light" ? ":root, " : ""}[data-color-scheme="${colorScheme}"]`,
+			layer: `ds.theme.color-scheme.${colorScheme}`,
+			prefix: "ds",
+			buildPath: `${theme}/`,
+			transforms: dsTransformers,
+			files: [{
+				destination: `color-scheme/${colorScheme}.css`,
+				format: formats.colorScheme.name,
+				filter: (token) => typeEquals("color", token) && !R.startsWith(["global"], token.path)
+			}],
+			options: { outputReferences: false }
+		} }
+	};
+};
+const colorCategoryVariables = (opts) => ({ "color-scheme": colorScheme, theme, ...permutation }) => {
+	const category = opts.category;
+	const color = category === "builtin" ? opts.color : permutation[`${category}-color`];
+	if (!color) throw new Error(category === "builtin" ? `Missing color for built-in color ${opts.color}` : `Missing color for category ${category}`);
+	return {
+		preprocessors: ["tokens-studio"],
+		platforms: { css: {
+			colorScheme,
+			theme,
+			selector: color === buildOptions?.defaultColor ? `:root, [data-color-scheme], [data-color="${color}"]` : `[data-color="${color}"], [data-color-scheme][data-color="${color}"]`,
+			layer: `ds.theme.color`,
+			prefix: "ds",
+			buildPath: `${theme}/`,
+			transforms: dsTransformers,
+			files: [{
+				destination: `color/${color}.css`,
+				format: formats.colorCategory.name,
+				filter: (token) => category === "builtin" ? isSemanticColorToken(token, color) : isColorCategoryToken(token, category)
+			}],
+			options: { outputReferences: true }
+		} }
+	};
+};
+//#endregion
+export { colorCategoryVariables, colorSchemeVariables };

package/dist/src/tokens/process/configs/semantic.d.ts

@@ -0,0 +1,3 @@
+import { type GetStyleDictionaryConfig } from './shared.js';
+export declare const semanticVariables: GetStyleDictionaryConfig;
+//# sourceMappingURL=semantic.d.ts.map

package/dist/src/tokens/process/configs/semantic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../../src/tokens/process/configs/semantic.ts"],"names":[],"mappings":"AAKA,OAAO,EAAkC,KAAK,wBAAwB,EAAU,MAAM,aAAa,CAAC;AAEpG,eAAO,MAAM,iBAAiB,EAAE,wBA4C/B,CAAC"}

package/dist/src/tokens/process/configs/semantic.js

@@ -0,0 +1,47 @@
+import { pathStartsWithOneOf, typeEquals } from "../../utils.js";
+import { dsTransformers } from "./shared.js";
+import { formats } from "../formats/css.js";
+import * as R from "ramda";
+import { outputReferencesFilter } from "style-dictionary/utils";
+//#region src/tokens/process/configs/semantic.ts
+const semanticVariables = ({ theme }) => {
+	return {
+		preprocessors: ["tokens-studio"],
+		platforms: { css: {
+			theme,
+			basePxFontSize: 16,
+			selector: `:root`,
+			layer: `ds.theme.semantic`,
+			prefix: "ds",
+			buildPath: `${theme}/`,
+			transforms: dsTransformers,
+			files: [{
+				destination: `semantic.css`,
+				format: formats.semantic.name,
+				filter: (token) => {
+					const isUwantedToken = R.anyPass([R.includes("primitives/global")])(token.filePath);
+					const isPrivateToken = R.includes("_", token.path);
+					const unwantedPaths = pathStartsWithOneOf([
+						"size",
+						"_size",
+						"font-size",
+						"line-height",
+						"letter-spacing"
+					], token);
+					const unwantedTypes = typeEquals([
+						"color",
+						"fontWeight",
+						"fontFamily",
+						"typography"
+					], token);
+					return !(unwantedPaths || unwantedTypes || isPrivateToken || isUwantedToken);
+				}
+			}],
+			options: { outputReferences: (token, options) => {
+				return pathStartsWithOneOf(["border-radius"], token) && outputReferencesFilter(token, options);
+			} }
+		} }
+	};
+};
+//#endregion
+export { semanticVariables };

package/dist/src/tokens/process/configs/shared.d.ts

@@ -0,0 +1,10 @@
+import type { Config as StyleDictionaryConfig } from 'style-dictionary/types';
+import type { ThemePermutation } from '../../types.js';
+export type GetStyleDictionaryConfig = (permutation: ThemePermutation) => StyleDictionaryConfig | {
+    config: StyleDictionaryConfig;
+    permutationOverrides?: Partial<ThemePermutation>;
+}[];
+export declare const prefix = "ds";
+export declare const basePxFontSize = 16;
+export declare const dsTransformers: string[];
+//# sourceMappingURL=shared.d.ts.map

package/dist/src/tokens/process/configs/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../../src/tokens/process/configs/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC9E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGvD,MAAM,MAAM,wBAAwB,GAAG,CACrC,WAAW,EAAE,gBAAgB,KAC1B,qBAAqB,GAAG;IAAE,MAAM,EAAE,qBAAqB,CAAC;IAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAA;CAAE,EAAE,CAAC;AAEnH,eAAO,MAAM,MAAM,OAAO,CAAC;AAC3B,eAAO,MAAM,cAAc,KAAK,CAAC;AAEjC,eAAO,MAAM,cAAc,UAY1B,CAAC"}

package/dist/src/tokens/process/configs/shared.js

@@ -0,0 +1,19 @@
+import { resolveMath, sizeRem, typographyName, unitless } from "../transformers.js";
+//#region src/tokens/process/configs/shared.ts
+const prefix = "ds";
+const basePxFontSize = 16;
+const dsTransformers = [
+	"name/kebab",
+	resolveMath.name,
+	"ts/size/px",
+	sizeRem.name,
+	unitless.name,
+	"ts/typography/fontWeight",
+	typographyName.name,
+	"ts/color/modifiers",
+	"ts/color/css/hexrgba",
+	"ts/size/lineheight",
+	"shadow/css/shorthand"
+];
+//#endregion
+export { basePxFontSize, dsTransformers, prefix };

package/dist/src/tokens/process/configs/size-mode.d.ts

@@ -0,0 +1,3 @@
+import { type GetStyleDictionaryConfig } from './shared.js';
+export declare const sizeModeVariables: GetStyleDictionaryConfig;
+//# sourceMappingURL=size-mode.d.ts.map

package/dist/src/tokens/process/configs/size-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"size-mode.d.ts","sourceRoot":"","sources":["../../../../../src/tokens/process/configs/size-mode.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkC,KAAK,wBAAwB,EAAU,MAAM,aAAa,CAAC;AAEpG,eAAO,MAAM,iBAAiB,EAAE,wBA8B/B,CAAC"}

package/dist/src/tokens/process/configs/size-mode.js

@@ -0,0 +1,28 @@
+import { dsTransformers } from "./shared.js";
+import { formats } from "../formats/css.js";
+import * as R from "ramda";
+//#region src/tokens/process/configs/size-mode.ts
+const sizeModeVariables = ({ theme, size }) => {
+	return {
+		preprocessors: ["tokens-studio"],
+		platforms: { css: {
+			size,
+			theme,
+			basePxFontSize: 16,
+			selector: `:root`,
+			layer: `ds.theme.size-mode`,
+			prefix: "ds",
+			buildPath: `${theme}/`,
+			transforms: dsTransformers,
+			files: [{
+				destination: `size-mode/${size}.css`,
+				format: formats.sizeMode.name,
+				filter: (token) => {
+					return R.equals(["_size", "mode-font-size"], token.path);
+				}
+			}]
+		} }
+	};
+};
+//#endregion
+export { sizeModeVariables };

package/dist/src/tokens/process/configs/size.d.ts

@@ -0,0 +1,3 @@
+import { type GetStyleDictionaryConfig } from './shared.js';
+export declare const sizeVariables: GetStyleDictionaryConfig;
+//# sourceMappingURL=size.d.ts.map

package/dist/src/tokens/process/configs/size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"size.d.ts","sourceRoot":"","sources":["../../../../../src/tokens/process/configs/size.ts"],"names":[],"mappings":"AAMA,OAAO,EAAkC,KAAK,wBAAwB,EAAU,MAAM,aAAa,CAAC;AAEpG,eAAO,MAAM,aAAa,EAAE,wBAuC3B,CAAC"}