@digdir/designsystemet 0.0.0-deps-tsdown-20260421103939

package/dist/src/tokens/process/utils/getMultidimensionalThemes.d.ts

@@ -0,0 +1,36 @@
+import type { ThemeObject } from '@tokens-studio/types';
+import type { ThemeDimension, ThemePermutation } from '../../types.js';
+/**
+ * Find the theme permutations that are relevant for the given theme dimensions.
+ *
+ * Technically, for the given dimensions all permutations are included, while for other
+ * dimensions the first permutation is used.
+ *
+ * @param processed$themes Theme objects from $themes.json (Tokens Studio)
+ * @param dimensions Which theme dimensions to return permutations for.
+ *    'theme' (e.g. altinn/digdir/uutilsynet) is always implicitly included.
+ * @returns the relevant theme permutations
+ */
+export declare const getMultidimensionalThemes: (processed$themes: ProcessedThemeObject[], dimensions: ThemeDimension[]) => PermutatedTheme[];
+export type PermutatedTheme = {
+    name: string;
+    selectedTokenSets: string[];
+    permutation: ThemePermutation;
+};
+declare const processed: unique symbol;
+/**
+ * A Tokens Studio {@link ThemeObject} which has been processed for easier use in code
+ */
+export type ProcessedThemeObject = ThemeObject & {
+    [processed]: true;
+};
+/**
+ * Normalise theme names and theme group names for easier use in code
+ * @param theme A theme object from $themes.json
+ * @returns Processed theme object
+ */
+export declare function processThemeObject(theme: ThemeObject | ProcessedThemeObject): ProcessedThemeObject;
+export type GroupedThemes = Record<keyof ThemePermutation, ProcessedThemeObject[]>;
+export declare const getCustomColors: (processed$themes: ProcessedThemeObject[], colorGroups: (string | RegExp)[]) => string[];
+export {};
+//# sourceMappingURL=getMultidimensionalThemes.d.ts.map

package/dist/src/tokens/process/utils/getMultidimensionalThemes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMultidimensionalThemes.d.ts","sourceRoot":"","sources":["../../../../../src/tokens/process/utils/getMultidimensionalThemes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAIxD,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAIvE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,GAAI,kBAAkB,oBAAoB,EAAE,EAAE,YAAY,cAAc,EAAE,sBAe/G,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,WAAW,EAAE,gBAAgB,CAAC;CAC/B,CAAC;AAEF,QAAA,MAAM,SAAS,EAAE,OAAO,MAAsD,CAAC;AAC/E;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,WAAW,GAAG;IAAE,CAAC,SAAS,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAMvE;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,oBAAoB,GAAG,oBAAoB,CAUlG;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,gBAAgB,EAAE,oBAAoB,EAAE,CAAC,CAAC;AA8FnF,eAAO,MAAM,eAAe,GAAI,kBAAkB,oBAAoB,EAAE,EAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,aASnF,CAAC"}

package/dist/src/tokens/process/utils/getMultidimensionalThemes.js

@@ -0,0 +1,114 @@
+import { TokenSetStatus } from "../../../../node_modules/.pnpm/@tokens-studio_types@0.5.2/node_modules/@tokens-studio/types/dist/constants/TokenSetStatus.js";
+import "../../../../node_modules/.pnpm/@tokens-studio_types@0.5.2/node_modules/@tokens-studio/types/dist/types/index.js";
+import { kebabCase } from "./kebab-case.js";
+import { buildOptions } from "../platform.js";
+import pc from "picocolors";
+import * as R from "ramda";
+//#region src/tokens/process/utils/getMultidimensionalThemes.ts
+/**
+* Find the theme permutations that are relevant for the given theme dimensions.
+*
+* Technically, for the given dimensions all permutations are included, while for other
+* dimensions the first permutation is used.
+*
+* @param processed$themes Theme objects from $themes.json (Tokens Studio)
+* @param dimensions Which theme dimensions to return permutations for.
+*    'theme' (e.g. altinn/digdir/uutilsynet) is always implicitly included.
+* @returns the relevant theme permutations
+*/
+const getMultidimensionalThemes = (processed$themes, dimensions) => {
+	const verboseLogging = buildOptions?.verbose;
+	const grouped$themes = groupThemes(processed$themes);
+	const permutations = permutateThemes(grouped$themes);
+	const ALL_DEPENDENT_ON = ["theme"];
+	const nonDependentKeys = R.keys(grouped$themes).filter((x) => ![...ALL_DEPENDENT_ON, ...dimensions].includes(x));
+	if (verboseLogging) {
+		console.log(pc.cyan(`🔎 Finding theme permutations for ${dimensions}`));
+		console.log(pc.cyan(`   (ignoring permutations for ${nonDependentKeys})`));
+	}
+	return permutations.filter((val) => {
+		return nonDependentKeys.map((x) => val.permutation[x] === grouped$themes[x][0].name).every((x) => x);
+	});
+};
+const processed = Symbol("Type brand for ProcessedThemeObject");
+function isProcessed(theme) {
+	return Boolean(theme[processed]);
+}
+/**
+* Normalise theme names and theme group names for easier use in code
+* @param theme A theme object from $themes.json
+* @returns Processed theme object
+*/
+function processThemeObject(theme) {
+	if (isProcessed(theme)) return theme;
+	const result = {
+		...theme,
+		[processed]: true
+	};
+	if (result.group) result.group = kebabCase(result.group);
+	result.name = kebabCase(result.name);
+	return result;
+}
+function groupThemes(themes) {
+	const groups = {};
+	for (const theme of themes) if (theme.group) {
+		const groupKey = theme.group;
+		groups[groupKey] = [...groups[groupKey] ?? [], theme];
+	} else throw new Error(`Theme ${theme.name} does not have a group property, which is required for multi-dimensional theming.`);
+	return groups;
+}
+const hasUnknownProps = R.pipe(R.values, R.none(R.equals("unknown")), R.not);
+function permutateThemes(groups) {
+	const separator = "_";
+	return cartesian(Object.values(groups)).map((perm) => {
+		const permutatedTheme = perm.reduce((acc, theme) => {
+			const { group, name, selectedTokenSets } = theme;
+			let updatedPermutation = acc.permutation;
+			if (group) {
+				const groupProp = R.lensProp(group);
+				updatedPermutation = R.set(groupProp, name, updatedPermutation);
+			}
+			const updatedName = `${String(acc.name)}${acc ? separator : ""}${name}`;
+			const sets = [...acc.selectedTokenSets, ...filterTokenSets(selectedTokenSets)];
+			return {
+				permutation: updatedPermutation,
+				name: updatedName,
+				selectedTokenSets: sets
+			};
+		}, {
+			name: "",
+			selectedTokenSets: [],
+			permutation: {
+				"color-scheme": "unknown",
+				"main-color": "unknown",
+				"support-color": "unknown",
+				theme: "unknown",
+				semantic: "unknown",
+				size: "unknown",
+				typography: "unknown"
+			}
+		});
+		if (hasUnknownProps(permutatedTheme)) throw Error(`Theme ${permutatedTheme.name} has unknown props: ${JSON.stringify(permutatedTheme)}`);
+		const uniqueTokenSets = new Set(permutatedTheme.selectedTokenSets);
+		return {
+			...permutatedTheme,
+			selectedTokenSets: Array.from(uniqueTokenSets)
+		};
+	});
+}
+function filterTokenSets(tokensets) {
+	return Object.entries(tokensets).filter(([, val]) => val !== TokenSetStatus.DISABLED).sort((a, b) => {
+		if (a[1] === TokenSetStatus.SOURCE && b[1] === TokenSetStatus.ENABLED) return -1;
+		if (a[1] === TokenSetStatus.ENABLED && b[1] === TokenSetStatus.SOURCE) return 1;
+		return 0;
+	}).map((entry) => entry[0]);
+}
+function cartesian(a) {
+	return a.reduce((a, b) => a.flatMap((d) => b.map((e) => [d, e].flat())));
+}
+const getCustomColors = (processed$themes, colorGroups) => processed$themes.filter((x) => {
+	if (!x.group) return false;
+	return colorGroups.includes(x.group);
+}).map((x) => x.name);
+//#endregion
+export { getCustomColors, getMultidimensionalThemes, processThemeObject };

package/dist/src/tokens/process/utils/kebab-case.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Function to convert a string to kebab-case.
+ */
+export declare function kebabCase(str: string): string;
+//# sourceMappingURL=kebab-case.d.ts.map

package/dist/src/tokens/process/utils/kebab-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kebab-case.d.ts","sourceRoot":"","sources":["../../../../../src/tokens/process/utils/kebab-case.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAK7C"}

package/dist/src/tokens/process/utils/kebab-case.js

@@ -0,0 +1,9 @@
+//#region src/tokens/process/utils/kebab-case.ts
+/**
+* Function to convert a string to kebab-case.
+*/
+function kebabCase(str) {
+	return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+//#endregion
+export { kebabCase };

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

@@ -0,0 +1,74 @@
+import type { Config as SDConfig } from 'style-dictionary/types';
+import type { ConfigSchemaTheme } from '../config.js';
+import type { GetStyleDictionaryConfig } from './process/configs/shared.js';
+export type Token = {
+    $value: string | Record<string, string>[];
+    $type: string;
+} | {
+    $type: 'boxShadow';
+    $value: Record<'x' | 'y' | 'blur' | 'spread' | 'color', string>[];
+} | {
+    $type: 'typography';
+    $value: Record<'fontFamily' | 'fontWeight' | 'lineHeight' | 'fontSize' | 'letterSpacing', string>;
+};
+export type TokenSet = {
+    [key: string]: Token | TokenSet;
+};
+export type TokenSets = Map<string, TokenSet>;
+export type Colors = Theme['colors'];
+export type Typography = Theme['typography'];
+export type Theme = {
+    name: string;
+} & Required<Omit<ConfigSchemaTheme, 'overrides'>> & Pick<ConfigSchemaTheme, 'overrides'>;
+export declare const colorCategories: {
+    readonly main: "main";
+    readonly support: "support";
+};
+export type ColorCategories = keyof typeof colorCategories;
+export type BuiltInColors = 'neutral' | 'success' | 'warning' | 'danger' | 'info';
+export type SizeModes = 'small' | 'medium' | 'large';
+/**
+ * A multi-dimensional theme is a concrete permutation of the possible theme dimensions
+ */
+export type ThemePermutation = {
+    'color-scheme': string;
+    'main-color': string;
+    'support-color'?: string;
+    semantic: string;
+    size: string;
+    theme: string;
+    typography: string;
+};
+export type ThemeDimension = keyof ThemePermutation;
+export type GetSDConfigOptions = {
+    tokensDir?: string;
+    dry?: boolean;
+    tokenSets?: TokenSets;
+};
+export type BuildConfig = {
+    /** Optional name of the build config - only used in the console output */
+    name?: string;
+    /** Style Dictionary configuration creator */
+    getConfig: GetStyleDictionaryConfig;
+    /** Which theme dimensions to include. `theme` (e.g. digdir/altinn) is always included. */
+    dimensions: ThemeDimension[];
+    /** Whether the build config is enabled. @default () => true */
+    enabled?: () => boolean;
+    /** Custom log message. */
+    log?: (config: SDConfigForThemePermutation) => string;
+};
+export type SDConfigForThemePermutation = {
+    permutation: ThemePermutation;
+    config: SDConfig;
+};
+/** This type is taken from Style Dictionary `formatPlatform`.
+ * Metadata for a file output */
+export type OutputFile = {
+    output: string;
+    destination: string;
+};
+export type DesignsystemetObject = {
+    name: string;
+    version: string;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/tokens/types.ts"],"names":[],"mappings":"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"}

package/dist/src/tokens/types.js

@@ -0,0 +1,7 @@
+//#region src/tokens/types.ts
+const colorCategories = {
+	main: "main",
+	support: "support"
+};
+//#endregion
+export { colorCategories };

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

@@ -0,0 +1,63 @@
+import type { Tokens } from 'style-dictionary';
+import type { DesignToken, TransformedToken } from 'style-dictionary/types';
+import { type ColorCategories, type TokenSet } from './types.js';
+/**
+ * Returns type based on design token format used. Read more:https://v4.styledictionary.com/info/dtcg/
+ * @param token Transformed token
+ * @returns type
+ */
+export declare const getType: (token: TransformedToken) => string;
+/**
+ * Returns value based on design token format used. Read more:https://v4.styledictionary.com/info/dtcg/
+ *
+ * Use generic (`<T>`) to define return value type
+ * @param token Transformed or Design token
+ * @returns value
+ */
+export declare const getValue: <T>(token: TransformedToken | DesignToken) => T;
+/**
+ * Check if token type matches provided type
+ * This function is curried
+ * @param types Type or array of types to check against
+ * @param token Transformed token
+ * @returns boolean
+ */
+export declare const typeEquals: (types: string[] | string, token: TransformedToken) => boolean;
+export declare const pathStartsWithOneOf: ((paths: (string | string[])[], token: TransformedToken) => boolean) & ((paths: (string | string[])[]) => (token: TransformedToken) => boolean);
+export declare function isSemanticToken(token: TransformedToken): boolean;
+export declare function isSemanticColorToken(token: TransformedToken, color: string): boolean;
+export declare function isGlobalColorToken(token: TransformedToken): boolean;
+export declare function isColorCategoryToken(token: TransformedToken, category?: ColorCategories): boolean;
+export declare const isDigit: (s: string) => boolean;
+/** Copied from Style Dictionary and added types
+@see https://github.com/amzn/style-dictionary/blob/31c29df0382a61b085f6392dc3225c5009fbffc5/lib/utils/combineJSON.js#L33 */
+export declare function traverseObj(obj: Tokens | TokenSet, fn: (obj: TokenSet | Tokens | DesignToken, key: keyof Tokens | string, slice: Tokens | DesignToken | string) => void): import("style-dictionary/types").DesignTokens | TokenSet;
+/**
+ * In the given tokens array, inline and remove tokens that match the predicate
+ *
+ * Example: In pseudo-code, given the predicate `(token) => token.path === ['size', '1']` and the following tokens
+ * ```js
+ *  [
+ *    { path: ['size', 'base'], original: { $value: '8px' } },
+ *    { path: ['size', '1'], original: { $value: '{size.base} * 2' } },
+ *    { path: ['size', 'sm']: original: { $value: 'min({size.1}, 12px)' } }
+ *  ]
+ * ```
+ * would return
+ * ```js
+ *  [
+ *    { path: ['size', 'base'], original: { $value: '8px' } },
+ *    { path: ['size', 'sm']: original: { $value: 'min({size.base} * 2, 12px)' } }
+ *  ]
+ * ```
+ *
+ * @param shouldInline - predicate to determine if token should be inlined
+ * @param tokens - array of tokens to transform
+ * @returns copy of `tokens` without those that matched the predicate,
+ *          where references to the matching tokens have been inlined
+ */
+export declare function inlineTokens(shouldInline: (t: TransformedToken) => boolean, tokens: TransformedToken[]): TransformedToken[];
+export declare function shortSizeName(size: string): string;
+export declare const sizeComparator: (size: string) => number;
+export declare function orderBySize(sizes: string[]): string[];
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/tokens/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,EAAE,KAAK,eAAe,EAAmB,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAMlF;;;;GAIG;AACH,eAAO,MAAM,OAAO,GAAI,OAAO,gBAAgB,WAAkD,CAAC;AAElG;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,OAAO,gBAAgB,GAAG,WAAW,KAAG,CAAuC,CAAC;AAE5G;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,KAAK,EAAE,gBAAgB,KAAK,OAQ/E,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,gBAAgB,KAAK,OAAO,CAAC,GACpG,CAAC,CAAC,KAAK,EAAE,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,CAcxE,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAEhE;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAEpF;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAEnE;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,gBAAgB,EAAE,QAAQ,CAAC,EAAE,eAAe,GAAG,OAAO,CAOjG;AAED,eAAO,MAAM,OAAO,GAAI,GAAG,MAAM,YAAoB,CAAC;AAEtD;2HAC2H;AAC3H,wBAAgB,WAAW,CACzB,GAAG,EAAE,MAAM,GAAG,QAAQ,EACtB,EAAE,EAAE,CAAC,GAAG,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,EAAE,GAAG,EAAE,MAAM,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,KAAK,IAAI,4DAYrH;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,YAAY,CAAC,YAAY,EAAE,CAAC,CAAC,EAAE,gBAAgB,KAAK,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,sBAetG;AAUD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,KAAG,MAG7C,CAAC;AAEF,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAErD"}

package/dist/src/tokens/utils.js

@@ -0,0 +1,121 @@
+import { colorCategories } from "./types.js";
+import * as R from "ramda";
+//#region src/tokens/utils.ts
+const mapToLowerCase = R.map(R.toLower);
+const hasAnyTruth = R.any(R.equals(true));
+/**
+* Returns type based on design token format used. Read more:https://v4.styledictionary.com/info/dtcg/
+* @param token Transformed token
+* @returns type
+*/
+const getType = (token) => (token.$type ?? token.type) || "";
+/**
+* Returns value based on design token format used. Read more:https://v4.styledictionary.com/info/dtcg/
+*
+* Use generic (`<T>`) to define return value type
+* @param token Transformed or Design token
+* @returns value
+*/
+const getValue = (token) => token.$value ?? token.value;
+/**
+* Check if token type matches provided type
+* This function is curried
+* @param types Type or array of types to check against
+* @param token Transformed token
+* @returns boolean
+*/
+const typeEquals = R.curry((types, token) => {
+	if (R.isNil(token)) return false;
+	return R.includes(R.toLower(getType(token)), R.map(R.toLower, Array.isArray(types) ? types : [types]));
+});
+const pathStartsWithOneOf = R.curry((paths, token) => {
+	if (R.isNil(token)) return false;
+	const tokenPath = mapToLowerCase(token.path);
+	return hasAnyTruth(R.map((pathOrString) => {
+		const path = typeof pathOrString === "string" ? [pathOrString] : pathOrString;
+		return R.startsWith(mapToLowerCase(path), tokenPath);
+	}, paths));
+});
+function isSemanticToken(token) {
+	return token.filePath.includes("semantic/");
+}
+function isSemanticColorToken(token, color) {
+	return token.filePath.includes("semantic/") && R.startsWith(["color", color], token.path);
+}
+function isGlobalColorToken(token) {
+	return typeEquals("color", token) && pathStartsWithOneOf(["global"], token);
+}
+function isColorCategoryToken(token, category) {
+	if (!category) return Object.keys(colorCategories).some((colorCategory) => isColorCategoryToken(token, colorCategory));
+	return R.startsWith(["color", category], token.path);
+}
+const isDigit = (s) => /^\d+$/.test(s);
+/** Copied from Style Dictionary and added types
+@see https://github.com/amzn/style-dictionary/blob/31c29df0382a61b085f6392dc3225c5009fbffc5/lib/utils/combineJSON.js#L33 */
+function traverseObj(obj, fn) {
+	for (const key in obj) {
+		const prop = obj[key];
+		if (prop != null) {
+			fn.apply(null, [
+				obj,
+				key,
+				prop
+			]);
+			if (typeof prop === "object") traverseObj(prop, fn);
+		}
+	}
+	return obj;
+}
+/**
+* In the given tokens array, inline and remove tokens that match the predicate
+*
+* Example: In pseudo-code, given the predicate `(token) => token.path === ['size', '1']` and the following tokens
+* ```js
+*  [
+*    { path: ['size', 'base'], original: { $value: '8px' } },
+*    { path: ['size', '1'], original: { $value: '{size.base} * 2' } },
+*    { path: ['size', 'sm']: original: { $value: 'min({size.1}, 12px)' } }
+*  ]
+* ```
+* would return
+* ```js
+*  [
+*    { path: ['size', 'base'], original: { $value: '8px' } },
+*    { path: ['size', 'sm']: original: { $value: 'min({size.base} * 2, 12px)' } }
+*  ]
+* ```
+*
+* @param shouldInline - predicate to determine if token should be inlined
+* @param tokens - array of tokens to transform
+* @returns copy of `tokens` without those that matched the predicate,
+*          where references to the matching tokens have been inlined
+*/
+function inlineTokens(shouldInline, tokens) {
+	const [inlineableTokens, otherTokens] = R.partition(shouldInline, tokens);
+	return otherTokens.map((token) => {
+		let transformed = getValue(token.original);
+		for (const ref of inlineableTokens) {
+			const refName = ref.path.join(".");
+			if (typeof transformed === "string") transformed = transformed.replaceAll(`{${refName}}`, getValue(ref.original));
+		}
+		return R.set(R.lensPath(["original", "$value"]), transformed, token);
+	});
+}
+const sizeMap = {
+	xsmall: "xs",
+	small: "sm",
+	medium: "md",
+	large: "lg",
+	xlarge: "xl"
+};
+function shortSizeName(size) {
+	return sizeMap[size] ?? size;
+}
+const sizeComparator = (size) => {
+	return Object.entries(sizeMap).findIndex(([key, val]) => key === size || val === size) ?? 0;
+};
+function orderBySize(sizes) {
+	return R.sortBy(sizeComparator, sizes);
+}
+//#endregion
+export { getType, getValue, inlineTokens, isColorCategoryToken, isDigit, isGlobalColorToken, isSemanticColorToken, isSemanticToken, orderBySize, pathStartsWithOneOf, shortSizeName, sizeComparator, traverseObj, typeEquals };

package/dist/src/types.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * This file is deprecated and will be removed in a future release.
+ * Use @digdir/designsystemet-types instead
+ */
+export * from '@digdir/designsystemet-types';
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,8BAA8B,CAAC"}

package/dist/src/types.js

@@ -0,0 +1,2 @@
+export * from "@digdir/designsystemet-types";
+export {};

package/dist/src/utils/filesystem.d.ts

@@ -0,0 +1,40 @@
+import type { CopyOptions, PathLike } from 'node:fs';
+import type { OutputFile } from '../tokens/types.js';
+declare class FileSystem {
+    private isInitialized;
+    private dry;
+    private verbose;
+    /** Default working directory is where the process was started */
+    workingDir: string;
+    outDir: string;
+    /** Initialize the file system */
+    init({ dry, outdir, verbose }: {
+        dry?: boolean;
+        outdir?: string;
+        verbose?: boolean;
+    }): void;
+    /**
+     * Creates a directory if it does not already exist.
+     *
+     * @param dir - The path of the directory to create.
+     *
+     * @returns A promise that resolves when the operation is complete.
+     * If the directory already exists or `dry` is `true`, the promise resolves immediately.
+     */
+    mkdir: (dir: PathLike) => Promise<string | void>;
+    writeFile: (path: PathLike, data: string) => Promise<void>;
+    cp: (src: string, dest: string, filter?: CopyOptions["filter"]) => Promise<void>;
+    copyFile: (src: PathLike, dest: PathLike) => Promise<void>;
+    cleanDir: (dir: string) => Promise<void>;
+    readFile: (path: PathLike, allowFileNotFound?: boolean) => Promise<string>;
+    readdir: (path: PathLike) => Promise<string[]>;
+    writeFiles: (files: OutputFile[], outDir: string, log?: boolean) => Promise<void>;
+}
+/**
+ * An abstraction of Node's file system API and helper functions for Designsystemet CLI interaction with the file system.
+ *
+ * Allows dry-running destructive operations, logging and store relevant file system state.
+ */
+export declare const dsfs: FileSystem;
+export {};
+//# sourceMappingURL=filesystem.d.ts.map

package/dist/src/utils/filesystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../../src/utils/filesystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAIrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,cAAM,UAAU;IACd,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,OAAO,CAAS;IACxB,iEAAiE;IACjE,UAAU,SAAiB;IAC3B,MAAM,SAAmB;IAEzB,iCAAiC;IACjC,IAAI,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE;QAAE,GAAG,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE;IAwBpF;;;;;;;OAOG;IACH,KAAK,GAAU,KAAK,QAAQ,4BAgB1B;IAEF,SAAS,GAAU,MAAM,QAAQ,EAAE,MAAM,MAAM,mBAW7C;IAEF,EAAE,GAAU,KAAK,MAAM,EAAE,MAAM,MAAM,EAAE,SAAS,WAAW,CAAC,QAAQ,CAAC,mBAOnE;IAEF,QAAQ,GAAU,KAAK,QAAQ,EAAE,MAAM,QAAQ,mBAO7C;IAEF,QAAQ,GAAU,KAAK,MAAM,mBAS3B;IAEF,QAAQ,GAAU,MAAM,QAAQ,EAAE,oBAAoB,OAAO,qBAa3D;IACF,OAAO,GAAU,MAAM,QAAQ,uBAa7B;IACF,UAAU,GAAU,OAAO,UAAU,EAAE,EAAE,QAAQ,MAAM,EAAE,MAAM,OAAO,mBAcpE;CACH;AAED;;;;GAIG;AACH,eAAO,MAAM,IAAI,YAAmB,CAAC"}

package/dist/src/utils/filesystem.js

@@ -0,0 +1,115 @@
+import pc from "picocolors";
+import fs from "node:fs/promises";
+import path from "node:path";
+//#region src/utils/filesystem.ts
+var FileSystem = class {
+	isInitialized = false;
+	dry = false;
+	verbose = false;
+	/** Default working directory is where the process was started */
+	workingDir = process.cwd();
+	outDir = this.workingDir;
+	/** Initialize the file system */
+	init({ dry, outdir, verbose }) {
+		if (this.isInitialized) {
+			console.warn(pc.yellow("FileSystem is already initialized. Ignoring subsequent init call."));
+			return;
+		}
+		if (dry) console.log(pc.blue("Initializing FileSystem in dry-run mode. No files will be written."));
+		this.dry = dry ?? false;
+		this.verbose = verbose ?? false;
+		this.outDir = outdir ? path.isAbsolute(outdir) ? outdir : path.join(this.workingDir, outdir) : this.workingDir;
+		if (this.verbose) console.log(`FileSystem initialized with workingDir: ${pc.green(this.workingDir)}, outDir: ${pc.green(this.outDir)}`);
+		this.isInitialized = true;
+	}
+	/**
+	* Creates a directory if it does not already exist.
+	*
+	* @param dir - The path of the directory to create.
+	*
+	* @returns A promise that resolves when the operation is complete.
+	* If the directory already exists or `dry` is `true`, the promise resolves immediately.
+	*/
+	mkdir = async (dir) => {
+		if (this.dry) {
+			console.log(`${pc.blue("mkdir")} ${dir}`);
+			return Promise.resolve();
+		}
+		if (await fs.access(dir, fs.constants.F_OK).then(() => true).catch(() => false)) return Promise.resolve();
+		return fs.mkdir(dir, { recursive: true });
+	};
+	writeFile = async (path, data) => {
+		if (this.dry) {
+			console.log(`${pc.blue("writeFile")} ${path}`);
+			return Promise.resolve();
+		}
+		return fs.writeFile(path, data, { encoding: "utf-8" }).catch((error) => {
+			console.error(pc.red(`Error writing file: ${path}`));
+			console.error(pc.red(error));
+			throw error;
+		});
+	};
+	cp = async (src, dest, filter) => {
+		if (this.dry) {
+			console.log(`${pc.blue("cp")} ${src} ${dest}`);
+			return Promise.resolve();
+		}
+		return fs.cp(src, dest, {
+			recursive: true,
+			filter
+		});
+	};
+	copyFile = async (src, dest) => {
+		if (this.dry) {
+			console.log(`${pc.blue("copyFile")} ${src} to ${dest}`);
+			return Promise.resolve();
+		}
+		return fs.copyFile(src, dest);
+	};
+	cleanDir = async (dir) => {
+		if (this.dry) {
+			console.log(`${pc.blue("cleanDir")} ${dir}`);
+			return Promise.resolve();
+		}
+		console.log(`\n🔥 Cleaning dir ${pc.red(`${dir.trim()}`)} `);
+		return fs.rm(dir, {
+			recursive: true,
+			force: true
+		});
+	};
+	readFile = async (path, allowFileNotFound) => {
+		if (this.dry) console.log(`${pc.blue("readFile")} ${path}`);
+		try {
+			return await fs.readFile(path, "utf-8");
+		} catch (error) {
+			if (allowFileNotFound && error.code === "ENOENT") return "";
+			throw error;
+		}
+	};
+	readdir = async (path) => {
+		if (this.dry) console.log(`${pc.blue("readdir")} ${path}`);
+		try {
+			return await fs.readdir(path);
+		} catch (error) {
+			if (error.code === "ENOENT") return [];
+			throw error;
+		}
+	};
+	writeFiles = async (files, outDir, log) => {
+		for (const { destination: filename, output } of files) if (filename) {
+			const filePath = path.join(outDir, filename);
+			const fileDir = path.dirname(filePath);
+			if (log) console.log(filename);
+			await this.mkdir(fileDir);
+			await this.writeFile(filePath, output);
+		}
+	};
+};
+/**
+* An abstraction of Node's file system API and helper functions for Designsystemet CLI interaction with the file system.
+*
+* Allows dry-running destructive operations, logging and store relevant file system state.
+*/
+const dsfs = new FileSystem();
+//#endregion
+export { dsfs };