@digdir/designsystemet 0.0.0-chore-remove-cli-tsx-20260701060359

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

@@ -0,0 +1,71 @@
+import { ConfigSchemaTheme } from "../schemas/v1.1/schema.js";
+import { ColorScheme } from "../colors/types.js";
+import { GetStyleDictionaryConfig } from "./process/configs/shared.js";
+import { Config } from "style-dictionary/types";
+
+//#region src/tokens/types.d.ts
+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>;
+};
+type TokenSet = {
+  [key: string]: Token | TokenSet;
+};
+type TokenSets = Map<string, TokenSet>;
+type Colors = Theme['colors'];
+type Typography = Theme['typography'];
+type Theme = {
+  name: string;
+} & Required<Omit<ConfigSchemaTheme, 'overrides'>> & Pick<ConfigSchemaTheme, 'overrides'>;
+type SizeModes = 'small' | 'medium' | 'large';
+/**
+ * A multi-dimensional theme is a concrete permutation of the possible theme dimensions
+ */
+type ThemePermutation = {
+  'color-scheme': string;
+  color: string;
+  semantic: string;
+  size: string;
+  theme: string;
+  typography: string;
+};
+type ThemeDimension = keyof ThemePermutation;
+type TokenSetDimensions = {
+  colorSchemes: ColorScheme[];
+  sizeModes: SizeModes[];
+};
+type GetSDConfigOptions = {
+  tokensDir?: string;
+  dry?: boolean;
+  tokenSets?: TokenSets;
+};
+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` is always included. */
+  dimensions: ThemeDimension[]; /** Whether the build config is enabled. @default () => true */
+  enabled?: () => boolean; /** Custom log message. */
+  log?: (config: SDConfigForThemePermutation) => string;
+};
+type SDConfigForThemePermutation = {
+  permutation: ThemePermutation;
+  config: Config;
+};
+/** This type is taken from Style Dictionary `formatPlatform`.
+ * Metadata for a file output */
+type OutputFile = {
+  output: string;
+  destination: string;
+};
+type DesignsystemetObject = {
+  name: string;
+  version: string;
+};
+//#endregion
+export { BuildConfig, Colors, DesignsystemetObject, GetSDConfigOptions, OutputFile, SDConfigForThemePermutation, SizeModes, Theme, ThemeDimension, ThemePermutation, Token, TokenSet, TokenSetDimensions, TokenSets, Typography };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/tokens/types.ts"],"mappings":";;;;;;KAKY,KAAA;EACN,MAAA,WAAiB,MAAA;EAA0B,KAAA;AAAA;EAC3C,KAAA;EAAoB,MAAA,EAAQ,MAAA;AAAA;EAE5B,KAAA;EACA,MAAA,EAAQ,MAAA;AAAA;AAAA,KAGF,QAAA;EAAA,CACT,GAAA,WAAc,KAAA,GAAQ,QAAQ;AAAA;AAAA,KAErB,SAAA,GAAY,GAAG,SAAS,QAAA;AAAA,KAExB,MAAA,GAAS,KAAK;AAAA,KACd,UAAA,GAAa,KAAK;AAAA,KAElB,KAAA;EACV,IAAA;AAAA,IACE,QAAA,CAAS,IAAA,CAAK,iBAAA,kBAChB,IAAA,CAAK,iBAAA;AAAA,KAEK,SAAA;;AAhBQ;AAGpB;KAkBY,gBAAA;EACV,cAAA;EACA,KAAA;EACA,QAAA;EACA,IAAA;EACA,KAAA;EACA,UAAA;AAAA;AAAA,KAGU,cAAA,SAAuB,gBAAgB;AAAA,KAEvC,kBAAA;EACV,YAAA,EAAc,WAAA;EACd,SAAA,EAAW,SAAS;AAAA;AAAA,KAGV,kBAAA;EACV,SAAA;EACA,GAAA;EACA,SAAA,GAAY,SAAS;AAAA;AAAA,KAGX,WAAA;EAlCU,0EAoCpB,IAAA,WApC4B;EAsC5B,SAAA,EAAW,wBAAA,EApCD;EAsCV,UAAA,EAAY,cAAA;EAEZ,OAAA,kBAtCW;EAwCX,GAAA,IAAO,MAAA,EAAQ,2BAAA;AAAA;AAAA,KAGL,2BAAA;EAAgC,WAAA,EAAa,gBAAA;EAAkB,MAAA,EAAQ,MAAQ;AAAA;;;KAI/E,UAAA;EACV,MAAA;EACA,WAAW;AAAA;AAAA,KAGD,oBAAA;EACV,IAAA;EACA,OAAO;AAAA"}

package/dist/src/tokens/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,62 @@
+import { CssColor } from "../colors/types.js";
+import { Theme, TokenSet } from "./types.js";
+import { Tokens } from "style-dictionary";
+import { DesignToken, TransformedToken as TransformedToken$1 } from "style-dictionary/types";
+
+//#region src/tokens/utils.d.ts
+/**
+ * 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
+ */
+declare const getValue: <T>(token: TransformedToken$1 | 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
+ */
+declare const typeEquals: (types: string[] | string, token: TransformedToken$1) => boolean;
+declare const pathStartsWithOneOf: ((paths: (string | string[])[], token: TransformedToken$1) => boolean) & ((paths: (string | string[])[]) => (token: TransformedToken$1) => boolean);
+declare function isSemanticToken(token: TransformedToken$1): boolean;
+declare function isSemanticColorToken(token: TransformedToken$1, color: string): boolean;
+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 */
+declare function traverseObj(obj: Tokens | TokenSet, fn: (obj: TokenSet | Tokens | DesignToken, key: keyof Tokens | string, slice: Tokens | DesignToken | string) => void): TokenSet | import("style-dictionary/types").DesignTokens;
+/**
+ * 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
+ */
+declare function inlineTokens(shouldInline: (t: TransformedToken$1) => boolean, tokens: TransformedToken$1[]): TransformedToken$1[];
+declare function shortSizeName(size: string): string;
+declare const sizeComparator: (size: string) => number;
+declare function orderBySize(sizes: string[]): string[];
+declare function addSeverityColors(colors: Theme['colors']): Record<string, CssColor>;
+declare function toColorNames(themeColors: Theme['colors']): string[];
+//#endregion
+export { addSeverityColors, getValue, inlineTokens, isDigit, isSemanticColorToken, isSemanticToken, orderBySize, pathStartsWithOneOf, shortSizeName, sizeComparator, toColorNames, traverseObj, typeEquals };
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../src/tokens/utils.ts"],"mappings":";;;;;;;;;AAyBA;;;;cAAa,QAAA,MAAe,KAAA,EAAO,kBAAA,GAAmB,WAAA,KAAc,CAAA;;;;;;;;cASvD,UAAA,GAAa,KAAA,qBAA0B,KAAA,EAAO,kBAAgB;AAAA,cAU9D,mBAAA,IAAuB,KAAA,yBAA8B,KAAA,EAAO,kBAAA,kBACrE,KAAA,6BAAkC,KAAA,EAAO,kBAAgB;AAAA,iBAgB7C,eAAA,CAAgB,KAAuB,EAAhB,kBAAgB;AAAA,iBAIvC,oBAAA,CAAqB,KAAA,EAAO,kBAAgB,EAAE,KAAA;AAAA,cAIjD,OAAA,GAAW,CAAS;;;iBAIjB,WAAA,CACd,GAAA,EAAK,MAAA,GAAS,QAAA,EACd,EAAA,GAAK,GAAA,EAAK,QAAA,GAAW,MAAA,GAAS,WAAA,EAAa,GAAA,QAAW,MAAA,WAAiB,KAAA,EAAO,MAAA,GAAS,WAAA,qBAA6B,QAAA,oCAAA,YAAA;;;;AAzC3C;AAU3E;;;;;;;;;;;AAC6D;AAgB7D;;;;AAAuD;AAIvD;;;iBAgDgB,YAAA,CAAa,YAAA,GAAe,CAAA,EAAG,kBAAA,cAA8B,MAAA,EAAQ,kBAAA,KAAkB,kBAAA;AAAA,iBAyBvF,aAAA,CAAc,IAAY;AAAA,cAI7B,cAAA,GAAkB,IAAY;AAAA,iBAK3B,WAAA,CAAY,KAAe;AAAA,iBAI3B,iBAAA,CAAkB,MAAA,EAAQ,KAAA,aAAkB,MAAA,SAAe,QAAA;AAAA,iBAK3D,YAAA,CAAa,WAA4B,EAAf,KAAK"}

package/dist/src/tokens/utils.js

@@ -0,0 +1,123 @@
+import { baseColors } from "../colors/colorMetadata.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);
+}
+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);
+}
+function addSeverityColors(colors) {
+	return R.mergeDeepLeft(colors, baseColors);
+}
+function toColorNames(themeColors) {
+	const colors = addSeverityColors(themeColors);
+	return Object.keys(colors);
+}
+//#endregion
+export { addSeverityColors, getValue, inlineTokens, isDigit, isSemanticColorToken, isSemanticToken, orderBySize, pathStartsWithOneOf, shortSizeName, sizeComparator, toColorNames, traverseObj, typeEquals };
+
+//# sourceMappingURL=utils.js.map

package/dist/src/tokens/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../../src/tokens/utils.ts"],"sourcesContent":["import * as R from 'ramda';\nimport type { Tokens } from 'style-dictionary';\nimport type { DesignToken, TransformedToken } from 'style-dictionary/types';\nimport { baseColors } from '../colors/colorMetadata.ts';\nimport type { CssColor } from '../index.ts';\nimport type { Theme, TokenSet } from './types.ts';\n\nconst mapToLowerCase = R.map<string, string>(R.toLower);\n\nconst hasAnyTruth = R.any(R.equals(true));\n\n/**\n * Returns type based on design token format used. Read more:https://v4.styledictionary.com/info/dtcg/\n * @param token Transformed token\n * @returns type\n */\nconst getType = (token: TransformedToken) => ((token.$type ?? token.type) as string) || '';\n\n/**\n * Returns value based on design token format used. Read more:https://v4.styledictionary.com/info/dtcg/\n *\n * Use generic (`<T>`) to define return value type\n * @param token Transformed or Design token\n * @returns value\n */\nexport const getValue = <T>(token: TransformedToken | DesignToken): T => (token.$value ?? token.value) as T;\n\n/**\n * Check if token type matches provided type\n * This function is curried\n * @param types Type or array of types to check against\n * @param token Transformed token\n * @returns boolean\n */\nexport const typeEquals: (types: string[] | string, token: TransformedToken) => boolean = R.curry(\n  (types: string[] | string, token: TransformedToken) => {\n    if (R.isNil(token)) {\n      return false;\n    }\n\n    return R.includes(R.toLower(getType(token)), R.map(R.toLower, Array.isArray(types) ? types : [types]));\n  },\n);\n\nexport const pathStartsWithOneOf: ((paths: (string | string[])[], token: TransformedToken) => boolean) &\n  ((paths: (string | string[])[]) => (token: TransformedToken) => boolean) = R.curry(\n  (paths: (string | string[])[], token: TransformedToken) => {\n    if (R.isNil(token)) {\n      return false;\n    }\n\n    const tokenPath = mapToLowerCase(token.path);\n    const matchPathsStartingWith = R.map((pathOrString) => {\n      const path = typeof pathOrString === 'string' ? [pathOrString] : pathOrString;\n      return R.startsWith(mapToLowerCase(path), tokenPath);\n    }, paths);\n\n    return hasAnyTruth(matchPathsStartingWith);\n  },\n);\n\nexport function isSemanticToken(token: TransformedToken): boolean {\n  return token.filePath.includes('semantic/');\n}\n\nexport function isSemanticColorToken(token: TransformedToken, color: string): boolean {\n  return token.filePath.includes('semantic/') && R.startsWith(['color', color], token.path);\n}\n\nexport const isDigit = (s: string) => /^\\d+$/.test(s);\n\n/** Copied from Style Dictionary and added types\n@see https://github.com/amzn/style-dictionary/blob/31c29df0382a61b085f6392dc3225c5009fbffc5/lib/utils/combineJSON.js#L33 */\nexport function traverseObj(\n  obj: Tokens | TokenSet,\n  fn: (obj: TokenSet | Tokens | DesignToken, key: keyof Tokens | string, slice: Tokens | DesignToken | string) => void,\n) {\n  for (const key in obj) {\n    const prop = obj[key];\n    if (prop != null) {\n      fn.apply(null, [obj, key, prop]);\n      if (typeof prop === 'object') {\n        traverseObj(prop, fn);\n      }\n    }\n  }\n  return obj;\n}\n\n/**\n * In the given tokens array, inline and remove tokens that match the predicate\n *\n * Example: In pseudo-code, given the predicate `(token) => token.path === ['size', '1']` and the following tokens\n * ```js\n *  [\n *    { path: ['size', 'base'], original: { $value: '8px' } },\n *    { path: ['size', '1'], original: { $value: '{size.base} * 2' } },\n *    { path: ['size', 'sm']: original: { $value: 'min({size.1}, 12px)' } }\n *  ]\n * ```\n * would return\n * ```js\n *  [\n *    { path: ['size', 'base'], original: { $value: '8px' } },\n *    { path: ['size', 'sm']: original: { $value: 'min({size.base} * 2, 12px)' } }\n *  ]\n * ```\n *\n * @param shouldInline - predicate to determine if token should be inlined\n * @param tokens - array of tokens to transform\n * @returns copy of `tokens` without those that matched the predicate,\n *          where references to the matching tokens have been inlined\n */\nexport function inlineTokens(shouldInline: (t: TransformedToken) => boolean, tokens: TransformedToken[]) {\n  const [inlineableTokens, otherTokens] = R.partition(shouldInline, tokens);\n  return otherTokens.map((token: TransformedToken) => {\n    // Inline the tokens that satisfy shouldInline().\n    let transformed = getValue<string>(token.original);\n    for (const ref of inlineableTokens) {\n      const refName = ref.path.join('.');\n\n      if (typeof transformed === 'string') {\n        transformed = transformed.replaceAll(`{${refName}}`, getValue<string>(ref.original));\n      }\n    }\n    const tokenWithInlinedRefs = R.set(R.lensPath(['original', '$value']), transformed, token);\n    return tokenWithInlinedRefs;\n  });\n}\n\nconst sizeMap: Record<string, string | undefined> = {\n  xsmall: 'xs',\n  small: 'sm',\n  medium: 'md',\n  large: 'lg',\n  xlarge: 'xl',\n};\n\nexport function shortSizeName(size: string): string {\n  return sizeMap[size] ?? size;\n}\n\nexport const sizeComparator = (size: string): number => {\n  const sortIndex = Object.entries(sizeMap).findIndex(([key, val]) => key === size || val === size);\n  return sortIndex ?? 0;\n};\n\nexport function orderBySize(sizes: string[]): string[] {\n  return R.sortBy(sizeComparator, sizes);\n}\n\nexport function addSeverityColors(colors: Theme['colors']): Record<string, CssColor> {\n  // Add severity colors if not present\n  return R.mergeDeepLeft(colors, baseColors);\n}\n\nexport function toColorNames(themeColors: Theme['colors']): string[] {\n  const colors = addSeverityColors(themeColors);\n\n  return Object.keys(colors);\n}\n"],"mappings":";;;AAOA,MAAM,iBAAiB,EAAE,IAAoB,EAAE,OAAO;AAEtD,MAAM,cAAc,EAAE,IAAI,EAAE,OAAO,IAAI,CAAC;;;;;;AAOxC,MAAM,WAAW,WAA8B,MAAM,SAAS,MAAM,SAAoB;;;;;;;;AASxF,MAAa,YAAe,UAA8C,MAAM,UAAU,MAAM;;;;;;;;AAShG,MAAa,aAA6E,EAAE,OACzF,OAA0B,UAA4B;CACrD,IAAI,EAAE,MAAM,KAAK,GACf,OAAO;CAGT,OAAO,EAAE,SAAS,EAAE,QAAQ,QAAQ,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,SAAS,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC;AACvG,CACF;AAEA,MAAa,sBACgE,EAAE,OAC5E,OAA8B,UAA4B;CACzD,IAAI,EAAE,MAAM,KAAK,GACf,OAAO;CAGT,MAAM,YAAY,eAAe,MAAM,IAAI;CAM3C,OAAO,YALwB,EAAE,KAAK,iBAAiB;EACrD,MAAM,OAAO,OAAO,iBAAiB,WAAW,CAAC,YAAY,IAAI;EACjE,OAAO,EAAE,WAAW,eAAe,IAAI,GAAG,SAAS;CACrD,GAAG,KAEqC,CAAC;AAC3C,CACF;AAEA,SAAgB,gBAAgB,OAAkC;CAChE,OAAO,MAAM,SAAS,SAAS,WAAW;AAC5C;AAEA,SAAgB,qBAAqB,OAAyB,OAAwB;CACpF,OAAO,MAAM,SAAS,SAAS,WAAW,KAAK,EAAE,WAAW,CAAC,SAAS,KAAK,GAAG,MAAM,IAAI;AAC1F;AAEA,MAAa,WAAW,MAAc,QAAQ,KAAK,CAAC;;;AAIpD,SAAgB,YACd,KACA,IACA;CACA,KAAK,MAAM,OAAO,KAAK;EACrB,MAAM,OAAO,IAAI;EACjB,IAAI,QAAQ,MAAM;GAChB,GAAG,MAAM,MAAM;IAAC;IAAK;IAAK;GAAI,CAAC;GAC/B,IAAI,OAAO,SAAS,UAClB,YAAY,MAAM,EAAE;EAExB;CACF;CACA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,aAAa,cAAgD,QAA4B;CACvG,MAAM,CAAC,kBAAkB,eAAe,EAAE,UAAU,cAAc,MAAM;CACxE,OAAO,YAAY,KAAK,UAA4B;EAElD,IAAI,cAAc,SAAiB,MAAM,QAAQ;EACjD,KAAK,MAAM,OAAO,kBAAkB;GAClC,MAAM,UAAU,IAAI,KAAK,KAAK,GAAG;GAEjC,IAAI,OAAO,gBAAgB,UACzB,cAAc,YAAY,WAAW,IAAI,QAAQ,IAAI,SAAiB,IAAI,QAAQ,CAAC;EAEvF;EAEA,OAD6B,EAAE,IAAI,EAAE,SAAS,CAAC,YAAY,QAAQ,CAAC,GAAG,aAAa,KAC1D;CAC5B,CAAC;AACH;AAEA,MAAM,UAA8C;CAClD,QAAQ;CACR,OAAO;CACP,QAAQ;CACR,OAAO;CACP,QAAQ;AACV;AAEA,SAAgB,cAAc,MAAsB;CAClD,OAAO,QAAQ,SAAS;AAC1B;AAEA,MAAa,kBAAkB,SAAyB;CAEtD,OADkB,OAAO,QAAQ,OAAO,CAAC,CAAC,WAAW,CAAC,KAAK,SAAS,QAAQ,QAAQ,QAAQ,IAC7E,KAAK;AACtB;AAEA,SAAgB,YAAY,OAA2B;CACrD,OAAO,EAAE,OAAO,gBAAgB,KAAK;AACvC;AAEA,SAAgB,kBAAkB,QAAmD;CAEnF,OAAO,EAAE,cAAc,QAAQ,UAAU;AAC3C;AAEA,SAAgB,aAAa,aAAwC;CACnE,MAAM,SAAS,kBAAkB,WAAW;CAE5C,OAAO,OAAO,KAAK,MAAM;AAC3B"}

package/dist/src/types.d.ts

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

package/dist/src/types.js

@@ -0,0 +1,10 @@
+export * from "@digdir/designsystemet-types";
+//#region src/types.ts
+/*!
+* This file is deprecated and will be removed in a future release.
+* Use @digdir/designsystemet-types instead
+*/
+//#endregion
+export {};
+
+//# sourceMappingURL=types.js.map

package/dist/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/types.ts"],"sourcesContent":["/*!\n * This file is deprecated and will be removed in a future release.\n * Use @digdir/designsystemet-types instead\n */\n\nexport * from '@digdir/designsystemet-types';\n"],"mappings":""}

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

@@ -0,0 +1,47 @@
+import { OutputFile } from "../tokens/types.js";
+import { CopyOptions, PathLike } from "node:fs";
+
+//#region src/utils/filesystem.d.ts
+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.
+ */
+declare const dsfs: FileSystem;
+//#endregion
+export { dsfs };
+//# sourceMappingURL=filesystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.d.ts","names":[],"sources":["../../../src/utils/filesystem.ts"],"mappings":";;;;cAMM,UAAA;EAAA,QACI,aAAA;EAAA,QACA,GAAA;EAAA,QACA,OAAA;;EAER,UAAA;EACA,MAAA;EAGoB;EAApB,IAAA;IAAO,GAAA;IAAK,MAAA;IAAQ;EAAA;IAAa,GAAA;IAAe,MAAA;IAAiB,OAAA;EAAA;EA+DI;;;;;;;;EA/BrE,KAAA,GAAe,GAAA,EAAK,QAAA,KAAQ,OAAA;EAkB5B,SAAA,GAAmB,IAAA,EAAM,QAAA,EAAU,IAAA,aAAY,OAAA;EAa/C,EAAA,GAAY,GAAA,UAAa,IAAA,UAAc,MAAA,GAAS,WAAA,eAAqB,OAAA;EASrE,QAAA,GAAkB,GAAA,EAAK,QAAA,EAAU,IAAA,EAAM,QAAA,KAAQ,OAAA;EAS/C,QAAA,GAAkB,GAAA,aAAW,OAAA;EAW7B,QAAA,GAAkB,IAAA,EAAM,QAAA,EAAU,iBAAA,eAA2B,OAAA;EAc7D,OAAA,GAAiB,IAAA,EAAM,QAAA,KAAQ,OAAA;EAc/B,UAAA,GAAoB,KAAA,EAAO,UAAA,IAAc,MAAA,UAAgB,GAAA,eAAa,OAAA;AAAA;;;;;;cAsB3D,IAAA,EAAI,UAAmB"}

package/dist/src/utils/filesystem.js

@@ -0,0 +1,117 @@
+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 };
+
+//# sourceMappingURL=filesystem.js.map

package/dist/src/utils/filesystem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.js","names":[],"sources":["../../../src/utils/filesystem.ts"],"sourcesContent":["import type { CopyOptions, PathLike } from 'node:fs';\nimport fs from 'node:fs/promises';\nimport path from 'node:path';\nimport pc from 'picocolors';\nimport type { OutputFile } from '../tokens/types.ts';\n\nclass FileSystem {\n  private isInitialized = false;\n  private dry = false;\n  private verbose = false;\n  /** Default working directory is where the process was started */\n  workingDir = process.cwd();\n  outDir = this.workingDir;\n\n  /** Initialize the file system */\n  init({ dry, outdir, verbose }: { dry?: boolean; outdir?: string; verbose?: boolean }) {\n    if (this.isInitialized) {\n      console.warn(pc.yellow('FileSystem is already initialized. Ignoring subsequent init call.'));\n      return;\n    }\n\n    if (dry) {\n      console.log(pc.blue('Initializing FileSystem in dry-run mode. No files will be written.'));\n    }\n\n    this.dry = dry ?? false;\n    this.verbose = verbose ?? false;\n    // If a config file path is provided, set the working directory to the config file's directory. This allows relative paths in the config file to be resolved correctly. If no config file path is provided, use the current working directory.\n    // this.workingDir = configFilePath ? path.dirname(configFilePath) : this.workingDir;\n    // If an output directory is provided, resolve it relative to the working directory. Otherwise, use the working directory as the output directory.\n    this.outDir = outdir ? (path.isAbsolute(outdir) ? outdir : path.join(this.workingDir, outdir)) : this.workingDir;\n    if (this.verbose) {\n      console.log(\n        `FileSystem initialized with workingDir: ${pc.green(this.workingDir)}, outDir: ${pc.green(this.outDir)}`,\n      );\n    }\n    this.isInitialized = true;\n  }\n\n  /**\n   * Creates a directory if it does not already exist.\n   *\n   * @param dir - The path of the directory to create.\n   *\n   * @returns A promise that resolves when the operation is complete.\n   * If the directory already exists or `dry` is `true`, the promise resolves immediately.\n   */\n  mkdir = async (dir: PathLike) => {\n    if (this.dry) {\n      console.log(`${pc.blue('mkdir')} ${dir}`);\n      return Promise.resolve();\n    }\n\n    const exists = await fs\n      .access(dir, fs.constants.F_OK)\n      .then(() => true)\n      .catch(() => false);\n\n    if (exists) {\n      return Promise.resolve();\n    }\n\n    return fs.mkdir(dir, { recursive: true });\n  };\n\n  writeFile = async (path: PathLike, data: string) => {\n    if (this.dry) {\n      console.log(`${pc.blue('writeFile')} ${path}`);\n      return Promise.resolve();\n    }\n\n    return fs.writeFile(path, data, { encoding: 'utf-8' }).catch((error) => {\n      console.error(pc.red(`Error writing file: ${path}`));\n      console.error(pc.red(error));\n      throw error;\n    });\n  };\n\n  cp = async (src: string, dest: string, filter?: CopyOptions['filter']) => {\n    if (this.dry) {\n      console.log(`${pc.blue('cp')} ${src} ${dest}`);\n      return Promise.resolve();\n    }\n\n    return fs.cp(src, dest, { recursive: true, filter });\n  };\n\n  copyFile = async (src: PathLike, dest: PathLike) => {\n    if (this.dry) {\n      console.log(`${pc.blue('copyFile')} ${src} to ${dest}`);\n      return Promise.resolve();\n    }\n\n    return fs.copyFile(src, dest);\n  };\n\n  cleanDir = async (dir: string) => {\n    if (this.dry) {\n      console.log(`${pc.blue('cleanDir')} ${dir}`);\n      return Promise.resolve();\n    }\n\n    console.log(`\\n🔥 Cleaning dir ${pc.red(`${dir.trim()}`)} `);\n\n    return fs.rm(dir, { recursive: true, force: true });\n  };\n\n  readFile = async (path: PathLike, allowFileNotFound?: boolean) => {\n    if (this.dry) {\n      console.log(`${pc.blue('readFile')} ${path}`);\n    }\n\n    try {\n      return await fs.readFile(path, 'utf-8');\n    } catch (error) {\n      if (allowFileNotFound && (error as NodeJS.ErrnoException).code === 'ENOENT') {\n        return '';\n      }\n      throw error;\n    }\n  };\n  readdir = async (path: PathLike) => {\n    if (this.dry) {\n      console.log(`${pc.blue('readdir')} ${path}`);\n    }\n\n    try {\n      return await fs.readdir(path);\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {\n        return [];\n      }\n      throw error;\n    }\n  };\n  writeFiles = async (files: OutputFile[], outDir: string, log?: boolean) => {\n    for (const { destination: filename, output } of files) {\n      if (filename) {\n        const filePath = path.join(outDir, filename);\n        const fileDir = path.dirname(filePath);\n\n        if (log) {\n          console.log(filename);\n        }\n\n        await this.mkdir(fileDir);\n        await this.writeFile(filePath, output);\n      }\n    }\n  };\n}\n\n/**\n * An abstraction of Node's file system API and helper functions for Designsystemet CLI interaction with the file system.\n *\n * Allows dry-running destructive operations, logging and store relevant file system state.\n */\nexport const dsfs = new FileSystem();\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@digdir/designsystemet",
+  "version": "0.0.0-chore-remove-cli-tsx-20260701060359",
+  "description": "CLI for Designsystemet",
+  "author": "Designsystemet team",
+  "engines": {
+    "node": ">=24.18.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/digdir/designsystemet.git"
+  },
+  "homepage": "https://github.com/digdir/designsystemet/tree/main/packages/cli",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/src/index.js",
+  "files": [
+    "./dist/**"
+  ],
+  "bin": "dist/bin/designsystemet.js",
+  "exports": {
+    ".": {
+      "import": "./dist/src/index.js"
+    },
+    "./color": {
+      "import": "./dist/src/colors/index.js"
+    },
+    "./tokens": {
+      "import": "./dist/src/tokens/index.js"
+    },
+    "./types": {
+      "import": "./dist/src/types.js"
+    },
+    "./schemas/*": {
+      "import": "./dist/src/schemas/*"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@commander-js/extra-typings": "^14.0.0",
+    "@digdir/designsystemet-types": "0.0.0-chore-remove-cli-tsx-20260701060359",
+    "@inquirer/confirm": "^6.1.1",
+    "@tokens-studio/sd-transforms": "2.0.3",
+    "chroma-js": "^3.2.0",
+    "colorjs.io": "^0.6.1",
+    "commander": "^14.0.3",
+    "fast-glob": "^3.3.3",
+    "hsluv": "^1.0.2",
+    "jsonc-parser": "^3.3.1",
+    "object-hash": "^3.0.0",
+    "picocolors": "^1.1.1",
+    "postcss": "^8.5.15",
+    "ramda": "^0.32.0",
+    "style-dictionary": "^5.5.0",
+    "zod": "^4.4.3",
+    "zod-validation-error": "^5.0.0"
+  },
+  "devDependencies": {
+    "@tokens-studio/types": "0.5.2",
+    "@types/chroma-js": "3.1.2",
+    "@types/node": "24.13.2",
+    "@types/object-hash": "3.0.6",
+    "@types/ramda": "0.31.1",
+    "tsdown": "0.22.2",
+    "typescript": "5.9.3"
+  },
+  "scripts": {
+    "designsystemet": "pnpm node ./bin/designsystemet.ts",
+    "designsystemet:inspect": "pnpm node --inspect-brk ./bin/designsystemet.ts",
+    "build": "tsdown && pnpm build:json-schema",
+    "build:json-schema": "pnpm node ./src/scripts/createJsonSchema.ts",
+    "types": "tsc --noEmit",
+    "test:tokens-create-options": "pnpm run designsystemet tokens create -m dominant:\"#007682\" -n \"#003333\" -b 99 -o ./temp/options/design-tokens --theme options --clean",
+    "test:tokens-create-config": "pnpm run designsystemet tokens create --config ./tests/test-tokens.config.jsonc",
+    "test:tokens-build-options": "pnpm run designsystemet tokens build -t ./temp/options/design-tokens -o ./temp/options/build --clean --experimental-tailwind",
+    "test:tokens-build-config": "pnpm run designsystemet tokens build -t ./tests/config/design-tokens -o ./tests/config/build --clean --experimental-tailwind",
+    "test:tokens-build-config:inspect": "pnpm run designsystemet:inspect tokens build -t ./tests/config/design-tokens -o ./tests/config/build --clean",
+    "test:tokens-create-and-build-options": "pnpm test:tokens-create-options && pnpm test:tokens-build-options",
+    "test:tokens-create-and-build-config": "pnpm test:tokens-create-config && pnpm test:tokens-build-config",
+    "test:generate-config-from-tokens": "pnpm run designsystemet generate-config-from-tokens -d ../../design-tokens --dry",
+    "test": "node -v && pnpm test:tokens-create-and-build-options && pnpm test:generate-config-from-tokens && pnpm test:tokens-create-and-build-config",
+    "update:preview-tokens": "pnpm node ./src/scripts/update-preview-tokens.ts",
+    "verify": "pnpm test && pnpm update:template && pnpm --filter @internal/digdir update:theme-digdir"
+  }
+}