@digdir/designsystemet 1.12.1 → 1.13.0

package/dist/bin/designsystemet.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 // bin/designsystemet.ts
+import path5 from "path";
 import { Argument, createCommand, program } from "@commander-js/extra-typings";
 import pc12 from "picocolors";
 import * as R29 from "ramda";
@@ -415,58 +416,133 @@ var cssVarRename = (dictionary) => ({
 });
 
 // src/migrations/codemods/css/run.ts
-import fs2 from "fs";
 import glob from "fast-glob";
 import postcss from "postcss";
 
-// src/utils.ts
+// src/utils/filesystem.ts
 import fs from "fs/promises";
+import path from "path";
 import pc2 from "picocolors";
-var mkdir = async (dir, dry) => {
-  if (dry) {
-    console.log(`${pc2.blue("mkdir")} ${dir}`);
-    return Promise.resolve();
-  }
-  const exists = await fs.access(dir, fs.constants.F_OK).then(() => true).catch(() => false);
-  if (exists) {
-    return Promise.resolve();
-  }
-  return fs.mkdir(dir, { recursive: true });
-};
-var writeFile = async (path6, data, dry) => {
-  if (dry) {
-    console.log(`${pc2.blue("writeFile")} ${path6}`);
-    return Promise.resolve();
-  }
-  return fs.writeFile(path6, data, { encoding: "utf-8" }).catch((error) => {
-    console.error(pc2.red(`Error writing file: ${path6}`));
-    console.error(pc2.red(error));
-    throw error;
-  });
-};
-var cleanDir = async (dir, dry) => {
-  if (dry) {
-    console.log(`${pc2.blue("cleanDir")} ${dir}`);
-    return Promise.resolve();
+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(pc2.yellow("FileSystem is already initialized. Ignoring subsequent init call."));
+      return;
+    }
+    if (dry) {
+      console.log(pc2.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: ${pc2.green(this.workingDir)}, outDir: ${pc2.green(this.outDir)}`
+      );
+    }
+    this.isInitialized = true;
   }
-  console.log(`
+  /**
+   * 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(`${pc2.blue("mkdir")} ${dir}`);
+      return Promise.resolve();
+    }
+    const exists = await fs.access(dir, fs.constants.F_OK).then(() => true).catch(() => false);
+    if (exists) {
+      return Promise.resolve();
+    }
+    return fs.mkdir(dir, { recursive: true });
+  };
+  writeFile = async (path6, data) => {
+    if (this.dry) {
+      console.log(`${pc2.blue("writeFile")} ${path6}`);
+      return Promise.resolve();
+    }
+    return fs.writeFile(path6, data, { encoding: "utf-8" }).catch((error) => {
+      console.error(pc2.red(`Error writing file: ${path6}`));
+      console.error(pc2.red(error));
+      throw error;
+    });
+  };
+  cp = async (src, dest, filter2) => {
+    if (this.dry) {
+      console.log(`${pc2.blue("cp")} ${src} ${dest}`);
+      return Promise.resolve();
+    }
+    return fs.cp(src, dest, { recursive: true, filter: filter2 });
+  };
+  copyFile = async (src, dest) => {
+    if (this.dry) {
+      console.log(`${pc2.blue("copyFile")} ${src} to ${dest}`);
+      return Promise.resolve();
+    }
+    return fs.copyFile(src, dest);
+  };
+  cleanDir = async (dir) => {
+    if (this.dry) {
+      console.log(`${pc2.blue("cleanDir")} ${dir}`);
+      return Promise.resolve();
+    }
+    console.log(`
 \u{1F525} Cleaning dir ${pc2.red(`${dir.trim()}`)} `);
-  return fs.rm(dir, { recursive: true, force: true });
-};
-var readFile = async (path6, dry, allowFileNotFound) => {
-  if (dry) {
-    console.log(`${pc2.blue("readFile")} ${path6}`);
-    return Promise.resolve("");
-  }
-  try {
-    return await fs.readFile(path6, "utf-8");
-  } catch (error) {
-    if (allowFileNotFound && error.code === "ENOENT") {
-      return "";
+    return fs.rm(dir, { recursive: true, force: true });
+  };
+  readFile = async (path6, allowFileNotFound) => {
+    if (this.dry) {
+      console.log(`${pc2.blue("readFile")} ${path6}`);
     }
-    throw error;
-  }
+    try {
+      return await fs.readFile(path6, "utf-8");
+    } catch (error) {
+      if (allowFileNotFound && error.code === "ENOENT") {
+        return "";
+      }
+      throw error;
+    }
+  };
+  readdir = async (path6) => {
+    if (this.dry) {
+      console.log(`${pc2.blue("readdir")} ${path6}`);
+    }
+    try {
+      return await fs.readdir(path6);
+    } 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);
+      }
+    }
+  };
 };
+var dsfs = new FileSystem();
 
 // src/migrations/codemods/css/run.ts
 var runCssCodemod = async ({ plugins = [], globPattern = "./**/*.css" }) => {
@@ -482,9 +558,9 @@ var runCssCodemod = async ({ plugins = [], globPattern = "./**/*.css" }) => {
       if (file.includes("node_modules") || file.includes("dist")) {
         return;
       }
-      const contents = readFile(file).toString();
-      const result = await processor.process(contents, { from: file });
-      fs2.writeFileSync(file, result.css);
+      const contents = await dsfs.readFile(file);
+      const result = await processor.process(contents.toString(), { from: file });
+      await dsfs.writeFile(file, result.css);
     });
     await Promise.all(filePromises);
   };
@@ -874,7 +950,6 @@ var migrations_default = {
 };
 
 // src/tokens/build.ts
-import path from "path";
 import pc7 from "picocolors";
 import * as R22 from "ramda";
 
@@ -884,11 +959,11 @@ import pc5 from "picocolors";
 // package.json
 var package_default = {
   name: "@digdir/designsystemet",
-  version: "1.12.1",
+  version: "1.13.0",
   description: "CLI for Designsystemet",
   author: "Designsystemet team",
   engines: {
-    node: ">=20 <25"
+    node: ">=20.20.1"
   },
   repository: {
     type: "git",
@@ -952,16 +1027,16 @@ var package_default = {
     hsluv: "^1.0.1",
     "object-hash": "^3.0.0",
     picocolors: "^1.1.1",
-    postcss: "^8.5.6",
+    postcss: "^8.5.8",
     ramda: "^0.32.0",
-    "style-dictionary": "^5.3.0",
+    "style-dictionary": "^5.3.3",
     zod: "^4.3.6",
     "zod-validation-error": "^5.0.0"
   },
   devDependencies: {
     "@tokens-studio/types": "0.5.2",
     "@types/chroma-js": "^3.1.2",
-    "@types/node": "^24.10.13",
+    "@types/node": "^24.12.0",
     "@types/object-hash": "^3.0.6",
     "@types/ramda": "^0.31.1",
     tsup: "^8.5.1",
@@ -2530,25 +2605,13 @@ ${fileHeader}
 };
 
 // src/tokens/build.ts
-async function write(files, outDir, dry) {
-  for (const { destination, output } of files) {
-    if (destination) {
-      const filePath = path.join(outDir, destination);
-      const fileDir = path.dirname(filePath);
-      console.log(destination);
-      await mkdir(fileDir, dry);
-      await writeFile(filePath, output, dry);
-    }
-  }
-}
 var buildTokens = async (options) => {
-  const outDir = path.resolve(options.outDir);
-  const tokensDir = path.resolve(options.tokensDir);
-  const $themes = JSON.parse(await readFile(`${tokensDir}/$themes.json`));
+  const tokensDir = options.tokensDir;
+  const $themes = JSON.parse(await dsfs.readFile(`${tokensDir}/$themes.json`));
   const processed$themes = $themes.map(processThemeObject);
   let $designsystemet;
   try {
-    const $designsystemetContent = await readFile(`${tokensDir}/$designsystemet.jsonc`);
+    const $designsystemetContent = await dsfs.readFile(`${tokensDir}/$designsystemet.jsonc`);
     $designsystemet = JSON.parse($designsystemetContent);
   } catch (_error) {
   }
@@ -2556,7 +2619,6 @@ var buildTokens = async (options) => {
 \u{1F3D7}\uFE0F Start building tokens in ${pc7.green(tokensDir)}`);
   const processedBuilds = await processPlatform({
     ...options,
-    outDir,
     tokensDir,
     type: "build",
     processed$themes,
@@ -2575,15 +2637,10 @@ design-tokens: v${$designsystemet.version}` : ""
     const tailwindFiles = createTailwindCSSFiles(cssFiles);
     files = files.concat(tailwindFiles.filter(Boolean));
   }
-  console.log(`
-\u{1F4BE} Writing build to ${pc7.green(outDir)}`);
-  await write(files, outDir, options.dry);
-  console.log(`
-\u2705 Finished building tokens!`);
-  return processedBuilds;
+  return files;
 };
 
-// src/tokens/create/write.ts
+// src/tokens/create/files.ts
 import path2 from "path";
 import pc8 from "picocolors";
 import * as R23 from "ramda";
@@ -2783,24 +2840,22 @@ function generateTypographyGroup(themes) {
   ];
 }
 
-// src/tokens/create/write.ts
+// src/tokens/create/files.ts
 var stringify = (data) => JSON.stringify(data, null, 2);
-var writeTokens = async (options) => {
+var createTokenFiles = async (options) => {
   const {
     outDir,
     tokenSets,
-    theme: { name: themeName, colors: colors2 },
-    dry
+    theme: { name: themeName, colors: colors2 }
   } = options;
-  const targetDir = path2.resolve(process.cwd(), String(outDir));
-  const $themesPath = path2.join(targetDir, "$themes.json");
-  const $metadataPath = path2.join(targetDir, "$metadata.json");
-  const $designsystemetPath = path2.join(targetDir, "$designsystemet.jsonc");
+  const $themesPath = "$themes.json";
+  const $metadataPath = "$metadata.json";
+  const $designsystemetPath = "$designsystemet.jsonc";
   let themeObjects = [];
   const sizeModes2 = ["small", "medium", "large"];
-  await mkdir(targetDir, dry);
+  await dsfs.mkdir(outDir);
   try {
-    const $themes2 = await readFile($themesPath);
+    const $themes2 = await dsfs.readFile(path2.join(outDir, $themesPath));
     if ($themes2) {
       themeObjects = JSON.parse($themes2);
     }
@@ -2819,16 +2874,15 @@ Themes: ${pc8.blue(themes.join(", "))}`);
   const $themes = await generate$Themes(["dark", "light"], themes, colors2, sizeModes2);
   const $metadata = generate$Metadata(["dark", "light"], themes, colors2, sizeModes2);
   const $designsystemet = generate$Designsystemet();
-  await writeFile($themesPath, stringify($themes), dry);
-  await writeFile($metadataPath, stringify($metadata), dry);
-  await writeFile($designsystemetPath, stringify($designsystemet), dry);
+  const files = [];
+  files.push({ destination: $themesPath, output: stringify($themes) });
+  files.push({ destination: $metadataPath, output: stringify($metadata) });
+  files.push({ destination: $designsystemetPath, output: stringify($designsystemet) });
   for (const [set4, tokens] of tokenSets) {
-    const fileDir = path2.join(targetDir, path2.dirname(set4));
-    await mkdir(fileDir, dry);
-    const filePath = path2.join(targetDir, `${set4}.json`);
-    await writeFile(filePath, stringify(tokens), dry);
+    const filePath = `${set4}.json`;
+    files.push({ destination: filePath, output: stringify(tokens) });
   }
-  console.log(`Finished creating Designsystem design tokens in ${pc8.green(outDir)} for theme ${pc8.blue(themeName)}`);
+  return files;
 };
 
 // src/tokens/create/generators/primitives/color-scheme.ts
@@ -4062,12 +4116,11 @@ var createTokens = async (theme) => {
 };
 
 // src/tokens/generate-config.ts
-import fs3 from "fs/promises";
 import path3 from "path";
 import pc9 from "picocolors";
 async function readJsonFile(filePath) {
   try {
-    const content = await fs3.readFile(filePath, "utf-8");
+    const content = await dsfs.readFile(filePath);
     return JSON.parse(content);
   } catch (err) {
     throw new Error(`Failed to read token file at ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
@@ -4085,7 +4138,7 @@ function extractBaseColor(colorScale) {
 async function discoverThemes(tokensDir) {
   const lightModePath = path3.join(tokensDir, "themes");
   try {
-    const files = await fs3.readdir(lightModePath);
+    const files = await dsfs.readdir(lightModePath);
     const themes = files.filter((file) => file.endsWith(".json")).map((file) => file.replace(".json", ""));
     return themes;
   } catch {
@@ -4191,7 +4244,7 @@ function categorizeColors(themeTokens, themeName) {
   return { main, support, neutral };
 }
 async function generateConfigFromTokens(options) {
-  const { tokensDir, dry = false } = options;
+  const { tokensDir } = options;
   console.log(`
 Reading tokens from ${pc9.blue(tokensDir)}`);
   const themes = await discoverThemes(tokensDir);
@@ -4251,18 +4304,10 @@ Warning: No neutral color found for theme ${themeName}`));
 \u2705 Font family: ${pc9.cyan(fontFamily)}`);
     }
   }
-  if (!dry && options.outFile) {
-    const configJson = JSON.stringify(config, null, 2);
-    await fs3.writeFile(options.outFile, configJson, "utf-8");
-    console.log();
-    console.log(`
-\u2705 Config file written to ${pc9.blue(options.outFile)}`);
-  }
   return config;
 }
 
 // bin/config.ts
-import path5 from "path";
 import pc11 from "picocolors";
 import * as R28 from "ramda";
 
@@ -4296,24 +4341,24 @@ function makeFriendlyError(err) {
     console.error(err instanceof Error ? err.stack : "No stack trace available");
   }
 }
-function validateConfig(schema, unvalidatedConfig, configPath) {
+function validateConfig(schema, unvalidatedConfig, configFilePath) {
   try {
     return schema.parse(unvalidatedConfig);
   } catch (err) {
-    console.error(pc10.redBright(`Invalid config file at ${pc10.red(configPath)}`));
+    console.error(pc10.redBright(`Invalid config file at ${pc10.red(configFilePath)}`));
     const validationError = makeFriendlyError(err);
     console.error(validationError?.toString());
     process.exit(1);
   }
 }
-function parseConfig(configFile, configPath) {
+function parseConfig(configFile, configFilePath) {
   if (!configFile) {
     return {};
   }
   try {
     return JSON.parse(configFile);
   } catch (err) {
-    console.error(pc10.redBright(`Failed parsing config file at ${pc10.red(configPath)}`));
+    console.error(pc10.redBright(`Failed parsing config file at ${pc10.red(configFilePath)}`));
     const validationError = makeFriendlyError(err);
     console.error(validationError?.toString());
     process.exit(1);
@@ -4404,26 +4449,25 @@ var getDefaultCliOption = getOptionIfMatchingSource("default");
 var getCliOption = getOptionIfMatchingSource("cli", "default");
 
 // bin/config.ts
-async function readConfigFile(configPath, allowFileNotFound = true) {
-  const resolvedPath = path5.resolve(process.cwd(), configPath);
+async function readConfigFile(configFilePath, allowFileNotFound = true) {
   let configFile;
   try {
-    configFile = await readFile(resolvedPath, false, allowFileNotFound);
+    configFile = await dsfs.readFile(configFilePath, allowFileNotFound);
   } catch (err) {
     if (allowFileNotFound) {
       return "";
     }
-    console.error(pc11.redBright(`Could not read config file at ${pc11.blue(resolvedPath)}`));
+    console.error(pc11.redBright(`Could not read config file at ${pc11.blue(configFilePath)}`));
     throw err;
   }
   if (configFile) {
-    console.log(`Found config file: ${pc11.green(resolvedPath)}`);
+    console.log(`Found config file: ${pc11.green(configFilePath)}`);
   }
   return configFile;
 }
 async function parseCreateConfig(configFile, options) {
-  const { cmd, theme = "theme", configPath } = options;
-  const configParsed = parseConfig(configFile, configPath);
+  const { cmd, theme = "theme", configFilePath } = options;
+  const configParsed = parseConfig(configFile, configFilePath);
   const themeColors = Object.values(configParsed?.themes ?? {}).map(
     (x) => /* @__PURE__ */ new Set([...R28.keys(x.colors.main), ...R28.keys(x.colors.support)])
   );
@@ -4466,11 +4510,7 @@ async function parseCreateConfig(configFile, options) {
       }
     )
   });
-  return validateConfig(configFileCreateSchema, unvalidatedConfig, configPath);
-}
-async function parseBuildConfig(configFile, { configPath }) {
-  const configParsed = parseConfig(configFile, configPath);
-  return validateConfig(commonConfig, configParsed, configPath);
+  return validateConfig(configFileCreateSchema, unvalidatedConfig, configFilePath);
 }
 
 // bin/designsystemet.ts
@@ -4489,27 +4529,31 @@ var DEFAULT_TOKENS_CREATE_DIR = "./design-tokens";
 var DEFAULT_TOKENS_BUILD_DIR = "./design-tokens-build";
 var DEFAULT_FONT = "Inter";
 var DEFAULT_THEME_NAME = "theme";
-var DEFAULT_CONFIG_FILE = "designsystemet.config.json";
+var DEFAULT_CONFIG_FILEPATH = "designsystemet.config.json";
 function makeTokenCommands() {
   const tokenCmd = createCommand("tokens");
   tokenCmd.command("build").description("Build Designsystemet tokens").option("-t, --tokens <string>", `Path to ${pc12.blue("design-tokens")}`, DEFAULT_TOKENS_CREATE_DIR).option(
     "-o, --out-dir <string>",
     `Output directory for built ${pc12.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 ${pc12.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) => {
+  ).option(`--${cliOptions.clean} [boolean]`, "Clean output directory before building tokens", parseBoolean, false).option("--dry [boolean]", `Dry run for built ${pc12.blue("design-tokens")}`, parseBoolean, false).option("--verbose", "Enable verbose output", false).option("--config <string>", `Path to config file (default: "${DEFAULT_CONFIG_FILEPATH}")`).option("--experimental-tailwind", "Generate Tailwind CSS classes for tokens", false).action(async (opts) => {
     console.log(figletAscii);
-    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);
-    const config = await parseBuildConfig(configFile, { configPath });
-    if (dry) {
-      console.log(`Performing dry run, no files will be written`);
-    }
+    const { verbose, clean, dry, experimentalTailwind, tokens } = opts;
+    dsfs.init({ dry, outdir: opts.outDir, verbose });
+    const outDir = dsfs.outDir;
     if (clean) {
-      await cleanDir(outDir, dry);
+      await dsfs.cleanDir(outDir);
     }
-    await buildTokens({ tokensDir, outDir, verbose, dry, tailwind: experimentalTailwind, ...config });
+    const files = await buildTokens({
+      tokensDir: tokens,
+      verbose,
+      tailwind: experimentalTailwind
+    });
+    console.log(`
+\u{1F4BE} Writing build to ${pc12.green(outDir)}`);
+    await dsfs.writeFiles(files, outDir, true);
+    console.log(`
+\u2705 Finished building tokens in ${pc12.green(outDir)}`);
     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(
@@ -4521,47 +4565,62 @@ function makeTokenCommands() {
     `Unitless base border-radius in px`,
     (radiusAsString) => Number(radiusAsString),
     4
-  ).option("--theme <string>", "Theme name (ignored when using JSON config file)", DEFAULT_THEME_NAME).option("--config <string>", `Path to config file (default: "${DEFAULT_CONFIG_FILE}")`).action(async (opts, cmd) => {
+  ).option("--theme <string>", "Theme name (ignored when using JSON config file)", DEFAULT_THEME_NAME).option("--config <string>", `Path to config file (default: "${DEFAULT_CONFIG_FILEPATH}")`).action(async (opts, cmd) => {
     console.log(figletAscii);
     if (opts.dry) {
       console.log(`Performing dry run, no files will be written`);
     }
-    const { configFile, configPath } = await getConfigFile(opts.config);
+    const themeName = opts.theme;
+    const { configFile, configFilePath } = await getConfigFile(opts.config);
     const config = await parseCreateConfig(configFile, {
-      theme: opts.theme,
+      theme: themeName,
       cmd,
-      configPath
+      configFilePath
     });
+    dsfs.init({ dry: opts.dry, outdir: config.outDir });
+    const outDir = dsfs.outDir;
     if (config.clean) {
-      await cleanDir(config.outDir, opts.dry);
+      await dsfs.cleanDir(outDir);
     }
+    let files = [];
     if (config.themes) {
       for (const [name, themeWithoutName] of Object.entries(config.themes)) {
         const theme = { name, ...themeWithoutName };
         const { tokenSets } = await createTokens(theme);
-        await writeTokens({ outDir: config.outDir, theme, dry: opts.dry, tokenSets });
+        files = files.concat(await createTokenFiles({ outDir, theme, tokenSets }));
       }
     }
+    await dsfs.writeFiles(files, outDir);
+    console.log(`
+\u2705 Finished creating tokens in ${pc12.green(outDir)} for theme: ${pc12.blue(themeName)}`);
+    return Promise.resolve();
   });
   return tokenCmd;
 }
 program.addCommand(makeTokenCommands());
-program.command("generate-config-from-tokens").description("Generate a config file from existing design tokens. Will not include overrides.").option("-d, --dir <string>", "Path to design tokens directory", DEFAULT_TOKENS_CREATE_DIR).option("-o, --out <string>", "Output path for config file", DEFAULT_CONFIG_FILE).option("--dry [boolean]", "Dry run - show config without writing file", parseBoolean, false).action(async (opts) => {
+program.command("generate-config-from-tokens").description("Generate a config file from existing design tokens. Will not include overrides.").option("-d, --dir <string>", "Path to design tokens directory", DEFAULT_TOKENS_CREATE_DIR).option("-o, --out <string>", "Output path for config file", DEFAULT_CONFIG_FILEPATH).option("--dry [boolean]", "Dry run - show config without writing file", parseBoolean, false).action(async (opts) => {
   console.log(figletAscii);
   const { dry } = opts;
-  const tokensDir = typeof opts.dir === "string" ? opts.dir : DEFAULT_TOKENS_CREATE_DIR;
-  const outFile = typeof opts.out === "string" ? opts.out : DEFAULT_CONFIG_FILE;
+  const tokensDir = path5.resolve(opts.dir);
+  const configFilePath = path5.resolve(opts.out);
+  dsfs.init({ dry, outdir: path5.dirname(configFilePath) });
   try {
     const config = await generateConfigFromTokens({
       tokensDir,
-      outFile: dry ? void 0 : outFile,
-      dry
+      outFile: configFilePath
     });
     if (dry) {
       console.log();
       console.log("Generated config (dry run):");
       console.log(JSON.stringify(config, null, 2));
     }
+    if (configFilePath) {
+      const configJson = JSON.stringify(config, null, 2);
+      await dsfs.writeFile(configFilePath, configJson);
+      console.log();
+      console.log(`
+\u2705 Config file written to ${pc12.blue(configFilePath)}`);
+    }
   } catch (error) {
     console.error(pc12.redBright("Error generating config:"));
     console.error(error instanceof Error ? error.message : String(error));
@@ -4596,11 +4655,11 @@ function parseColorValues(value, previous = {}) {
 function parseBoolean(value) {
   return value === "true" || value === true;
 }
-async function getConfigFile(config) {
-  const allowFileNotFound = R29.isNil(config) || config === DEFAULT_CONFIG_FILE;
-  const configPath = config ?? DEFAULT_CONFIG_FILE;
-  const configFile = await readConfigFile(configPath, allowFileNotFound);
-  return { configFile, configPath };
+async function getConfigFile(userConfigFilePath) {
+  const allowFileNotFound = R29.isNil(userConfigFilePath) || userConfigFilePath === DEFAULT_CONFIG_FILEPATH;
+  const configFilePath = userConfigFilePath ?? DEFAULT_CONFIG_FILEPATH;
+  const configFile = await readConfigFile(configFilePath, allowFileNotFound);
+  return { configFile, configFilePath };
 }
 export {
   figletAscii

package/dist/src/config.d.ts

@@ -8,8 +8,8 @@ import { z } from 'zod';
  * @returns The validated configuration object, typed as T.
  * @throws Exits the process with code 1 if validation fails, after logging a friendly error message.
  */
-export declare function validateConfig<T>(schema: z.ZodType<T>, unvalidatedConfig: Record<string, unknown>, configPath: string): T;
-export declare function parseConfig<T>(configFile: string, configPath: string): T;
+export declare function validateConfig<T>(schema: z.ZodType<T>, unvalidatedConfig: Record<string, unknown>, configFilePath: string): T;
+export declare function parseConfig<T>(configFile: string, configFilePath: string): T;
 export declare const colorRegex: RegExp;
 declare const overridesSchema: z.ZodOptional<z.ZodObject<{
     colors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodEnum<{

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

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuCxB;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EACpB,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1C,UAAU,EAAE,MAAM,GACjB,CAAC,CAUH;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,CAAC,CAexE;AAWD,eAAO,MAAM,UAAU,QAA2C,CAAC;AAuEnE,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQR,CAAC;AAEd,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBmG,CAAC;AAErH,eAAO,MAAM,YAAY;;iBAEvB,CAAC;AAYH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAqD,CAAC;AACzF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAC9D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAC7D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACxE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAC5D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuCxB;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EACpB,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1C,cAAc,EAAE,MAAM,GACrB,CAAC,CAUH;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,CAAC,CAe5E;AAWD,eAAO,MAAM,UAAU,QAA2C,CAAC;AAuEnE,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQR,CAAC;AAEd,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBmG,CAAC;AAErH,eAAO,MAAM,YAAY;;iBAEvB,CAAC;AAYH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAqD,CAAC;AACzF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAC9D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAC7D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACxE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAC5D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/src/config.js

@@ -355,24 +355,24 @@ function makeFriendlyError(err) {
     console.error(err instanceof Error ? err.stack : "No stack trace available");
   }
 }
-function validateConfig(schema, unvalidatedConfig, configPath) {
+function validateConfig(schema, unvalidatedConfig, configFilePath) {
   try {
     return schema.parse(unvalidatedConfig);
   } catch (err) {
-    console.error(pc.redBright(`Invalid config file at ${pc.red(configPath)}`));
+    console.error(pc.redBright(`Invalid config file at ${pc.red(configFilePath)}`));
     const validationError = makeFriendlyError(err);
     console.error(validationError?.toString());
     process.exit(1);
   }
 }
-function parseConfig(configFile, configPath) {
+function parseConfig(configFile, configFilePath) {
   if (!configFile) {
     return {};
   }
   try {
     return JSON.parse(configFile);
   } catch (err) {
-    console.error(pc.redBright(`Failed parsing config file at ${pc.red(configPath)}`));
+    console.error(pc.redBright(`Failed parsing config file at ${pc.red(configFilePath)}`));
     const validationError = makeFriendlyError(err);
     console.error(validationError?.toString());
     process.exit(1);