@digdir/designsystemet 1.1.3 → 1.1.4

package/dist/bin/designsystemet.js

@@ -3,7 +3,7 @@
 // bin/designsystemet.ts
 import { Argument, createCommand, program } from "@commander-js/extra-typings";
 import chalk11 from "chalk";
-import * as R26 from "ramda";
+import * as R24 from "ramda";
 
 // src/colors/colorMetadata.ts
 import * as R from "ramda";
@@ -862,14 +862,14 @@ var migrations_default = {
 // src/tokens/build.ts
 import path from "path";
 import chalk7 from "chalk";
-import * as R18 from "ramda";
+import * as R16 from "ramda";
 
 // src/tokens/process/output/declarations.ts
 import chalk5 from "chalk";
 
 // src/tokens/process/platform.ts
 import chalk4 from "chalk";
-import * as R16 from "ramda";
+import * as R14 from "ramda";
 import StyleDictionary2 from "style-dictionary";
 
 // src/tokens/types.ts
@@ -880,7 +880,7 @@ var colorCategories = {
 
 // src/tokens/process/configs.ts
 import { register } from "@tokens-studio/sd-transforms";
-import * as R15 from "ramda";
+import * as R13 from "ramda";
 import StyleDictionary from "style-dictionary";
 
 // src/tokens/utils.ts
@@ -991,7 +991,11 @@ var colorScheme = {
         (t) => !isColorCategoryToken(t)
       ])
     );
-    const formattedTokens = filteredAllTokens.map(format).join("\n");
+    const formattedMap = filteredAllTokens.map((token) => ({
+      token,
+      formatted: format(token)
+    }));
+    const formattedTokens = formattedMap.map(R6.view(R6.lensProp("formatted"))).join("\n");
     const content = `{
 ${formattedTokens}
 ${colorSchemeProperty}}
@@ -1009,7 +1013,8 @@ var colorCategory = {
   name: "ds/css-colorcategory",
   format: async ({ dictionary, options, platform }) => {
     const { outputReferences, usesDtcg } = options;
-    const { selector, layer } = platform;
+    const { selector, layer, files } = platform;
+    const destination = files?.[0]?.destination;
     const format = R6.compose(
       createPropertyFormatter({
         outputReferences,
@@ -1026,7 +1031,12 @@ var colorCategory = {
         }
       })
     );
-    const formattedTokens = dictionary.allTokens.map(format).join("\n");
+    const formattedMap = dictionary.allTokens.map((token) => ({
+      token,
+      formatted: format(token)
+    }));
+    buildOptions.buildTokenFormats[destination] = formattedMap;
+    const formattedTokens = formattedMap.map(R6.view(R6.lensProp("formatted"))).join("\n");
     const content = `{
 ${formattedTokens}
 }
@@ -1057,30 +1067,30 @@ var overrideSizingFormula = (format, token) => {
     calc
   };
 };
-var formatSizingTokens = (format, tokens) => {
-  const { round, calc } = R7.reduce(
-    (acc, token) => {
-      const { round: round2, calc: calc2, name } = overrideSizingFormula(format, token);
-      return {
-        round: [...acc.round, `${name}: ${round2};`],
-        calc: [...acc.calc, `${name}: ${calc2};`]
-      };
-    },
-    { round: [], calc: [] },
-    tokens
-  );
-  return `
+var formatSizingTokens = (format, tokens) => R7.reduce(
+  (acc, token) => {
+    const { round, calc, name } = overrideSizingFormula(format, token);
+    return {
+      tokens: [...acc.tokens, token],
+      round: [...acc.round, `${name}: ${round};`],
+      calc: [...acc.calc, `${name}: ${calc};`]
+    };
+  },
+  { tokens: [], round: [], calc: [] },
+  tokens
+);
+var sizingTemplate = ({ round, calc }) => `
 ${calc.join("\n")}
 
   @supports (width: round(down, .1em, 1px)) {
 ${round.join("\n")}
   }`;
-};
 var semantic = {
   name: "ds/css-semantic",
   format: async ({ dictionary, options, platform }) => {
     const { outputReferences, usesDtcg } = options;
-    const { selector, layer } = platform;
+    const { selector, layer, files } = platform;
+    const destination = files?.[0]?.destination;
     const format = createPropertyFormatter2({
       outputReferences,
       dictionary,
@@ -1093,7 +1103,18 @@ var semantic = {
       (t) => pathStartsWithOneOf(["_size"], t) && isDigit(t.path[1]),
       filteredTokens
     );
-    const formattedTokens = [R7.map(format, restTokens).join("\n"), formatSizingTokens(format, sizingTokens)];
+    const formattedSizingTokens = formatSizingTokens(format, sizingTokens);
+    const formattedMap = restTokens.map((token) => ({
+      token,
+      formatted: format(token)
+    }));
+    const formattedSizingMap = formattedSizingTokens.round.map((t, i) => ({
+      token: formattedSizingTokens.tokens[i],
+      formatted: t
+    }));
+    buildOptions.buildTokenFormats[destination] = [...formattedMap, ...formattedSizingMap];
+    const sizingSnippet = sizingTemplate(formattedSizingTokens);
+    const formattedTokens = formattedMap.map(R7.view(R7.lensProp("formatted"))).concat(sizingSnippet);
     const content = `{
 ${formattedTokens.join("\n")}
 }
@@ -1118,7 +1139,8 @@ var typography = {
   name: "ds/css-typography",
   format: async ({ dictionary, options, platform }) => {
     const { outputReferences, usesDtcg } = options;
-    const { selector, layer } = platform;
+    const { selector, layer, files } = platform;
+    const destination = files?.[0]?.destination;
     const format = createPropertyFormatter3({
       outputReferences,
       dictionary,
@@ -1126,7 +1148,12 @@ var typography = {
       usesDtcg
     });
     const filteredTokens = R8.reject(typographyFontFamilyPredicate, dictionary.allTokens);
-    const formattedTokens = R8.pipe(R8.map(format), R8.join("\n"))(filteredTokens);
+    const formattedMap = filteredTokens.map((token) => ({
+      token,
+      formatted: format(token)
+    }));
+    buildOptions.buildTokenFormats[destination] = formattedMap;
+    const formattedTokens = formattedMap.map(R8.view(R8.lensProp("formatted"))).join("\n");
     const content = selector ? `${selector} {
 ${formattedTokens}
 }` : formattedTokens;
@@ -1333,90 +1360,6 @@ var semanticVariables = ({ theme }) => {
   };
 };
 
-// src/tokens/process/configs/storefront.ts
-import * as R13 from "ramda";
-import { outputReferencesFilter as outputReferencesFilter2 } from "style-dictionary/utils";
-
-// src/tokens/process/formats/js-tokens.ts
-import * as R12 from "ramda";
-import { createPropertyFormatter as createPropertyFormatter4, fileHeader } from "style-dictionary/utils";
-var groupByType = R12.groupBy((token) => getType(token));
-var removeUnwatedTokens = R12.pipe(
-  R12.reject((token) => isColorCategoryToken(token)),
-  R12.reject((token) => R12.any((path5) => path5.startsWith("_"))(token.path))
-);
-var dissocExtensions = R12.pipe(R12.dissoc("$extensions"), R12.dissocPath(["original", "$extensions"]));
-var removeUnwatedProps = R12.map((token) => dissocExtensions(token));
-var toCssVarName = R12.pipe(R12.split(":"), R12.head, R12.trim);
-var jsTokens = {
-  name: "ds/js-tokens",
-  format: async ({ dictionary, file, options }) => {
-    const { usesDtcg, outputReferences } = options;
-    const format = createPropertyFormatter4({
-      outputReferences,
-      dictionary,
-      format: "css",
-      usesDtcg
-    });
-    const formatTokens = R12.map((token) => {
-      if (pathStartsWithOneOf(["size", "_size"], token)) {
-        const { calc, name } = overrideSizingFormula(format, token);
-        return {
-          ...token,
-          name: name.trim(),
-          $value: calc.trim()
-        };
-      }
-      return {
-        ...token,
-        name: toCssVarName(format(token))
-      };
-    });
-    const processTokens = R12.pipe(removeUnwatedTokens, removeUnwatedProps, formatTokens, groupByType);
-    const tokens = processTokens(inlineTokens(isInlineTokens, dictionary.allTokens));
-    const content = Object.entries(tokens).map(
-      ([name, token]) => `export const  ${name} = ${JSON.stringify(token, null, 2).replace(/"([^"]+)":/g, "$1:")} 
-`
-    ).join("\n");
-    return fileHeader({ file }).then((fileHeaderText) => fileHeaderText + content);
-  }
-};
-
-// src/tokens/process/configs/storefront.ts
-var typescriptTokens = ({ "color-scheme": colorScheme2, theme }) => {
-  return {
-    preprocessors: ["tokens-studio"],
-    platforms: {
-      ts: {
-        prefix,
-        basePxFontSize,
-        transforms: dsTransformers,
-        buildPath: `${theme}/`,
-        files: [
-          {
-            destination: `${colorScheme2}.ts`,
-            format: jsTokens.name,
-            filter: (token) => {
-              if (pathStartsWithOneOf(["border-width", "letter-spacing", "border-radius"], token) && !R13.includes("semantic", token.filePath))
-                return false;
-              const isSemanticColor = R13.includes("semantic", token.filePath) && typeEquals(["color"], token);
-              const wantedTypes = typeEquals(["shadow", "dimension", "typography", "opacity"], token);
-              return isSemanticColor || wantedTypes;
-            }
-          }
-        ],
-        options: {
-          outputReferences: (token, options) => {
-            const include = pathStartsWithOneOf(["border-radius"], token);
-            const isWantedSize = pathStartsWithOneOf(["size", "_size"], token) && isDigit(token.path[1]);
-            return (include || isWantedSize) && outputReferencesFilter2(token, options);
-          }
-        }
-      }
-    }
-  };
-};
-
 // src/tokens/process/configs/typography.ts
 import { expandTypesMap } from "@tokens-studio/sd-transforms";
 var typographyVariables = ({ theme, typography: typography2 }) => {
@@ -1443,6 +1386,7 @@ var typographyVariables = ({ theme, typography: typography2 }) => {
           sizeRem.name,
           "ts/size/lineheight",
           "ts/typography/fontWeight",
+          "ts/size/css/letterspacing",
           typographyName.name
         ],
         files: [
@@ -1630,13 +1574,13 @@ var TypographyValues;
 // src/tokens/process/utils/getMultidimensionalThemes.ts
 import chalk3 from "chalk";
 import { kebabCase } from "change-case";
-import * as R14 from "ramda";
+import * as R12 from "ramda";
 var 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 keys3 = R14.keys(grouped$themes);
+  const keys3 = R12.keys(grouped$themes);
   const nonDependentKeys = keys3.filter((x) => ![...ALL_DEPENDENT_ON, ...dimensions].includes(x));
   if (verboseLogging) {
     console.log(chalk3.cyan(`\u{1F50E} Finding theme permutations for ${dimensions}`));
@@ -1676,7 +1620,7 @@ function groupThemes(themes) {
   }
   return groups;
 }
-var hasUnknownProps = R14.pipe(R14.values, R14.none(R14.equals("unknown")), R14.not);
+var hasUnknownProps = R12.pipe(R12.values, R12.none(R12.equals("unknown")), R12.not);
 function permutateThemes(groups) {
   const separator = "_";
   const permutations = cartesian(Object.values(groups));
@@ -1686,8 +1630,8 @@ function permutateThemes(groups) {
         const { group, name, selectedTokenSets } = theme;
         let updatedPermutation = acc.permutation;
         if (group) {
-          const groupProp = R14.lensProp(group);
-          updatedPermutation = R14.set(groupProp, name, updatedPermutation);
+          const groupProp = R12.lensProp(group);
+          updatedPermutation = R12.set(groupProp, name, updatedPermutation);
         }
         const updatedName = `${String(acc.name)}${acc ? separator : ""}${name}`;
         const sets = [...acc.selectedTokenSets, ...filterTokenSets(selectedTokenSets)];
@@ -1746,7 +1690,6 @@ StyleDictionary.registerTransform(sizeRem);
 StyleDictionary.registerTransform(typographyName);
 StyleDictionary.registerTransform(resolveMath);
 StyleDictionary.registerTransform(unitless);
-StyleDictionary.registerFormat(jsTokens);
 for (const format of Object.values(formats)) {
   StyleDictionary.registerFormat(format);
 }
@@ -1760,8 +1703,7 @@ var configs = {
   warningColorVariables: colorCategoryVariables({ category: "builtin", color: "warning" }),
   infoColorVariables: colorCategoryVariables({ category: "builtin", color: "info" }),
   typographyVariables,
-  semanticVariables,
-  typescriptTokens
+  semanticVariables
 };
 var getConfigsForThemeDimensions = (getConfig, processed$themes, dimensions, options) => {
   const { tokensDir, tokenSets } = options;
@@ -1777,7 +1719,7 @@ var getConfigsForThemeDimensions = (getConfig, processed$themes, dimensions, opt
               obj.filePath = tokenSet;
             }
           });
-          tokenSource.tokens = R15.mergeDeepRight(tokenSource.tokens, tokensWithFilePath);
+          tokenSource.tokens = R13.mergeDeepRight(tokenSource.tokens, tokensWithFilePath);
         }
       }
     } else {
@@ -1809,6 +1751,7 @@ var getConfigsForThemeDimensions = (getConfig, processed$themes, dimensions, opt
 // src/tokens/process/platform.ts
 var initResult = {
   formatted: [],
+  tokens: [],
   permutation: {
     "color-scheme": "",
     "main-color": "",
@@ -1819,7 +1762,11 @@ var initResult = {
     typography: ""
   }
 };
-var buildOptions;
+var buildOptions = {
+  verbose: false,
+  processed$themes: [],
+  buildTokenFormats: {}
+};
 var sd = new StyleDictionary2();
 var buildConfigs = {
   typography: { getConfig: configs.typographyVariables, dimensions: ["typography"] },
@@ -1852,19 +1799,15 @@ var buildConfigs = {
     log: ({ permutation: { theme } }) => `${theme} - info`
   },
   semantic: { getConfig: configs.semanticVariables, dimensions: ["semantic"] }
-  // storefront: {
-  //   name: 'Storefront preview tokens',
-  //   getConfig: configs.typescriptTokens,
-  //   dimensions: ['color-scheme'],
-  //   options: { outPath: path.resolve('../../apps/storefront/tokens') },
-  //   enabled: () => buildOptions?.preview ?? false,
-  // },
 };
 async function processPlatform(options) {
   const { type, processed$themes } = options;
   const platform = "css";
   const tokenSets = type === "format" ? options.tokenSets : void 0;
   const tokensDir = type === "build" ? options.tokensDir : void 0;
+  const filteredProcessed$themes = processed$themes.filter(
+    (theme) => R14.not(theme.group === "size" && theme.name !== "medium")
+  );
   const UNSAFE_DEFAULT_COLOR = process.env.UNSAFE_DEFAULT_COLOR ?? "";
   if (UNSAFE_DEFAULT_COLOR) {
     console.warn(
@@ -1887,19 +1830,16 @@ async function processPlatform(options) {
   buildOptions = options;
   buildOptions.defaultColor = UNSAFE_DEFAULT_COLOR;
   buildOptions.colorGroups = colorGroups;
-  const filteredProcessed$themes = processed$themes.filter(
-    (theme) => R16.not(theme.group === "size" && theme.name !== "medium")
-  );
-  const customColors = getCustomColors(filteredProcessed$themes, colorGroups);
   if (!buildOptions.defaultColor) {
-    const firstMainColor = R16.head(customColors);
+    const customColors = getCustomColors(filteredProcessed$themes, colorGroups);
+    const firstMainColor = R14.head(customColors);
     buildOptions.defaultColor = firstMainColor;
   }
   if (buildOptions.defaultColor) {
     console.log(`
 \u{1F3A8} Using ${chalk4.blue(buildOptions.defaultColor)} as default color`);
   }
-  const buildAndSdConfigs = R16.map((buildConfig) => {
+  const buildAndSdConfigs = R14.map((buildConfig) => {
     const sdConfigs = getConfigsForThemeDimensions(
       buildConfig.getConfig,
       filteredProcessed$themes,
@@ -1935,7 +1875,7 @@ async function processPlatform(options) {
     typography: [initResult]
   };
   try {
-    for (const [buildName, { buildConfig, sdConfigs }] of R16.toPairs(buildAndSdConfigs)) {
+    for (const [buildName, { buildConfig, sdConfigs }] of R14.toPairs(buildAndSdConfigs)) {
       if (!(buildConfig.enabled?.() ?? true)) {
         continue;
       }
@@ -1947,13 +1887,16 @@ async function processPlatform(options) {
             const { config, permutation } = sdConfig;
             const modes = ["theme", ...buildConfig.dimensions];
             const modeMessage = modes.map((x) => permutation[x]).join(" - ");
-            const logMessage = R16.isNil(buildConfig.log) ? modeMessage : buildConfig?.log(sdConfig);
+            const logMessage = R14.isNil(buildConfig.log) ? modeMessage : buildConfig?.log(sdConfig);
             console.log(logMessage);
             const sdOptions = { cache: true };
             const sdExtended = await sd.extend(config);
+            const formatted = await sdExtended.formatPlatform(platform, sdOptions);
+            const tokens = (await sdExtended.getPlatformTokens(platform, sdOptions)).allTokens;
             const result = {
               permutation,
-              formatted: await sdExtended.formatPlatform(platform, sdOptions)
+              formatted,
+              tokens
             };
             return Promise.resolve(result);
           })
@@ -1990,7 +1933,7 @@ import type {} from '@digdir/designsystemet-react/colors';
 
 declare module '@digdir/designsystemet-react/colors' {
   export interface MainAndSupportColors {
-${colors2.map((color) => `    ${color}: never;`).join("\n")}
+${colors2.map((color) => `    ${color.includes("-") ? `'${color}'` : color}: never;`).join("\n")}
   }
 }
 `.trimStart();
@@ -2056,16 +1999,16 @@ ${dynamicColors}`;
 
 // src/tokens/process/output/theme.ts
 import chalk6 from "chalk";
-import * as R17 from "ramda";
+import * as R15 from "ramda";
 
 // package.json
 var package_default = {
   name: "@digdir/designsystemet",
-  version: "1.1.3",
+  version: "1.1.4",
   description: "CLI for Designsystemet",
   author: "Designsystemet team",
   engines: {
-    node: ">=22.16.0"
+    node: ">=22.17.0"
   },
   repository: {
     type: "git",
@@ -2114,6 +2057,7 @@ var package_default = {
     "digdir:tokens-build": "pnpm run designsystemet tokens build -t ../../internal/design-tokens -o ../../packages/theme/brand --clean --experimental-tailwind",
     "digdir:tokens-create": "pnpm run designsystemet tokens create --config ./configs/digdir.config.json",
     "update:template": "tsx ./src/scripts/update-template.ts",
+    "update:preview-tokens": "tsx ./src/scripts/update-preview-tokens.ts",
     "update:theme-digdir": "pnpm digdir:tokens-create && tsx ./src/scripts/update-design-tokens.ts && pnpm digdir:tokens-build",
     verify: "pnpm test && pnpm update:template && pnpm update:theme-digdir && pnpm build:tokens"
   },
@@ -2131,8 +2075,8 @@ var package_default = {
     "object-hash": "^3.0.0",
     postcss: "^8.5.6",
     ramda: "^0.31.3",
-    "style-dictionary": "^5.0.0",
-    zod: "^3.25.67",
+    "style-dictionary": "^5.0.1",
+    zod: "^3.25.74",
     "zod-validation-error": "^3.5.2"
   },
   devDependencies: {
@@ -2140,8 +2084,7 @@ var package_default = {
     "@types/apca-w3": "^0.1.3",
     "@types/chroma-js": "^3.1.1",
     "@types/fs-extra": "^11.0.4",
-    "@types/glob": "^8.1.0",
-    "@types/node": "^22.15.32",
+    "@types/node": "^22.16.0",
     "@types/object-hash": "^3.0.6",
     "@types/ramda": "^0.30.2",
     "fs-extra": "^11.3.0",
@@ -2156,16 +2099,16 @@ var package_default = {
 var defaultFileHeader = `build: v${package_default.version}`;
 var createThemeCSSFiles = ({
   processedBuilds,
-  fileHeader: fileHeader2 = defaultFileHeader
+  fileHeader = defaultFileHeader
 }) => {
   const groupedByTheme = {};
   for (const [_, buildResults] of Object.entries(processedBuilds)) {
     for (const buildResult of buildResults) {
       const themeName = buildResult.permutation.theme;
       const newOutputs = buildResult.formatted;
-      if (R17.isNotEmpty(newOutputs)) {
+      if (R15.isNotEmpty(newOutputs)) {
         const currentOutputs = groupedByTheme[themeName] ?? [];
-        groupedByTheme[themeName] = R17.concat(currentOutputs, newOutputs);
+        groupedByTheme[themeName] = R15.concat(currentOutputs, newOutputs);
       }
     }
   }
@@ -2178,7 +2121,7 @@ var createThemeCSSFiles = ({
     "typography/primary",
     "color/"
   ];
-  const sortByDefinedOrder = R17.sortBy((file) => {
+  const sortByDefinedOrder = R15.sortBy((file) => {
     const filePath = file.destination || "";
     const sortIndex = sortOrder.findIndex((sortElement) => {
       if (sortElement.endsWith("/")) {
@@ -2203,17 +2146,17 @@ order may change due to nondeterminism.`.trim()
   });
   const header = `@charset "UTF-8";
 /*
-${fileHeader2}
+${fileHeader}
 */
 
 `;
-  const sortAlphabetically = R17.sort(R17.ascend((x) => x.destination || ""));
-  const pickOutputs = R17.map(R17.view(R17.lensProp("output")));
-  const themeCSSFile = R17.pipe(
+  const sortAlphabetically = R15.sort(R15.ascend((x) => x.destination || ""));
+  const pickOutputs = R15.map(R15.view(R15.lensProp("output")));
+  const themeCSSFile = R15.pipe(
     sortAlphabetically,
     sortByDefinedOrder,
     pickOutputs,
-    R17.join("\n"),
+    R15.join("\n"),
     (content) => header + content
   );
   const themeCSSFiles = Object.entries(groupedByTheme).map(([theme, files]) => ({
@@ -2253,16 +2196,17 @@ var buildTokens = async (options) => {
     outDir,
     tokensDir,
     type: "build",
-    processed$themes
+    processed$themes,
+    buildTokenFormats: {}
   });
-  const fileHeader2 = R18.join("")([
+  const fileHeader = R16.join("")([
     defaultFileHeader,
     $designsystemet ? `
 design-tokens: v${$designsystemet.version}` : ""
   ]);
   let files = [];
   const declarationFiles = createTypeDeclarationFiles(processed$themes);
-  const cssFiles = createThemeCSSFiles({ processedBuilds, fileHeader: fileHeader2 });
+  const cssFiles = createThemeCSSFiles({ processedBuilds, fileHeader });
   files = [...declarationFiles, ...cssFiles];
   if (options.tailwind) {
     const tailwindFiles = createTailwindCSSFiles(cssFiles);
@@ -2279,7 +2223,7 @@ design-tokens: v${$designsystemet.version}` : ""
 // src/tokens/create/write.ts
 import path2 from "path";
 import chalk8 from "chalk";
-import * as R19 from "ramda";
+import * as R17 from "ramda";
 
 // src/tokens/create/generators/$designsystemet.ts
 function generate$Designsystemet() {
@@ -2506,12 +2450,12 @@ var writeTokens = async (options) => {
     }
   } catch (_error) {
   }
-  const concatThemeNames = R19.pipe(
-    R19.filter((obj) => R19.toLower(obj.group || "") === "theme"),
-    R19.map(R19.prop("name")),
+  const concatThemeNames = R17.pipe(
+    R17.filter((obj) => R17.toLower(obj.group || "") === "theme"),
+    R17.map(R17.prop("name")),
     // New theme is added to the end of the list so we keep the same order from config and Token Studio
-    R19.append(themeName),
-    R19.uniq
+    R17.append(themeName),
+    R17.uniq
   );
   const themes = concatThemeNames(themeObjects);
   console.log(`
@@ -2534,7 +2478,7 @@ Themes: ${chalk8.blue(themes.join(", "))}`);
 };
 
 // src/tokens/create/defaults.ts
-import * as R20 from "ramda";
+import * as R18 from "ramda";
 
 // src/tokens/template/design-tokens/primitives/globals.json with { type: 'json' }
 var globals_default = {
@@ -3519,13 +3463,13 @@ var defaultTokens = {
   "primitives/modes/typography/size/large": large_default2,
   "semantic/style": style_default
 };
-var getDefaultTokens = (tokenSets) => Object.entries(R20.pick(tokenSets, defaultTokens));
+var getDefaultTokens = (tokenSets) => Object.entries(R18.pick(tokenSets, defaultTokens));
 var getDefaultToken = (tokenPath) => {
   return [tokenPath, defaultTokens[tokenPath]];
 };
 
 // src/tokens/create/generators/color.ts
-import * as R21 from "ramda";
+import * as R19 from "ramda";
 var generateColor = (colorArray) => {
   const obj = {};
   const $type = "color";
@@ -3535,8 +3479,8 @@ var generateColor = (colorArray) => {
   return obj;
 };
 var generateColorScheme = (themeName, colorScheme2, colors2) => {
-  const main = R21.map((color) => generateColor(generateColorScale(color, colorScheme2)), colors2.main);
-  const support = R21.map((color) => generateColor(generateColorScale(color, colorScheme2)), colors2.support);
+  const main = R19.map((color) => generateColor(generateColorScale(color, colorScheme2)), colors2.main);
+  const support = R19.map((color) => generateColor(generateColorScale(color, colorScheme2)), colors2.support);
   const neutral = generateColor(generateColorScale(colors2.neutral, colorScheme2));
   return {
     [themeName]: {
@@ -3564,7 +3508,7 @@ var generateColorGlobal = (colorScheme2) => {
 };
 
 // src/tokens/create/generators/semantic.ts
-import * as R22 from "ramda";
+import * as R20 from "ramda";
 
 // src/tokens/template/design-tokens/semantic/color.base.template.json with { type: 'json' }
 var color_base_template_default = {
@@ -4028,7 +3972,7 @@ var generateSemantic = (colors2) => {
   const semanticColorTokens = customColors.map(
     (colorName) => [
       colorName,
-      R22.map((x) => ({ ...x, $value: x.$value.replace("<color>", colorName) }), color_template_default)
+      R20.map((x) => ({ ...x, $value: x.$value.replace("<color>", colorName) }), color_template_default)
     ]
   );
   const color = {
@@ -4045,7 +3989,7 @@ var generateSemantic = (colors2) => {
 };
 
 // src/tokens/create/generators/theme.ts
-import * as R23 from "ramda";
+import * as R21 from "ramda";
 
 // src/tokens/template/design-tokens/themes/theme.base.template.json with { type: 'json' }
 var theme_base_template_default = {
@@ -4181,7 +4125,7 @@ var generateTheme = (colors2, themeName, borderRadius) => {
     customColors.map(
       (colorName) => [
         colorName,
-        R23.map((x) => ({ ...x, $value: x.$value.replace("<color>", colorName) }), theme_template_default)
+        R21.map((x) => ({ ...x, $value: x.$value.replace("<color>", colorName) }), theme_template_default)
       ]
     )
   );
@@ -4193,8 +4137,8 @@ var generateTheme = (colors2, themeName, borderRadius) => {
     },
     ...remainingThemeFile
   };
-  const baseBorderRadius = R23.lensPath(["border-radius", "base", "$value"]);
-  const updatedThemeFile = R23.set(baseBorderRadius, String(borderRadius), themeFile);
+  const baseBorderRadius = R21.lensPath(["border-radius", "base", "$value"]);
+  const updatedThemeFile = R21.set(baseBorderRadius, String(borderRadius), themeFile);
   const token = JSON.parse(
     JSON.stringify(
       updatedThemeFile,
@@ -4293,16 +4237,16 @@ var createTokens = async (opts) => {
 // bin/config.ts
 import path4 from "path";
 import chalk10 from "chalk";
-import * as R25 from "ramda";
+import * as R23 from "ramda";
 
 // src/config.ts
 import chalk9 from "chalk";
-import * as R24 from "ramda";
+import * as R22 from "ramda";
 import { z } from "zod/v4";
 import { fromError } from "zod-validation-error/v4";
 function mapPathToOptionName(path5) {
-  const normalisedPath = path5[0] === "themes" ? ["theme", ...R24.drop(2, path5)] : path5;
-  const option = R24.path(normalisedPath, cliOptions);
+  const normalisedPath = path5[0] === "themes" ? ["theme", ...R22.drop(2, path5)] : path5;
+  const option = R22.path(normalisedPath, cliOptions);
   if (typeof option !== "string") {
     return;
   }
@@ -4426,11 +4370,11 @@ async function parseCreateConfig(configFile, options) {
   const { cmd, theme = "theme", configPath } = options;
   const configParsed = parseConfig(configFile, configPath);
   const themeColors = Object.values(configParsed?.themes ?? {}).map(
-    (x) => /* @__PURE__ */ new Set([...R25.keys(x.colors.main), ...R25.keys(x.colors.support)])
+    (x) => /* @__PURE__ */ new Set([...R23.keys(x.colors.main), ...R23.keys(x.colors.support)])
   );
-  if (!R25.all(R25.equals(R25.__, themeColors[0]), themeColors)) {
+  if (!R23.all(R23.equals(R23.__, themeColors[0]), themeColors)) {
     console.error(chalk10.redBright(`In config, all themes must have the same custom color names, but we found:`));
-    const themeNames = R25.keys(configParsed.themes ?? {});
+    const themeNames = R23.keys(configParsed.themes ?? {});
     themeColors.forEach((colors2, index) => {
       const colorNames = Array.from(colors2);
       console.log(`  - ${themeNames[index]}: ${colorNames.join(", ")}`);
@@ -4438,7 +4382,7 @@ async function parseCreateConfig(configFile, options) {
     console.log();
     process.exit(1);
   }
-  const noUndefined = R25.reject(R25.isNil);
+  const noUndefined = R23.reject(R23.isNil);
   const getThemeOptions = (optionGetter) => noUndefined({
     colors: noUndefined({
       main: optionGetter(cmd, "mainColors"),
@@ -4454,10 +4398,10 @@ async function parseCreateConfig(configFile, options) {
   const unvalidatedConfig = noUndefined({
     outDir: configParsed?.outDir ?? getCliOption(cmd, "outDir"),
     clean: configParsed?.clean ?? getCliOption(cmd, "clean"),
-    themes: configParsed?.themes ? R25.map((jsonThemeValues) => {
+    themes: configParsed?.themes ? R23.map((jsonThemeValues) => {
       const defaultThemeValues = getThemeOptions(getDefaultCliOption);
       const cliThemeValues = getThemeOptions(getSuppliedCliOption);
-      const mergedConfigs = R25.mergeDeepRight(defaultThemeValues, R25.mergeDeepRight(jsonThemeValues, cliThemeValues));
+      const mergedConfigs = R23.mergeDeepRight(defaultThemeValues, R23.mergeDeepRight(jsonThemeValues, cliThemeValues));
       return mergedConfigs;
     }, configParsed.themes) : (
       // If there are no themes specified in the JSON config, we use both explicit
@@ -4487,8 +4431,8 @@ function makeTokenCommands() {
     "-o, --out-dir <string>",
     `Output directory for built ${chalk11.blue("design-tokens")}`,
     DEFAULT_TOKENS_BUILD_DIR
-  ).option(`--${cliOptions.clean} [boolean]`, "Clean output directory before building tokens", parseBoolean, false).option("--dry [boolean]", `Dry run for built ${chalk11.blue("design-tokens")}`, parseBoolean, false).option("-p, --preview", "Generate preview token.ts files", false).option("--verbose", "Enable verbose output", false).option("--config <string>", `Path to config file (default: "${DEFAULT_CONFIG_FILE}")`).option("--experimental-tailwind", "Generate Tailwind CSS classes for tokens", false).action(async (opts) => {
-    const { preview, verbose, clean, dry, experimentalTailwind } = opts;
+  ).option(`--${cliOptions.clean} [boolean]`, "Clean output directory before building tokens", parseBoolean, false).option("--dry [boolean]", `Dry run for built ${chalk11.blue("design-tokens")}`, parseBoolean, false).option("--verbose", "Enable verbose output", false).option("--config <string>", `Path to config file (default: "${DEFAULT_CONFIG_FILE}")`).option("--experimental-tailwind", "Generate Tailwind CSS classes for tokens", false).action(async (opts) => {
+    const { verbose, clean, dry, experimentalTailwind } = opts;
     const tokensDir = typeof opts.tokens === "string" ? opts.tokens : DEFAULT_TOKENS_CREATE_DIR;
     const outDir = typeof opts.outDir === "string" ? opts.outDir : "./dist/tokens";
     const { configFile, configPath } = await getConfigFile(opts.config);
@@ -4499,7 +4443,7 @@ function makeTokenCommands() {
     if (clean) {
       await cleanDir(outDir, dry);
     }
-    await buildTokens({ tokensDir, outDir, preview, verbose, dry, tailwind: experimentalTailwind, ...config });
+    await buildTokens({ tokensDir, outDir, verbose, dry, tailwind: experimentalTailwind, ...config });
     return Promise.resolve();
   });
   tokenCmd.command("create").description("Create Designsystemet tokens").option(`-m, --${cliOptions.theme.colors.main} <name:hex...>`, `Main colors`, parseColorValues).option(`-s, --${cliOptions.theme.colors.support} <name:hex...>`, `Support colors`, parseColorValues).option(`-n, --${cliOptions.theme.colors.neutral} <hex>`, `Neutral hex color`, convertToHex).option(
@@ -4563,7 +4507,7 @@ function parseBoolean(value) {
   return value === "true" || value === true;
 }
 async function getConfigFile(config) {
-  const allowFileNotFound = R26.isNil(config) || config === DEFAULT_CONFIG_FILE;
+  const allowFileNotFound = R24.isNil(config) || config === DEFAULT_CONFIG_FILE;
   const configPath = config ?? DEFAULT_CONFIG_FILE;
   const configFile = await readConfigFile(configPath, allowFileNotFound);
   return { configFile, configPath };