figma-token 0.1.0 → 0.1.2

package/README.md

@@ -1,6 +1,6 @@
 # figma-token
 
-`figma-token` exports Figma Variables to design token files.
+`figma-token` applies a Figma Plugin `tokens.json` export to a project directory.
 
 ## Install
 
@@ -8,33 +8,45 @@
 npm install --global figma-token
 ```
 
-## Help
+The Figma Plugin can download all six formats directly. Use this CLI when a project needs those files written to a predictable folder and checked for changes.
+
+## Apply Plugin Tokens
 
 ```bash
-figma-token --help
-figma-token sync --help
+figma-token ./figma-tokens.json
 ```
 
-## Basic usage
+This creates the following files in `./figma-token-output/`:
+
+```text
+tokens.json
+theme.ts
+variables.css
+tokens.scss
+tailwind.css
+tokens.dtcg.json
+```
 
-Export a local Figma Variables JSON file:
+Choose a project directory with `--out`:
 
 ```bash
-figma-token sync --input ./figma-variables.json --format theme-ts --output ./theme.ts
+figma-token ./figma-tokens.json --out ./src/tokens
 ```
 
-Preview token changes without writing output or snapshot files:
+Preview all generated files without writing anything:
 
 ```bash
-figma-token sync --input ./figma-variables.json --dry-run
+figma-token ./figma-tokens.json --dry-run
 ```
 
-`--input` accepts a Figma Variables JSON response or a normalized `tokens.json` array. Without `--input`, provide `--figma-token` and `--file-key`, or set `FIGMA_TOKEN` and `FIGMA_FILE_KEY`.
+Check whether generated files are current:
 
-## Options
+```bash
+figma-token check ./figma-tokens.json --out ./src/tokens
+```
 
-`sync` supports `--input`, `--output`, `--snapshot`, `--format`, `--export-name`, `--figma-token`, `--file-key`, and `--dry-run`.
+## Advanced Sync
 
-Supported formats are `tokens-json`, `theme-ts`, `variables-css`, `tokens-scss`, `tailwind-css`, and `tokens-dtcg-json`.
+The hidden `sync` command retains the previous single-format, snapshot, and Figma REST API flow for advanced users. It accepts `--input`, `--output`, `--snapshot`, `--format`, `--export-name`, `--figma-token`, `--file-key`, and `--dry-run`.
 
 For Plugin usage and project-wide documentation, see <https://github.com/lee090626/Project-F>.

package/dist/index.js

@@ -4,20 +4,322 @@
 import "dotenv/config";
 import { Command, InvalidArgumentError } from "commander";
 
+// src/exportTokens.ts
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import { join, resolve } from "path";
+
+// ../core/dist/index.js
+var supportedTypes = ["color", "spacing", "radius", "borderWidth", "size", "fontSize", "opacity"];
+var dimensionTypes = ["spacing", "radius", "borderWidth", "size", "fontSize"];
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+var isColorValue = (value) => isRecord(value) && ["r", "g", "b", "a"].every((key) => isFiniteNumber(value[key]));
+var words = (value) => value.replace(/%/g, " percent ").replace(/(^|[^A-Za-z0-9])-([0-9])/g, "$1 negative $2").replace(/([0-9])\.([0-9])/g, "$1 dot $2").replace(/([a-z0-9])([A-Z])/g, "$1 $2").match(/[A-Za-z0-9]+/g) ?? [];
+function isDesignTokenArray(value) {
+  return Array.isArray(value) && value.every(
+    (token) => isRecord(token) && typeof token.name === "string" && Array.isArray(token.path) && token.path.length > 0 && token.path.every((part) => typeof part === "string") && supportedTypes.includes(token.type) && (isFiniteNumber(token.value) || isColorValue(token.value))
+  );
+}
+var tokenTypeFromName = (name, resolvedType) => {
+  const first = name.split("/").filter(Boolean)[0]?.toLowerCase().replace(/[-_\s]/g, "");
+  if (resolvedType === "COLOR") return "color";
+  if (resolvedType !== "FLOAT") return void 0;
+  if (first === "spacing") return "spacing";
+  if (first === "radius") return "radius";
+  if (first === "borderwidth") return "borderWidth";
+  if (first === "size") return "size";
+  if (first === "fontsize") return "fontSize";
+  if (first === "opacity") return "opacity";
+  return void 0;
+};
+var tokenTypeFromCollection = (collection, resolvedType) => {
+  if (resolvedType !== "FLOAT" || typeof collection?.name !== "string") return void 0;
+  const name = words(collection.name.toLowerCase());
+  if (name.includes("spacing") || name.includes("gap")) return "spacing";
+  if (name.includes("radius") || name.includes("corner") || name.includes("shape")) return "radius";
+  if (name.includes("borderwidth") || name.includes("border") && name.includes("width") || name.includes("stroke")) return "borderWidth";
+  if (name.includes("fontsize") || name.includes("font") && name.includes("size") || name.includes("text")) return "fontSize";
+  if (name.includes("size")) return "size";
+  if (name.includes("opacity") || name.includes("alpha")) return "opacity";
+  return void 0;
+};
+var to255 = (value) => Math.round(value <= 1 ? value * 255 : value);
+var clamp = (min, value, max) => Math.min(max, Math.max(min, value));
+function pickModeId(collection, values, wanted) {
+  if (wanted && wanted in values) return wanted;
+  const defaultModeId = typeof collection?.defaultModeId === "string" ? collection.defaultModeId : void 0;
+  if (defaultModeId && defaultModeId in values) return defaultModeId;
+  const modes = Array.isArray(collection?.modes) ? collection.modes.filter(isRecord) : [];
+  const firstModeId = modes.map((mode) => mode.modeId).find((modeId) => typeof modeId === "string" && modeId in values);
+  return firstModeId ?? Object.keys(values)[0];
+}
+function resolveValue(variables, variable, modeId, onWarning, seen = /* @__PURE__ */ new Set()) {
+  const values = isRecord(variable.valuesByMode) ? variable.valuesByMode : {};
+  const name = typeof variable.name === "string" ? variable.name : modeId;
+  if (!(modeId in values)) {
+    onWarning?.(`${name} (mode: ${modeId})`, "alias-mode-mismatch");
+    return void 0;
+  }
+  const value = values[modeId];
+  if (!isRecord(value) || value.type !== "VARIABLE_ALIAS" || typeof value.id !== "string") return value;
+  if (seen.has(value.id)) {
+    onWarning?.(name, "alias-cycle");
+    return void 0;
+  }
+  seen.add(value.id);
+  const target = variables[value.id];
+  if (!isRecord(target)) {
+    onWarning?.(name, "alias-target-missing");
+    return void 0;
+  }
+  return resolveValue(variables, target, modeId, onWarning, seen);
+}
+function normalizeValue(value, type) {
+  if (type === "color" && isRecord(value) && ["r", "g", "b"].every((key) => isFiniteNumber(value[key])) && (value.a === void 0 || isFiniteNumber(value.a))) {
+    return {
+      r: clamp(0, to255(value.r), 255),
+      g: clamp(0, to255(value.g), 255),
+      b: clamp(0, to255(value.b), 255),
+      a: clamp(0, typeof value.a === "number" ? value.a : 1, 1)
+    };
+  }
+  if (type !== "color" && isFiniteNumber(value)) return value;
+  return void 0;
+}
+function normalizeFigmaVariables(input, options = {}) {
+  if (!isRecord(input)) return [];
+  const root = isRecord(input.meta) ? input.meta : input;
+  const variables = isRecord(root.variables) ? root.variables : {};
+  const collections = isRecord(root.variableCollections) ? root.variableCollections : {};
+  const result = [];
+  for (const variable of Object.values(variables)) {
+    if (!isRecord(variable) || typeof variable.name !== "string" || variable.deletedButReferenced === true) continue;
+    const collection = typeof variable.variableCollectionId === "string" && isRecord(collections[variable.variableCollectionId]) ? collections[variable.variableCollectionId] : void 0;
+    const typeFromName = tokenTypeFromName(variable.name, variable.resolvedType);
+    const typeFromCollection = tokenTypeFromCollection(collection, variable.resolvedType);
+    const type = typeFromName ?? typeFromCollection;
+    if (!type) {
+      options.onUnsupported?.(variable.name, variable.resolvedType === "FLOAT" ? "unclassified-float" : "unsupported-type", typeof collection?.name === "string" ? collection.name : void 0);
+      continue;
+    }
+    const path = variable.name.split("/").filter(Boolean);
+    if (!path.length) continue;
+    const values = isRecord(variable.valuesByMode) ? variable.valuesByMode : {};
+    const modeId = pickModeId(collection, values, options.modeId);
+    if (!modeId) continue;
+    const warnAlias = (name, reason) => options.onAliasWarning?.(name, reason, typeof collection?.name === "string" ? collection.name : void 0);
+    const selectedValue = values[modeId];
+    const rawValue = resolveValue(variables, variable, modeId, warnAlias);
+    const value = normalizeValue(rawValue, type);
+    if (value === void 0) {
+      if (isRecord(selectedValue) && selectedValue.type === "VARIABLE_ALIAS" && rawValue !== void 0) warnAlias(variable.name, "alias-type-mismatch");
+      continue;
+    }
+    const modes = Array.isArray(collection?.modes) ? collection.modes.filter(isRecord) : [];
+    const mode = modes.find((candidate) => candidate.modeId === modeId);
+    result.push({
+      name: variable.name,
+      path: typeFromName ? path : [type, ...path],
+      type,
+      value,
+      ...typeof collection?.name === "string" ? { collection: collection.name } : {},
+      ...typeof mode?.name === "string" ? { mode: mode.name } : {},
+      ...typeof variable.description === "string" && variable.description ? { description: variable.description } : {}
+    });
+  }
+  return result.sort(compareTokens);
+}
+var identity = (token) => `${token.path.join("/")}\0${token.collection ?? ""}\0${token.mode ?? ""}`;
+var compareTokens = (a, b) => (a.collection ?? "").localeCompare(b.collection ?? "") || (a.mode ?? "").localeCompare(b.mode ?? "") || a.path.join("/").localeCompare(b.path.join("/"));
+function diffTokens(previous, current) {
+  const before = new Map(previous.map((token) => [identity(token), token]));
+  const after = new Map(current.map((token) => [identity(token), token]));
+  const diffs = [];
+  for (const [key, token] of after) {
+    const old = before.get(key);
+    if (!old) diffs.push({ type: "added", token });
+    else if (JSON.stringify(old) !== JSON.stringify(token)) diffs.push({ type: "changed", token });
+  }
+  for (const [key, token] of before) if (!after.has(key)) diffs.push({ type: "removed", token });
+  const order = { added: 0, changed: 1, removed: 2 };
+  return diffs.sort((a, b) => compareTokens(a.token, b.token) || order[a.type] - order[b.type]);
+}
+var renderTokensJson = (tokens) => `${JSON.stringify(tokens, null, 2)}
+`;
+var camelKey = (value, fallback = "default") => {
+  let key = words(value).map((word, index) => index ? word[0].toUpperCase() + word.slice(1).toLowerCase() : word.toLowerCase()).join("") || fallback;
+  if (!/^[A-Za-z_$]/.test(key)) key = `_${key}`;
+  return key;
+};
+var kebabKey = (value) => words(value).map((word) => word.toLowerCase()).join("-");
+var generateVariableName = (token) => {
+  const prefix = token.type === "fontSize" ? "font-size" : token.type === "borderWidth" ? "border-width" : token.type;
+  const first = token.path[0]?.toLowerCase().replace(/[-_\s]/g, "");
+  const hasPrefix = first === prefix.replace(/-/g, "");
+  const rest = token.path.slice(hasPrefix ? 1 : 0).map(kebabKey).filter(Boolean).join("-");
+  return `${prefix}${rest ? `-${rest}` : ""}`;
+};
+var hex = (value) => clamp(0, Math.round(value), 255).toString(16).padStart(2, "0");
+var colorHex = (value) => `#${hex(value.r)}${hex(value.g)}${hex(value.b)}${value.a < 1 ? hex(value.a * 255) : ""}`;
+var formatValue = (token) => {
+  if (token.type === "color") return colorHex(token.value);
+  if (dimensionTypes.includes(token.type)) return `${token.value}px`;
+  return String(token.value);
+};
+var formatThemeValue = (token) => token.type === "opacity" ? token.value : formatValue(token);
+function renderCssLike(tokens, nameFor, wrap) {
+  const lines = tokens.map((token) => `${wrap ? "  " : ""}${nameFor(token)}: ${formatValue(token)};`);
+  return wrap ? `${wrap[0]}
+${lines.join("\n")}
+${wrap[1]}
+` : `${lines.join("\n")}
+`;
+}
+var cssName = (token) => `--${generateVariableName(token)}`;
+var scssName = (token) => `$${generateVariableName(token)}`;
+var renderCssVariables = (tokens) => renderCssLike(tokens, cssName, [":root {", "}"]);
+var renderScssVariables = (tokens) => renderCssLike(tokens, scssName);
+var renderTailwindTheme = (tokens) => renderCssLike(tokens, cssName, ["@theme {", "}"]);
+function dtcgValue(token) {
+  if (token.type === "color") return { $type: "color", $value: colorHex(token.value) };
+  if (dimensionTypes.includes(token.type)) return { $type: "dimension", $value: { value: token.value, unit: "px" } };
+  return { $type: "number", $value: token.value };
+}
+function renderDtcgJson(tokens) {
+  const root = {};
+  for (const token of tokens) {
+    let cursor = root;
+    token.path.forEach((part, index) => {
+      if (index === token.path.length - 1) {
+        if (part in cursor) throw new Error(`Duplicate DTCG path: ${token.path.join(".")}`);
+        cursor[part] = dtcgValue(token);
+      } else {
+        if (part in cursor && !isRecord(cursor[part])) throw new Error(`Duplicate DTCG path: ${token.path.join(".")}`);
+        cursor = cursor[part] ?? (cursor[part] = {});
+      }
+    });
+  }
+  return `${JSON.stringify(root, null, 2)}
+`;
+}
+function renderTheme(tokens, exportName = "theme") {
+  if (!/^[A-Za-z_$][\w$]*$/.test(exportName)) throw new Error(`Invalid TypeScript export name: ${exportName}`);
+  const root = {};
+  for (const token of tokens) {
+    const path = token.path.map((part) => camelKey(part, "token"));
+    let cursor = root;
+    path.forEach((part, index) => {
+      if (index === path.length - 1) {
+        if (part in cursor) throw new Error(`Duplicate theme path: ${path.join(".")}`);
+        cursor[part] = formatThemeValue(token);
+      } else {
+        if (part in cursor && !isRecord(cursor[part])) throw new Error(`Duplicate theme path: ${path.join(".")}`);
+        cursor = cursor[part] ?? (cursor[part] = {});
+      }
+    });
+  }
+  return `export const ${exportName} = ${JSON.stringify(root, null, 2)} as const;
+`;
+}
+
+// src/exportTokens.ts
+var tokenFileNames = ["tokens.json", "theme.ts", "variables.css", "tokens.scss", "tailwind.css", "tokens.dtcg.json"];
+function defaultOutputDirectory(cwd = process.cwd()) {
+  return resolve(cwd, "figma-token-output");
+}
+var outputDirectory = (output) => resolve(output ?? defaultOutputDirectory());
+async function readPluginTokens(input) {
+  const inputPath = resolve(input);
+  let inputStat;
+  try {
+    inputStat = await stat(inputPath);
+  } catch (error) {
+    if (error.code === "ENOENT") throw new Error(`Input file not found: ${inputPath}`);
+    throw new Error(`Cannot read input file: ${inputPath}`);
+  }
+  if (inputStat.isDirectory()) throw new Error(`Input path is a directory: ${inputPath}`);
+  let raw;
+  try {
+    raw = JSON.parse(await readFile(inputPath, "utf8"));
+  } catch (error) {
+    if (error instanceof SyntaxError) throw new Error(`Invalid JSON: ${inputPath}`);
+    throw new Error(`Cannot read input file: ${inputPath}`);
+  }
+  if (!isDesignTokenArray(raw)) throw new Error(`Unsupported input: expected Plugin tokens.json: ${inputPath}`);
+  return { inputPath, tokens: raw };
+}
+function renderAll(tokens) {
+  return {
+    "tokens.json": renderTokensJson(tokens),
+    "theme.ts": renderTheme(tokens),
+    "variables.css": renderCssVariables(tokens),
+    "tokens.scss": renderScssVariables(tokens),
+    "tailwind.css": renderTailwindTheme(tokens),
+    "tokens.dtcg.json": renderDtcgJson(tokens)
+  };
+}
+async function prepare(options) {
+  const { inputPath, tokens } = await readPluginTokens(options.input);
+  const outputPath = outputDirectory(options.output);
+  return { inputPath, outputPath, files: renderAll(tokens) };
+}
+async function writeAll(outputPath, files) {
+  try {
+    await mkdir(outputPath, { recursive: true });
+  } catch {
+    throw new Error(`Cannot create output directory: ${outputPath}`);
+  }
+  for (const filename of tokenFileNames) {
+    const path = join(outputPath, filename);
+    try {
+      await writeFile(path, files[filename]);
+    } catch {
+      throw new Error(`Cannot write token file: ${path}`);
+    }
+  }
+}
+async function exportTokenFiles(options, log = console.log) {
+  const result = await prepare(options);
+  if (options.dryRun) {
+    log(`Input: ${result.inputPath}`);
+    log(`Output: ${result.outputPath}`);
+    log("Would generate:");
+    tokenFileNames.forEach((filename) => log(`- ${filename}`));
+    return result;
+  }
+  await writeAll(result.outputPath, result.files);
+  log(`Generated token files in: ${result.outputPath}`);
+  return result;
+}
+async function checkTokenFiles(options, log = console.log) {
+  const result = await prepare(options);
+  const outdated = [];
+  for (const filename of tokenFileNames) {
+    const path = join(result.outputPath, filename);
+    let contents;
+    try {
+      contents = await readFile(path, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        outdated.push(`- ${filename}: missing`);
+        continue;
+      }
+      throw new Error(`Cannot read token file: ${path}`);
+    }
+    if (contents !== result.files[filename]) outdated.push(`- ${filename}: changed`);
+  }
+  if (outdated.length === 0) {
+    log("Token files are up to date.");
+    return 0;
+  }
+  log("Token files are not up to date:");
+  outdated.forEach((message) => log(message));
+  return 1;
+}
+
 // src/sync.ts
-import { mkdir, readFile, writeFile } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { dirname } from "path";
-import {
-  diffTokens,
-  isDesignTokenArray,
-  normalizeFigmaVariables,
-  renderCssVariables,
-  renderDtcgJson,
-  renderScssVariables,
-  renderTailwindTheme,
-  renderTheme,
-  renderTokensJson
-} from "@lee090626/core";
 
 // src/figma/fetchFigmaVariables.ts
 var FIGMA_API = "https://api.figma.com/v1";
@@ -40,7 +342,7 @@ async function fetchFigmaVariables(fileKey, token) {
 // src/sync.ts
 var readJson = async (path) => {
   try {
-    return JSON.parse(await readFile(path, "utf8"));
+    return JSON.parse(await readFile2(path, "utf8"));
   } catch (error) {
     if (error instanceof SyntaxError) throw new Error(`Invalid JSON: ${path}`);
     throw error;
@@ -57,8 +359,8 @@ var readSnapshot = async (path) => {
   }
 };
 var save = async (path, contents) => {
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, contents);
+  await mkdir2(dirname(path), { recursive: true });
+  await writeFile2(path, contents);
 };
 var render = (tokens, options) => ({
   "tokens-json": renderTokensJson,
@@ -97,8 +399,13 @@ var format = (value) => {
   if (!formats.includes(value)) throw new InvalidArgumentError(`format\uC740 ${formats.join(", ")} \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4.`);
   return value;
 };
-var program = new Command().name("figma-token").description("Figma Variables\uB97C \uB85C\uCEEC \uB514\uC790\uC778 \uD1A0\uD070\uC73C\uB85C \uB3D9\uAE30\uD654\uD569\uB2C8\uB2E4.");
-program.command("sync").option("--input <path>", "\uB85C\uCEEC Figma Variables JSON").option("--output <path>", "\uCD9C\uB825 \uD30C\uC77C", "./tokens.json").option("--snapshot <path>", "snapshot \uD30C\uC77C", ".figma-token/snapshot.json").option("--format <format>", "\uCD9C\uB825 \uD3EC\uB9F7", format, "tokens-json").option("--export-name <name>", "theme.ts export \uC774\uB984", "theme").option("--figma-token <token>", "Figma token").option("--file-key <key>", "Figma file key").option("--dry-run", "\uD30C\uC77C\uC744 \uC4F0\uC9C0 \uC54A\uACE0 diff\uB9CC \uCD9C\uB825", false).action(async (options) => sync({
+var program = new Command().name("figma-token").description("Plugin tokens.json\uC744 \uD504\uB85C\uC81D\uD2B8 \uD1A0\uD070 \uD30C\uC77C\uB85C \uC801\uC6A9\uD569\uB2C8\uB2E4.").version("0.1.2").argument("<input>", "Figma Plugin\uC5D0\uC11C \uB2E4\uC6B4\uB85C\uB4DC\uD55C tokens.json").option("--out <directory>", "\uCD9C\uB825 \uD3F4\uB354 (default: ./figma-token-output)").option("--dry-run", "\uD30C\uC77C\uC744 \uC4F0\uC9C0 \uC54A\uACE0 \uC0DD\uC131 \uACB0\uACFC\uB97C \uD655\uC778").action(async (input, options) => {
+  await exportTokenFiles({ input, output: options.out ?? defaultOutputDirectory(), dryRun: options.dryRun });
+});
+program.command("check").description("\uD604\uC7AC \uD1A0\uD070 \uD30C\uC77C\uC774 Plugin tokens.json\uACFC \uC77C\uCE58\uD558\uB294\uC9C0 \uD655\uC778\uD569\uB2C8\uB2E4.").argument("<input>", "Figma Plugin\uC5D0\uC11C \uB2E4\uC6B4\uB85C\uB4DC\uD55C tokens.json").option("--out <directory>", "\uCD9C\uB825 \uD3F4\uB354 (default: ./figma-token-output)").action(async (input, options) => {
+  process.exitCode = await checkTokenFiles({ input, output: options.out ?? defaultOutputDirectory() });
+});
+program.command("sync", { hidden: true }).option("--input <path>", "\uB85C\uCEEC Figma Variables JSON").option("--output <path>", "\uCD9C\uB825 \uD30C\uC77C", "./tokens.json").option("--snapshot <path>", "snapshot \uD30C\uC77C", ".figma-token/snapshot.json").option("--format <format>", "\uCD9C\uB825 \uD3EC\uB9F7", format, "tokens-json").option("--export-name <name>", "theme.ts export \uC774\uB984", "theme").option("--figma-token <token>", "Figma token").option("--file-key <key>", "Figma file key").option("--dry-run", "\uD30C\uC77C\uC744 \uC4F0\uC9C0 \uC54A\uACE0 diff\uB9CC \uCD9C\uB825", false).action(async (options) => sync({
   ...options,
   figmaToken: options.figmaToken ?? process.env.FIGMA_TOKEN,
   fileKey: options.fileKey ?? process.env.FIGMA_FILE_KEY

package/package.json

@@ -1,31 +1,29 @@
 {
   "name": "figma-token",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Export Figma Variables to design token files.",
   "license": "MIT",
   "type": "module",
-  "bin": {
-    "figma-token": "dist/index.js"
-  },
+  "bin": { "figma-token": "dist/index.js" },
   "repository": {
     "type": "git",
-    "url": "https://github.com/lee090626/Project-F.git",
+    "url": "git+https://github.com/lee090626/Project-F.git",
     "directory": "packages/cli"
   },
   "files": [
     "dist",
     "README.md"
   ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run"
+  },
   "dependencies": {
     "commander": "^14.0.0",
-    "dotenv": "^17.0.0",
-    "@lee090626/core": "0.1.0"
+    "dotenv": "^17.0.0"
   },
   "devDependencies": {
+    "@lee090626/core": "workspace:*",
     "tsup": "^8.5.0"
-  },
-  "scripts": {
-    "build": "tsup",
-    "test": "vitest run"
   }
-}
+}