@digdir/designsystemet 0.1.0-next.31 → 0.100.51-next.52

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

@@ -0,0 +1,46 @@
+import type { CssColor } from '../colors/types.js';
+export type Token = {
+    $value: string;
+    $type: string;
+};
+export type Tokens1ary = Record<string, Token>;
+export type Tokens2ary = Record<string, Tokens1ary>;
+export type Tokens3ary = Record<string, Record<string, Tokens1ary>>;
+export type TokensSet = Tokens1ary | Tokens2ary | Tokens3ary;
+export type ColorModeTokens = {
+    global: TokensSet;
+    [key: string]: TokensSet;
+};
+export type TypographyTokens = TokensSet;
+export type Tokens = {
+    colors: {
+        light: ColorModeTokens;
+        dark: ColorModeTokens;
+        contrast?: ColorModeTokens;
+    };
+    typography: {
+        primary: TokensSet;
+    };
+};
+export type Colors = {
+    main: Record<string, CssColor>;
+    support: Record<string, CssColor>;
+    neutral: CssColor;
+};
+export type Typography = {
+    fontFamily?: string;
+};
+export type TypographyModes = 'primary' | 'secondary';
+export type File = {
+    data: string;
+    path: string;
+    filePath: string;
+};
+export type Collection = string | 'global';
+export type Theme = {
+    name: string;
+    colors: Colors;
+    typography: Typography;
+    borderRadius: number;
+};
+//# 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":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,MAAM,MAAM,KAAK,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AACtD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAC/C,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AACpD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;AACpE,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,CAAC;AAE7D,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,SAAS,CAAC;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B,CAAC;AAGF,MAAM,MAAM,gBAAgB,GAAG,SAAS,CAAC;AAGzC,MAAM,MAAM,MAAM,GAAG;IACnB,MAAM,EAAE;QACN,KAAK,EAAE,eAAe,CAAC;QACvB,IAAI,EAAE,eAAe,CAAC;QACtB,QAAQ,CAAC,EAAE,eAAe,CAAC;KAC5B,CAAC;IACF,UAAU,EAAE;QACV,OAAO,EAAE,SAAS,CAAC;KACpB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAClC,OAAO,EAAE,QAAQ,CAAC;CACnB,CAAC;AACF,MAAM,MAAM,UAAU,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AACjD,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,WAAW,CAAC;AAEtD,MAAM,MAAM,IAAI,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE3C,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,UAAU,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC"}

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

@@ -0,0 +1,34 @@
+import type { DesignToken, TransformedToken } from 'style-dictionary/types';
+/**
+ * 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: import("ts-toolbelt/out/Function/Curry.js").Curry<(types: string[] | string, token: TransformedToken) => boolean>;
+export declare const pathStartsWithOneOf: import("ts-toolbelt/out/Function/Curry.js").Curry<(paths: string[], token: TransformedToken) => boolean>;
+export declare function isSemanticToken(token: TransformedToken): boolean;
+export declare function isGlobalColorToken(token: TransformedToken): boolean;
+export declare function isColorCategoryToken(token: TransformedToken, category?: 'main' | 'support'): boolean;
+export declare const mkdir: (dir: string, dry?: boolean) => Promise<string | void>;
+export declare const writeFile: (path: string, data: string, dry?: boolean) => Promise<void>;
+export declare const cp: (src: string, dest: string, dry?: boolean) => Promise<void>;
+export declare const copyFile: (src: string, dest: string, dry?: boolean) => Promise<void>;
+export declare const isDigit: (s: string) => boolean;
+export declare const cleanDir: (dir: string, dry?: boolean) => Promise<void>;
+//# 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":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAM5E;;;;GAIG;AACH,eAAO,MAAM,OAAO,UAAW,gBAAgB,WAAkD,CAAC;AAElG;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,gBAAgB,GAAG,WAAW,KAAG,CAAuC,CAAC;AAE5G;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,4DAAmB,MAAM,EAAE,GAAG,MAAM,SAAS,gBAAgB,aAMlF,CAAC;AAEH,eAAO,MAAM,mBAAmB,4DAAmB,MAAM,EAAE,SAAS,gBAAgB,aASlF,CAAC;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAEhE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAEnE;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,gBAAgB,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAKpG;AAED,eAAO,MAAM,KAAK,QAAe,MAAM,QAAQ,OAAO,2BAOrD,CAAC;AAEF,eAAO,MAAM,SAAS,SAAgB,MAAM,QAAQ,MAAM,QAAQ,OAAO,kBAOxE,CAAC;AAEF,eAAO,MAAM,EAAE,QAAe,MAAM,QAAQ,MAAM,QAAQ,OAAO,kBAOhE,CAAC;AAEF,eAAO,MAAM,QAAQ,QAAe,MAAM,QAAQ,MAAM,QAAQ,OAAO,kBAOtE,CAAC;AAEF,eAAO,MAAM,OAAO,MAAO,MAAM,YAAoB,CAAC;AAEtD,eAAO,MAAM,QAAQ,QAAe,MAAM,QAAQ,OAAO,kBASxD,CAAC"}

package/dist/src/tokens/utils.js

@@ -0,0 +1,85 @@
+import fs from "node:fs/promises";
+import chalk from "chalk";
+import * as R from "ramda";
+const mapToLowerCase = R.map(R.toLower);
+const hasAnyTruth = R.any(R.equals(true));
+const getType = (token) => (token.$type ?? token.type) || "";
+const getValue = (token) => token.$value ?? token.value;
+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);
+  const matchPathsStartingWith = R.map((path) => R.startsWith([path], tokenPath), mapToLowerCase(paths));
+  return hasAnyTruth(matchPathsStartingWith);
+});
+function isSemanticToken(token) {
+  return token.filePath.includes("semantic/");
+}
+function isGlobalColorToken(token) {
+  return typeEquals("color", token) && pathStartsWithOneOf(["global"], token);
+}
+function isColorCategoryToken(token, category) {
+  if (!category) {
+    return ["main", "support"].some((c) => isColorCategoryToken(token, c));
+  }
+  return R.startsWith(["color", category], token.path);
+}
+const mkdir = async (dir, dry) => {
+  if (dry) {
+    console.log(`${chalk.blue("mkdir")} ${dir}`);
+    return Promise.resolve();
+  }
+  return await fs.mkdir(dir, { recursive: true });
+};
+const writeFile = async (path, data, dry) => {
+  if (dry) {
+    console.log(`${chalk.blue("writeFile")} ${path}`);
+    return Promise.resolve();
+  }
+  return await fs.writeFile(path, data, { encoding: "utf-8" });
+};
+const cp = async (src, dest, dry) => {
+  if (dry) {
+    console.log(`${chalk.blue("cp")} ${src} ${dest}`);
+    return Promise.resolve();
+  }
+  return await fs.cp(src, dest, { recursive: true });
+};
+const copyFile = async (src, dest, dry) => {
+  if (dry) {
+    console.log(`${chalk.blue("copyFile")} ${src} to ${dest}`);
+    return Promise.resolve();
+  }
+  return await fs.copyFile(src, dest);
+};
+const isDigit = (s) => /^\d+$/.test(s);
+const cleanDir = async (dir, dry) => {
+  if (dry) {
+    console.log(`${chalk.blue("cleanDir")} ${dir}`);
+    return Promise.resolve();
+  }
+  console.log(`${chalk.red(`Cleaning outputDir: ${dir.trim()}`)} `);
+  return await fs.rm(dir, { recursive: true, force: true });
+};
+export {
+  cleanDir,
+  copyFile,
+  cp,
+  getType,
+  getValue,
+  isColorCategoryToken,
+  isDigit,
+  isGlobalColorToken,
+  isSemanticToken,
+  mkdir,
+  pathStartsWithOneOf,
+  typeEquals,
+  writeFile
+};

package/dist/src/tokens/write/generate$metadata.d.ts

@@ -0,0 +1,9 @@
+import type { ColorScheme } from '../../colors/types.js';
+import type { Colors } from '../types.js';
+type ColorSchemes = Array<ColorScheme>;
+type Metadata = {
+    tokenSetOrder: string[];
+};
+export declare function generateMetadataJson(schemes: ColorSchemes, themes: string[], colors: Colors): Metadata;
+export {};
+//# sourceMappingURL=generate$metadata.d.ts.map

package/dist/src/tokens/write/generate$metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate$metadata.d.ts","sourceRoot":"","sources":["../../../../src/tokens/write/generate$metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,KAAK,YAAY,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC;AAEvC,KAAK,QAAQ,GAAG;IACd,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAwBtG"}

package/dist/src/tokens/write/generate$metadata.js

@@ -0,0 +1,28 @@
+function generateMetadataJson(schemes, themes, colors) {
+  return {
+    tokenSetOrder: [
+      "primitives/globals",
+      "primitives/modes/size/small",
+      "primitives/modes/size/medium",
+      "primitives/modes/size/large",
+      "primitives/modes/size/global",
+      "primitives/modes/typography/size/small",
+      "primitives/modes/typography/size/medium",
+      "primitives/modes/typography/size/large",
+      ...themes.map((theme) => `primitives/modes/typography/primary/${theme}`),
+      ...themes.map((theme) => `primitives/modes/typography/secondary/${theme}`),
+      ...schemes.flatMap((scheme) => [
+        `primitives/modes/color-scheme/${scheme}/global`,
+        ...themes.map((theme) => `primitives/modes/color-scheme/${scheme}/${theme}`)
+      ]),
+      ...themes.map((theme) => `themes/${theme}`),
+      "semantic/color",
+      ...Object.entries(colors.main).map(([color]) => `semantic/modes/main-color/${color}`),
+      ...Object.entries(colors.support).map(([color]) => `semantic/modes/support-color/${color}`),
+      "semantic/style"
+    ]
+  };
+}
+export {
+  generateMetadataJson
+};

package/dist/src/tokens/write/generate$themes.d.ts

@@ -0,0 +1,12 @@
+import { type ThemeObject } from '@tokens-studio/types';
+import type { ColorScheme } from '../../colors/types.js';
+import type { Colors } from '../types.js';
+type ColorSchemes = Array<ColorScheme>;
+type ThemeObject_ = ThemeObject & {
+    $figmaCollectionId?: string;
+    $figmaModeId?: string;
+    $figmaVariableReferences?: Record<string, string>;
+};
+export declare function generateThemesJson(colorSchemes: ColorSchemes, themes: string[], colors: Colors): ThemeObject_[];
+export {};
+//# sourceMappingURL=generate$themes.d.ts.map

package/dist/src/tokens/write/generate$themes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate$themes.d.ts","sourceRoot":"","sources":["../../../../src/tokens/write/generate$themes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAkB,MAAM,sBAAsB,CAAC;AAExE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAM1C,KAAK,YAAY,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC;AAEvC,KAAK,YAAY,GAAG,WAAW,GAAG;IAChC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wBAAwB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnD,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,EAAE,CAU/G"}

package/dist/src/tokens/write/generate$themes.js

@@ -0,0 +1,161 @@
+import crypto from "node:crypto";
+import { TokenSetStatus } from "@tokens-studio/types";
+const capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1);
+const createHash = (text) => crypto.hash("sha1", text);
+function generateThemesJson(colorSchemes, themes, colors) {
+  return [
+    ...generateSizeGroup(),
+    ...generateThemesGroup(themes),
+    ...generateTypographyGroup(themes),
+    ...generateColorSchemesGroup(colorSchemes, themes),
+    generateSemanticGroup(),
+    ...generateColorGroup("main", colors),
+    ...generateColorGroup("support", colors)
+  ];
+}
+function generateSizeGroup() {
+  return [
+    {
+      id: "8b2c8cc86611a34b135cb22948666779361fd729",
+      name: "medium",
+      $figmaStyleReferences: {},
+      selectedTokenSets: {
+        "primitives/modes/size/medium": TokenSetStatus.SOURCE,
+        "primitives/modes/size/global": TokenSetStatus.ENABLED,
+        "primitives/modes/typography/size/medium": TokenSetStatus.ENABLED
+      },
+      $figmaCollectionId: "VariableCollectionId:36248:20757",
+      $figmaModeId: "41630:1",
+      group: "Size"
+    },
+    {
+      id: "d49b9eebeb48a4f165a74b7261733d0a73370f0e",
+      name: "large",
+      $figmaStyleReferences: {},
+      selectedTokenSets: {
+        "primitives/modes/size/large": TokenSetStatus.SOURCE,
+        "primitives/modes/size/global": TokenSetStatus.ENABLED,
+        "primitives/modes/typography/size/large": TokenSetStatus.ENABLED
+      },
+      $figmaCollectionId: "VariableCollectionId:36248:20757",
+      $figmaModeId: "41630:2",
+      group: "Size"
+    },
+    {
+      id: "fb11567729c298ca37c9da4e3a27716a23480824",
+      name: "small",
+      $figmaStyleReferences: {},
+      selectedTokenSets: {
+        "primitives/modes/size/small": TokenSetStatus.SOURCE,
+        "primitives/modes/size/global": TokenSetStatus.ENABLED,
+        "primitives/modes/typography/size/small": TokenSetStatus.ENABLED
+      },
+      $figmaCollectionId: "VariableCollectionId:36248:20757",
+      $figmaModeId: "41630:3",
+      group: "Size"
+    }
+  ];
+}
+const colorSchemeDefaults = {
+  light: {
+    name: "Light",
+    selectedTokenSets: {},
+    id: "0daa3ca0b427b9349da7e7dc00101b5668972926",
+    $figmaCollectionId: "VariableCollectionId:34811:5472",
+    $figmaModeId: "34811:0"
+  },
+  dark: {
+    name: "Dark",
+    selectedTokenSets: {},
+    id: "9ebd8aed52afbffc17e2666e8b4653a53498b257",
+    $figmaCollectionId: "VariableCollectionId:34811:5472",
+    $figmaModeId: "34811:1"
+  },
+  contrast: {
+    name: "Contrast",
+    selectedTokenSets: {},
+    id: "9ebd8aed52afbffc17e2666e8b4653a53498b123",
+    $figmaCollectionId: "VariableCollectionId:34811:5472",
+    $figmaModeId: "34811:2"
+  }
+};
+function generateColorSchemesGroup(colorSchemes, themes) {
+  return colorSchemes.map(
+    (scheme) => ({
+      ...colorSchemeDefaults[scheme],
+      selectedTokenSets: Object.fromEntries([
+        [`primitives/modes/color-scheme/${scheme}/global`, TokenSetStatus.ENABLED],
+        ...themes.map((theme) => [`primitives/modes/color-scheme/${scheme}/${theme}`, TokenSetStatus.ENABLED])
+      ]),
+      group: "Color scheme"
+    })
+  );
+}
+function generateThemesGroup(themes) {
+  return themes.map(
+    (theme, index) => ({
+      id: createHash(theme),
+      $figmaCollectionId: "VariableCollectionId:36528:61712",
+      $figmaModeId: `40960:${index + 6}`,
+      // Start on 6 in Token Studio and Community file for some reason
+      name: theme,
+      selectedTokenSets: {
+        [`themes/${theme}`]: TokenSetStatus.ENABLED
+      },
+      group: "Theme"
+    })
+  );
+}
+function generateSemanticGroup() {
+  return {
+    id: "541629445ef90ad5363f9e88f52a1ccb617e6f84",
+    name: "Semantic",
+    selectedTokenSets: {
+      "semantic/style": TokenSetStatus.ENABLED,
+      "semantic/color": TokenSetStatus.ENABLED,
+      "primitives/globals": TokenSetStatus.SOURCE
+    },
+    $figmaCollectionId: "VariableCollectionId:34811:5976",
+    $figmaModeId: "34811:5",
+    group: "Semantic"
+  };
+}
+function generateColorGroup(group, colors) {
+  return Object.entries(colors[group]).map(
+    ([color]) => ({
+      id: createHash(`${group}-${color}`),
+      name: color,
+      selectedTokenSets: {
+        [`semantic/modes/${group}-color/${color}`]: TokenSetStatus.ENABLED
+      },
+      group: `${capitalize(group)} color`
+    })
+  );
+}
+function generateTypographyGroup(themes) {
+  return [
+    {
+      id: "368d753fcac4455f289500eaa42e70dc0a03522f",
+      $figmaCollectionId: "VariableCollectionId:36248:20769",
+      $figmaModeId: "36248:2",
+      name: "Primary",
+      selectedTokenSets: Object.fromEntries(
+        themes.map((theme) => [`primitives/modes/typography/primary/${theme}`, TokenSetStatus.ENABLED])
+      ),
+      group: "Typography"
+    },
+    {
+      id: "264b8bd1d40b364e1ea3acf09e49795ddd4c513c",
+      $figmaCollectionId: "VariableCollectionId:36248:20769",
+      $figmaModeId: "36248:3",
+      name: "Secondary",
+      selectedTokenSets: Object.fromEntries(
+        themes.map((theme) => [`primitives/modes/typography/secondary/${theme}`, TokenSetStatus.ENABLED])
+      ),
+      group: "Typography"
+    }
+  ];
+}
+export {
+  generateThemesJson
+};

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

@@ -0,0 +1,12 @@
+import type { Theme, Tokens } from './types.js';
+export declare const stringify: (data: unknown) => string;
+type WriteTokensOptions = {
+    outDir: string;
+    tokens: Tokens;
+    theme: Theme;
+    /** Dry run, no files will be written */
+    dry?: boolean;
+};
+export declare const writeTokens: (options: WriteTokensOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=write.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../../src/tokens/write.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAoB,KAAK,EAAE,MAAM,EAA8B,MAAM,YAAY,CAAC;AAS9F,eAAO,MAAM,SAAS,SAAU,OAAO,WAAkC,CAAC;AAyB1E,KAAK,kBAAkB,GAAG;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;IACb,wCAAwC;IACxC,GAAG,CAAC,EAAE,OAAO,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,WAAW,YAAmB,kBAAkB,kBA4K5D,CAAC"}

package/dist/src/tokens/write.js

@@ -0,0 +1,176 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import chalk from "chalk";
+import * as R from "ramda";
+import semanticColorBaseFile from "./design-tokens/template/semantic/color-base-file.json" with { type: "json" };
+import customColorTemplate from "./design-tokens/template/semantic/modes/category-color/category-color-template.json" with { type: "json" };
+import semanticColorTemplate from "./design-tokens/template/semantic/semantic-color-template.json" with { type: "json" };
+import themeBaseFile from "./design-tokens/template/themes/theme-base-file.json" with { type: "json" };
+import themeColorTemplate from "./design-tokens/template/themes/theme-color-template.json" with { type: "json" };
+import { cp, mkdir, writeFile } from "./utils.js";
+import { generateMetadataJson } from "./write/generate$metadata.js";
+import { generateThemesJson } from "./write/generate$themes.js";
+const DIRNAME = import.meta.dirname || __dirname;
+const DEFAULT_FILES_PATH = path.join(DIRNAME, "./design-tokens/default");
+const TEMPLATE_FILES_PATH = path.join(DIRNAME, "./design-tokens/template/");
+const stringify = (data) => JSON.stringify(data, null, 2);
+const generateColorSchemeFile = (scheme, name, tokens, outPath) => {
+  const path2 = `${outPath}/primitives/modes/color-scheme/${scheme}`;
+  return {
+    data: stringify(tokens),
+    path: path2,
+    filePath: `${path2}/${name}.json`
+  };
+};
+const generateTypographyFile = (folder, name, tokens, outPath) => {
+  const path2 = `${outPath}/primitives/modes/typography/${folder}`;
+  return {
+    data: stringify(tokens),
+    path: path2,
+    filePath: `${path2}/${name}.json`
+  };
+};
+const writeTokens = async (options) => {
+  const {
+    outDir,
+    tokens,
+    theme: { name: themeName, colors, borderRadius },
+    dry
+  } = options;
+  const targetDir = path.resolve(process.cwd(), String(outDir));
+  const $themesPath = path.join(targetDir, "$themes.json");
+  const $metadataPath = path.join(targetDir, "$metadata.json");
+  let themes = [themeName];
+  await mkdir(targetDir, dry);
+  try {
+    const $themes = await fs.readFile($themesPath, "utf-8");
+    const themeObjects = JSON.parse($themes) || [];
+    themes = R.pipe(
+      R.filter((obj) => R.toLower(obj.group || "") === "theme"),
+      R.map(R.prop("name")),
+      R.append(themeName),
+      R.uniq
+    )(themeObjects);
+  } catch (error) {
+  }
+  console.log(`Themes: ${chalk.blue(themes.join(", "))}`);
+  const $theme = generateThemesJson(["dark", "light"], themes, colors);
+  const $metadata = generateMetadataJson(["dark", "light"], themes, colors);
+  await writeFile($themesPath, stringify($theme), dry);
+  await writeFile($metadataPath, stringify($metadata), dry);
+  await cp(DEFAULT_FILES_PATH, targetDir, dry);
+  const mainColorNames = Object.keys(colors.main);
+  const supportColorNames = Object.keys(colors.support);
+  const customColors = [...mainColorNames, "neutral", ...supportColorNames];
+  const defaultAccentColor = mainColorNames[0];
+  for (const [colorCategory, colorNames] of [
+    ["main", mainColorNames],
+    ["support", supportColorNames]
+  ]) {
+    const colorCategoryPath = path.join(targetDir, "semantic", "modes", `${colorCategory}-color`);
+    await mkdir(colorCategoryPath, dry);
+    for (const colorName of colorNames) {
+      const customColorFile = {
+        color: {
+          [colorCategory]: customColorTemplate
+        }
+      };
+      await writeFile(
+        path.join(colorCategoryPath, `${colorName}.json`),
+        JSON.stringify(
+          customColorFile,
+          (key, value) => {
+            if (key === "$value") {
+              return value.replace("<color>", colorName);
+            }
+            return value;
+          },
+          2
+        ),
+        dry
+      );
+    }
+  }
+  const semanticColorTokens = customColors.map(
+    (colorName) => [
+      colorName,
+      R.map((x) => ({ ...x, $value: x.$value.replace("<color>", colorName) }), semanticColorTemplate)
+    ]
+  );
+  const semanticColors = {
+    color: {
+      ...Object.fromEntries(semanticColorTokens),
+      ...semanticColorBaseFile.color
+    }
+  };
+  await writeFile(
+    path.join(targetDir, `semantic/color.json`),
+    JSON.stringify(
+      semanticColors,
+      (key, value) => {
+        if (key === "$value") {
+          return value.replace("<accent-color>", defaultAccentColor);
+        }
+        return value;
+      },
+      2
+    ),
+    dry
+  );
+  await mkdir(path.join(targetDir, "themes"), dry);
+  const themeColorTokens = Object.fromEntries(
+    customColors.map(
+      (colorName) => [
+        colorName,
+        R.map((x) => ({ ...x, $value: x.$value.replace("<color>", colorName) }), themeColorTemplate)
+      ]
+    )
+  );
+  const { color: themeBaseFileColor, ...remainingThemeFile } = themeBaseFile;
+  const themeFile = {
+    color: {
+      ...themeColorTokens,
+      ...themeBaseFileColor
+    },
+    ...remainingThemeFile
+  };
+  const baseBorderRadius = R.lensPath(["border-radius", "base", "$value"]);
+  const updatedThemeFile = R.set(baseBorderRadius, String(borderRadius), themeFile);
+  await writeFile(
+    path.join(targetDir, `themes/${themeName}.json`),
+    JSON.stringify(
+      updatedThemeFile,
+      (key, value) => {
+        if (key === "$value") {
+          return value.replace("<theme>", themeName);
+        }
+        return value;
+      },
+      2
+    ),
+    dry
+  );
+  const files = [
+    generateColorSchemeFile("light", themeName, tokens.colors.light[themeName], targetDir),
+    generateColorSchemeFile("light", "global", tokens.colors.light.global, targetDir),
+    generateColorSchemeFile("dark", themeName, tokens.colors.dark[themeName], targetDir),
+    generateColorSchemeFile("dark", "global", tokens.colors.dark.global, targetDir),
+    // generateColorSchemeFile('contrast', themeName, tokens.colors.contrast[themeName], targetDir),
+    // generateColorSchemeFile('contrast', 'global', tokens.colors.contrast.global, targetDir),
+    generateTypographyFile("primary", themeName, tokens.typography.primary, targetDir),
+    generateTypographyFile("secondary", themeName, tokens.typography.primary, targetDir)
+  ];
+  for (const file of files) {
+    const dirPath = path.resolve(file.path);
+    const filePath = path.resolve(file.filePath);
+    await mkdir(dirPath, dry);
+    await writeFile(filePath, file.data, dry);
+  }
+  console.log(
+    `Finished creating Designsystem design tokens in ${chalk.green(outDir)} for theme ${chalk.blue(themeName)}`
+  );
+};
+export {
+  stringify,
+  writeTokens
+};