@nice2dev/design-tokens 1.3.17 → 1.4.0

package/dist/index.js

@@ -1,61 +1,1192 @@
-import {
-  TokenGenerator,
-  buildTokenObject,
-  checkCircularReferences,
-  createGenerator,
-  createTheme,
-  createTokenCollection,
-  cubicBezierToCss,
-  darkenColor,
-  defaultOptions,
-  defaultThemes,
-  durationToMs,
-  extractReferencePath,
-  filterTokensByPath,
-  filterTokensByType,
-  findReferences,
-  flattenTokens,
-  fontWeightToNumber,
-  generateColorScale,
-  generateDarkModeTokens,
-  generateHighContrastTokens,
-  generateReactThemeContext,
-  generateThemeSwitcher,
-  generateThemesCss,
-  generateTokenTypes,
-  generateTokens,
-  getAccessibleTextColor,
-  getCategories,
-  getContrastRatio,
-  getDependencyGraph,
-  getTokenByPath,
-  hexToHsl,
-  hexToOklch,
-  hexToRgb,
-  isDesignToken,
-  isReference,
-  isTokenGroup,
-  lightenColor,
-  mergeTokenFiles,
-  parseTokenDirectory,
-  parseTokenFile,
-  parseTokenFiles,
-  pathToCssVariable,
-  pathToString,
-  pxToEm,
-  pxToRem,
-  remToPx,
-  resolveToVariable,
-  resolveTokenValue,
-  resolveTokens,
-  sortTokensByDependencies,
-  transformToCss,
-  transformToJs,
-  transformToScss,
-  transformToTailwind,
-  transformToTs
-} from "./chunk-PF2R7I6P.js";
-import "./chunk-6OYMWYZS.js";
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/parser.ts
+import * as fs from "fs";
+import * as path from "path";
+function isDesignToken(obj) {
+  return typeof obj === "object" && obj !== null && "$value" in obj && obj.$value !== void 0;
+}
+function isTokenGroup(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+  if (isDesignToken(obj)) {
+    return false;
+  }
+  return Object.keys(obj).some((key) => !key.startsWith("$"));
+}
+function isReference(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  return /^\{[\w.]+\}$/.test(value);
+}
+function extractReferencePath(ref) {
+  const match = ref.match(/^\{([\w.]+)\}$/);
+  if (!match) {
+    throw new Error(`Invalid reference: ${ref}`);
+  }
+  return match[1].split(".");
+}
+function pathToCssVariable(path3, prefix = "nice") {
+  return `--${prefix}-${path3.join("-")}`;
+}
+function pathToString(path3) {
+  return path3.join(".");
+}
+function parseTokenFile(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const parsed = JSON.parse(content);
+  return parsed;
+}
+function parseTokenFiles(filePaths) {
+  const merged = {};
+  for (const filePath of filePaths) {
+    const tokens = parseTokenFile(filePath);
+    mergeTokenFiles(merged, tokens);
+  }
+  return merged;
+}
+function mergeTokenFiles(target, source) {
+  for (const [key, value] of Object.entries(source)) {
+    if (key.startsWith("$")) {
+      if (!(key in target)) {
+        target[key] = value;
+      }
+    } else if (typeof value === "object" && value !== null) {
+      if (!(key in target)) {
+        target[key] = {};
+      }
+      const targetValue = target[key];
+      if (typeof targetValue === "object" && targetValue !== null) {
+        mergeTokenFiles(targetValue, value);
+      }
+    } else {
+      target[key] = value;
+    }
+  }
+}
+function flattenTokens(tokenFile, prefix = [], inheritedType) {
+  const tokens = [];
+  const currentType = tokenFile.$type ?? inheritedType;
+  for (const [key, value] of Object.entries(tokenFile)) {
+    if (key.startsWith("$")) {
+      continue;
+    }
+    const currentPath = [...prefix, key];
+    if (isDesignToken(value)) {
+      const token = value;
+      const tokenType = token.$type ?? currentType;
+      const references = [];
+      findReferences(token.$value, references);
+      tokens.push({
+        path: currentPath,
+        name: key,
+        value: token.$value,
+        resolvedValue: "",
+        // Will be populated by resolver
+        type: tokenType,
+        description: token.$description,
+        cssVariable: pathToCssVariable(currentPath),
+        references: references.length > 0 ? references : void 0
+      });
+    } else if (isTokenGroup(value)) {
+      const group = value;
+      const groupType = group.$type ?? currentType;
+      tokens.push(...flattenTokens(group, currentPath, groupType));
+    }
+  }
+  return tokens;
+}
+function findReferences(value, refs) {
+  if (typeof value === "string" && isReference(value)) {
+    refs.push(extractReferencePath(value).join("."));
+  } else if (typeof value === "object" && value !== null) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        findReferences(item, refs);
+      }
+    } else {
+      for (const v of Object.values(value)) {
+        findReferences(v, refs);
+      }
+    }
+  }
+}
+function createTokenCollection(tokens) {
+  const byPath = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const pathStr = pathToString(token.path);
+    byPath.set(pathStr, token);
+    const existing = byName.get(token.name);
+    if (!existing || token.path.length > existing.path.length) {
+      byName.set(token.name, token);
+    }
+  }
+  return { tokens, byPath, byName };
+}
+function parseTokenDirectory(dirPath, pattern = "*.json") {
+  const glob = __require("fast-glob");
+  const files = glob.sync(path.join(dirPath, pattern));
+  const tokenFile = parseTokenFiles(files);
+  const flatTokens = flattenTokens(tokenFile);
+  return createTokenCollection(flatTokens);
+}
+function getTokenByPath(collection, path3) {
+  const pathStr = Array.isArray(path3) ? pathToString(path3) : path3;
+  return collection.byPath.get(pathStr);
+}
+function filterTokensByType(collection, type) {
+  return collection.tokens.filter((token) => token.type === type);
+}
+function filterTokensByPath(collection, prefix) {
+  return collection.tokens.filter((token) => pathToString(token.path).startsWith(prefix));
+}
+function getCategories(collection) {
+  const categories = /* @__PURE__ */ new Set();
+  for (const token of collection.tokens) {
+    if (token.path.length > 0) {
+      categories.add(token.path[0]);
+    }
+  }
+  return Array.from(categories);
+}
+
+// src/generator.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/resolver.ts
+var MAX_RESOLUTION_DEPTH = 10;
+function resolveTokens(collection) {
+  const resolvedTokens = collection.tokens.map((token) => {
+    const resolved = { ...token };
+    resolved.resolvedValue = resolveTokenValue(token.value, collection, 0);
+    return resolved;
+  });
+  return {
+    tokens: resolvedTokens,
+    byPath: new Map(resolvedTokens.map((t) => [pathToString(t.path), t])),
+    byName: new Map(resolvedTokens.map((t) => [t.name, t]))
+  };
+}
+function resolveTokenValue(value, collection, depth) {
+  if (depth > MAX_RESOLUTION_DEPTH) {
+    throw new Error(`Maximum reference depth exceeded while resolving token`);
+  }
+  if (typeof value === "string") {
+    if (isReference(value)) {
+      const refPath = extractReferencePath(value);
+      const refPathStr = pathToString(refPath);
+      const refToken = collection.byPath.get(refPathStr);
+      if (!refToken) {
+        console.warn(`Reference not found: ${value}`);
+        return value;
+      }
+      return resolveTokenValue(refToken.value, collection, depth + 1);
+    }
+    return value;
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => {
+      if (typeof v === "string") {
+        return v.includes(" ") ? `"${v}"` : v;
+      }
+      return String(v);
+    }).join(", ");
+  }
+  if (isShadowValue(value)) {
+    return resolveShadowValue(value, collection, depth);
+  }
+  if (Array.isArray(value) && value.length > 0 && isShadowValue(value[0])) {
+    return value.map((s) => resolveShadowValue(s, collection, depth)).join(", ");
+  }
+  if (isTypographyValue(value)) {
+    return resolveTypographyValue(value, collection, depth);
+  }
+  if (isBorderValue(value)) {
+    return resolveBorderValue(value, collection, depth);
+  }
+  return JSON.stringify(value);
+}
+function isShadowValue(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return "offsetX" in value && "offsetY" in value && "blur" in value;
+}
+function resolveShadowValue(shadow, collection, depth) {
+  const offsetX = resolveTokenValue(shadow.offsetX, collection, depth);
+  const offsetY = resolveTokenValue(shadow.offsetY, collection, depth);
+  const blur = resolveTokenValue(shadow.blur, collection, depth);
+  const spread = resolveTokenValue(shadow.spread, collection, depth);
+  const color = resolveTokenValue(shadow.color, collection, depth);
+  const inset = shadow.inset ? "inset " : "";
+  return `${inset}${offsetX} ${offsetY} ${blur} ${spread} ${color}`;
+}
+function isTypographyValue(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return "fontFamily" in value && "fontSize" in value;
+}
+function resolveTypographyValue(typography, collection, depth) {
+  const fontFamily = resolveTokenValue(typography.fontFamily, collection, depth);
+  const fontSize = resolveTokenValue(typography.fontSize, collection, depth);
+  const fontWeight = resolveTokenValue(typography.fontWeight, collection, depth);
+  const lineHeight = typography.lineHeight ? resolveTokenValue(typography.lineHeight, collection, depth) : "normal";
+  const fontStyle = typography.fontStyle || "normal";
+  return `${fontStyle} ${fontWeight} ${fontSize}/${lineHeight} ${fontFamily}`;
+}
+function isBorderValue(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return "color" in value && "width" in value && "style" in value;
+}
+function resolveBorderValue(border, collection, depth) {
+  const width = resolveTokenValue(border.width, collection, depth);
+  const style = resolveTokenValue(border.style, collection, depth);
+  const color = resolveTokenValue(border.color, collection, depth);
+  return `${width} ${style} ${color}`;
+}
+function resolveToVariable(value, collection, _prefix = "nice") {
+  if (typeof value === "string" && isReference(value)) {
+    const refPath = extractReferencePath(value);
+    const refPathStr = pathToString(refPath);
+    const refToken = collection.byPath.get(refPathStr);
+    if (refToken) {
+      return `var(${refToken.cssVariable})`;
+    }
+  }
+  return resolveTokenValue(value, collection, 0);
+}
+function getDependencyGraph(collection) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const token of collection.tokens) {
+    const pathStr = pathToString(token.path);
+    const deps = /* @__PURE__ */ new Set();
+    if (token.references) {
+      for (const ref of token.references) {
+        deps.add(ref);
+      }
+    }
+    graph.set(pathStr, deps);
+  }
+  return graph;
+}
+function sortTokensByDependencies(collection) {
+  const graph = getDependencyGraph(collection);
+  const visited = /* @__PURE__ */ new Set();
+  const sorted = [];
+  function visit(pathStr) {
+    if (visited.has(pathStr)) {
+      return;
+    }
+    visited.add(pathStr);
+    const deps = graph.get(pathStr);
+    if (deps) {
+      for (const dep of deps) {
+        visit(dep);
+      }
+    }
+    const token = collection.byPath.get(pathStr);
+    if (token) {
+      sorted.push(token);
+    }
+  }
+  for (const token of collection.tokens) {
+    visit(pathToString(token.path));
+  }
+  return sorted;
+}
+function checkCircularReferences(collection) {
+  const graph = getDependencyGraph(collection);
+  const circles = [];
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  function visit(pathStr, path3) {
+    if (visited.has(pathStr)) {
+      return false;
+    }
+    if (visiting.has(pathStr)) {
+      const circleStart = path3.indexOf(pathStr);
+      circles.push(path3.slice(circleStart));
+      return true;
+    }
+    visiting.add(pathStr);
+    path3.push(pathStr);
+    const deps = graph.get(pathStr);
+    if (deps) {
+      for (const dep of deps) {
+        if (visit(dep, [...path3])) {
+          return true;
+        }
+      }
+    }
+    visiting.delete(pathStr);
+    visited.add(pathStr);
+    return false;
+  }
+  for (const token of collection.tokens) {
+    const pathStr = pathToString(token.path);
+    if (!visited.has(pathStr)) {
+      visit(pathStr, []);
+    }
+  }
+  return circles;
+}
+
+// src/transforms.ts
+var chroma = null;
+async function getChroma() {
+  if (!chroma) {
+    chroma = (await import("chroma-js")).default;
+  }
+  return chroma;
+}
+async function hexToRgb(hex) {
+  const c = await getChroma();
+  const [r, g, b] = c(hex).rgb();
+  return `rgb(${r}, ${g}, ${b})`;
+}
+async function hexToHsl(hex) {
+  const c = await getChroma();
+  const [h, s, l] = c(hex).hsl();
+  return `hsl(${Math.round(h)}deg ${Math.round(s * 100)}% ${Math.round(l * 100)}%)`;
+}
+async function hexToOklch(hex) {
+  const c = await getChroma();
+  const [l, a, b] = c(hex).lab();
+  const L = l / 100;
+  const C = Math.sqrt(a * a + b * b) / 125;
+  const H = Math.atan2(b, a) * 180 / Math.PI;
+  return `oklch(${(L * 100).toFixed(1)}% ${C.toFixed(3)} ${H < 0 ? H + 360 : H}deg)`;
+}
+async function lightenColor(hex, amount) {
+  const c = await getChroma();
+  return c(hex).brighten(amount).hex();
+}
+async function darkenColor(hex, amount) {
+  const c = await getChroma();
+  return c(hex).darken(amount).hex();
+}
+async function getContrastRatio(fg, bg) {
+  const c = await getChroma();
+  return c.contrast(fg, bg);
+}
+async function getAccessibleTextColor(bgColor) {
+  const c = await getChroma();
+  const contrastWhite = c.contrast(bgColor, "white");
+  const contrastBlack = c.contrast(bgColor, "black");
+  return contrastWhite > contrastBlack ? "#ffffff" : "#000000";
+}
+async function generateColorScale(baseColor, steps = 10) {
+  const c = await getChroma();
+  const scale = {};
+  const labels = ["50", "100", "200", "300", "400", "500", "600", "700", "800", "900", "950"];
+  const colors = c.scale(["white", baseColor, "black"]).mode("lab").colors(steps + 2);
+  for (let i = 0; i < Math.min(labels.length, colors.length - 1); i++) {
+    const index = Math.floor(i / (labels.length - 1) * (colors.length - 1));
+    scale[labels[i]] = colors[index];
+  }
+  return scale;
+}
+function pxToRem(px, baseFontSize = 16) {
+  const value = typeof px === "string" ? parseFloat(px) : px;
+  return `${value / baseFontSize}rem`;
+}
+function remToPx(rem, baseFontSize = 16) {
+  const value = typeof rem === "string" ? parseFloat(rem) : rem;
+  return `${value * baseFontSize}px`;
+}
+function pxToEm(px, context = 16) {
+  const value = typeof px === "string" ? parseFloat(px) : px;
+  return `${value / context}em`;
+}
+function fontWeightToNumber(weight) {
+  const weights = {
+    thin: 100,
+    hairline: 100,
+    extralight: 200,
+    ultralight: 200,
+    light: 300,
+    normal: 400,
+    regular: 400,
+    medium: 500,
+    semibold: 600,
+    demibold: 600,
+    bold: 700,
+    extrabold: 800,
+    ultrabold: 800,
+    black: 900,
+    heavy: 900
+  };
+  return (weights[weight.toLowerCase()] ?? parseInt(weight, 10)) || 400;
+}
+function cubicBezierToCss(values) {
+  if (values.length !== 4) {
+    throw new Error("Cubic bezier must have exactly 4 values");
+  }
+  return `cubic-bezier(${values.join(", ")})`;
+}
+function durationToMs(duration) {
+  if (duration.endsWith("ms")) {
+    return parseFloat(duration);
+  }
+  if (duration.endsWith("s")) {
+    return parseFloat(duration) * 1e3;
+  }
+  return parseFloat(duration);
+}
+function transformToCss(collection, prefix = "nice") {
+  const lines = [];
+  for (const token of collection.tokens) {
+    const varName = `--${prefix}-${token.path.join("-")}`;
+    lines.push(`  ${varName}: ${token.resolvedValue};`);
+  }
+  return `:root {
+${lines.join("\n")}
+}`;
+}
+function transformToScss(collection, prefix = "nice") {
+  const lines = [];
+  for (const token of collection.tokens) {
+    const varName = `$${prefix}-${token.path.join("-")}`;
+    lines.push(`${varName}: ${token.resolvedValue};`);
+  }
+  return lines.join("\n");
+}
+function transformToJs(collection, variableName = "tokens") {
+  const obj = buildTokenObject(collection);
+  return `export const ${variableName} = ${JSON.stringify(obj, null, 2)};`;
+}
+function transformToTs(collection, variableName = "tokens") {
+  const obj = buildTokenObject(collection);
+  const types = generateTokenTypes(collection);
+  return `${types}
+
+export const ${variableName}: Tokens = ${JSON.stringify(obj, null, 2)};`;
+}
+function buildTokenObject(collection) {
+  const result = {};
+  for (const token of collection.tokens) {
+    let current = result;
+    for (let i = 0; i < token.path.length - 1; i++) {
+      const key = token.path[i];
+      if (!(key in current)) {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+    const lastKey = token.path[token.path.length - 1];
+    current[lastKey] = token.resolvedValue;
+  }
+  return result;
+}
+function generateTokenTypes(collection) {
+  const typeObj = buildTypeStructure(collection);
+  return `interface Tokens ${formatTypeStructure(typeObj)}`;
+}
+function buildTypeStructure(collection) {
+  const result = {};
+  for (const token of collection.tokens) {
+    let current = result;
+    for (let i = 0; i < token.path.length - 1; i++) {
+      const key = token.path[i];
+      if (!(key in current)) {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+    const lastKey = token.path[token.path.length - 1];
+    current[lastKey] = "string";
+  }
+  return result;
+}
+function formatTypeStructure(obj, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  const lines = ["{"];
+  for (const [key, value] of Object.entries(obj)) {
+    const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `'${key}'`;
+    if (typeof value === "string") {
+      lines.push(`${spaces}  ${safeKey}: ${value};`);
+    } else {
+      lines.push(
+        `${spaces}  ${safeKey}: ${formatTypeStructure(value, indent + 1)};`
+      );
+    }
+  }
+  lines.push(`${spaces}}`);
+  return lines.join("\n");
+}
+function transformToTailwind(collection) {
+  const colors = {};
+  const spacing = {};
+  const fontSize = {};
+  const fontFamily = {};
+  const borderRadius = {};
+  const boxShadow = {};
+  for (const token of collection.tokens) {
+    const path3 = token.path;
+    const value = token.resolvedValue;
+    if (path3[0] === "color" || path3[0] === "colors") {
+      setNestedValue(colors, path3.slice(1), value);
+    } else if (path3[0] === "spacing") {
+      spacing[path3.slice(1).join("-")] = value;
+    } else if (path3[0] === "typography" && path3[1] === "fontSize") {
+      fontSize[path3[2]] = value;
+    } else if (path3[0] === "typography" && path3[1] === "fontFamily") {
+      fontFamily[path3[2]] = value.split(",").map((f) => f.trim());
+    } else if (path3[0] === "effects" && path3[1] === "radius") {
+      borderRadius[path3[2]] = value;
+    } else if (path3[0] === "effects" && path3[1] === "shadow") {
+      boxShadow[path3[2]] = value;
+    }
+  }
+  const config = {
+    theme: {
+      extend: {
+        colors,
+        spacing,
+        fontSize,
+        fontFamily,
+        borderRadius,
+        boxShadow
+      }
+    }
+  };
+  return `module.exports = ${JSON.stringify(config, null, 2)};`;
+}
+function setNestedValue(obj, path3, value) {
+  let current = obj;
+  for (let i = 0; i < path3.length - 1; i++) {
+    const key = path3[i];
+    if (!(key in current)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[path3[path3.length - 1]] = value;
+}
+function applyThemeOverrides(baseCollection, overrides) {
+  const mergedTokens = [...baseCollection.tokens];
+  for (const override of overrides.tokens) {
+    const pathStr = pathToString(override.path);
+    const existingIndex = mergedTokens.findIndex((t) => pathToString(t.path) === pathStr);
+    if (existingIndex >= 0) {
+      mergedTokens[existingIndex] = { ...mergedTokens[existingIndex], ...override };
+    } else {
+      mergedTokens.push(override);
+    }
+  }
+  return {
+    tokens: mergedTokens,
+    byPath: new Map(mergedTokens.map((t) => [pathToString(t.path), t])),
+    byName: new Map(mergedTokens.map((t) => [t.name, t]))
+  };
+}
+
+// src/themes.ts
+var defaultThemes = {
+  light: {
+    name: "light",
+    displayName: "Light",
+    mode: "light",
+    selector: ':root, [data-theme="light"]'
+  },
+  dark: {
+    name: "dark",
+    displayName: "Dark",
+    mode: "dark",
+    selector: '[data-theme="dark"]',
+    mediaQuery: "(prefers-color-scheme: dark)",
+    extends: "light"
+  },
+  "high-contrast": {
+    name: "high-contrast",
+    displayName: "High Contrast",
+    mode: "high-contrast",
+    selector: '[data-theme="high-contrast"]',
+    mediaQuery: "(prefers-contrast: more)",
+    extends: "light"
+  },
+  "high-contrast-dark": {
+    name: "high-contrast-dark",
+    displayName: "High Contrast Dark",
+    mode: "high-contrast-dark",
+    selector: '[data-theme="high-contrast-dark"]',
+    extends: "dark"
+  },
+  dim: {
+    name: "dim",
+    displayName: "Dim",
+    mode: "dim",
+    selector: '[data-theme="dim"]',
+    extends: "dark"
+  }
+};
+function createTheme(name, baseTokens, overrideTokens, config) {
+  const tokens = overrideTokens ? applyThemeOverrides(baseTokens, overrideTokens) : baseTokens;
+  const resolvedTokens = resolveTokens(tokens);
+  const themeConfig = { ...defaultThemes.light, ...config, name };
+  return {
+    name,
+    tokens: resolvedTokens,
+    extends: themeConfig.extends,
+    selector: themeConfig.selector,
+    mediaQuery: themeConfig.mediaQuery
+  };
+}
+function generateThemesCss(themes, prefix = "nice") {
+  const sections = [];
+  for (const theme of themes) {
+    const vars = generateThemeVariables(theme, prefix);
+    sections.push(`${theme.selector} {
+${vars}
+}`);
+    if (theme.mediaQuery) {
+      sections.push(
+        `@media ${theme.mediaQuery} {
+  :root {
+${vars.split("\n").map((l) => `  ${l}`).join("\n")}
+  }
+}`
+      );
+    }
+  }
+  return sections.join("\n\n");
+}
+function generateThemeVariables(theme, prefix) {
+  const lines = [];
+  for (const token of theme.tokens.tokens) {
+    const varName = `--${prefix}-${token.path.join("-")}`;
+    lines.push(`  ${varName}: ${token.resolvedValue};`);
+  }
+  return lines.join("\n");
+}
+function generateThemeSwitcher() {
+  return `
+/**
+ * Nice2Dev Theme Switcher
+ * Auto-generated by @nice2dev/design-tokens
+ */
+
+const THEME_KEY = 'nice-theme';
+const THEMES = ['light', 'dark', 'high-contrast', 'high-contrast-dark', 'dim'];
+
+/**
+ * Get current theme
+ */
+function getTheme() {
+  return document.documentElement.getAttribute('data-theme') || 'light';
+}
+
+/**
+ * Set theme
+ */
+function setTheme(theme) {
+  if (!THEMES.includes(theme)) {
+    console.warn(\`Invalid theme: \${theme}\`);
+    return;
+  }
+  
+  document.documentElement.setAttribute('data-theme', theme);
+  localStorage.setItem(THEME_KEY, theme);
+  
+  // Dispatch event
+  window.dispatchEvent(new CustomEvent('nice-theme-change', { detail: { theme } }));
+}
+
+/**
+ * Toggle between light and dark
+ */
+function toggleTheme() {
+  const current = getTheme();
+  const next = current === 'dark' ? 'light' : 'dark';
+  setTheme(next);
+  return next;
+}
+
+/**
+ * Use system preference
+ */
+function useSystemTheme() {
+  const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+  const prefersHighContrast = window.matchMedia('(prefers-contrast: more)').matches;
+  
+  let theme = 'light';
+  if (prefersDark && prefersHighContrast) {
+    theme = 'high-contrast-dark';
+  } else if (prefersDark) {
+    theme = 'dark';
+  } else if (prefersHighContrast) {
+    theme = 'high-contrast';
+  }
+  
+  setTheme(theme);
+  return theme;
+}
+
+/**
+ * Initialize theme on page load
+ */
+function initTheme() {
+  const saved = localStorage.getItem(THEME_KEY);
+  
+  if (saved && THEMES.includes(saved)) {
+    setTheme(saved);
+  } else {
+    useSystemTheme();
+  }
+  
+  // Listen for system changes
+  window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', () => {
+    if (!localStorage.getItem(THEME_KEY)) {
+      useSystemTheme();
+    }
+  });
+}
+
+// Auto-init
+if (typeof document !== 'undefined') {
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', initTheme);
+  } else {
+    initTheme();
+  }
+}
+
+export { getTheme, setTheme, toggleTheme, useSystemTheme, initTheme, THEMES };
+`.trim();
+}
+function generateReactThemeContext() {
+  return `
+'use client';
+
+import React, { createContext, useContext, useEffect, useState, useCallback } from 'react';
+
+type Theme = 'light' | 'dark' | 'high-contrast' | 'high-contrast-dark' | 'dim';
+
+interface ThemeContextValue {
+  theme: Theme;
+  setTheme: (theme: Theme) => void;
+  toggleTheme: () => void;
+  useSystemTheme: () => void;
+}
+
+const ThemeContext = createContext<ThemeContextValue | undefined>(undefined);
+
+const THEME_KEY = 'nice-theme';
+const THEMES: Theme[] = ['light', 'dark', 'high-contrast', 'high-contrast-dark', 'dim'];
+
+interface ThemeProviderProps {
+  children: React.ReactNode;
+  defaultTheme?: Theme;
+}
+
+export function ThemeProvider({ children, defaultTheme = 'light' }: ThemeProviderProps) {
+  const [theme, setThemeState] = useState<Theme>(defaultTheme);
+
+  useEffect(() => {
+    const saved = localStorage.getItem(THEME_KEY) as Theme | null;
+    if (saved && THEMES.includes(saved)) {
+      setThemeState(saved);
+      document.documentElement.setAttribute('data-theme', saved);
+    } else {
+      const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+      const initial = prefersDark ? 'dark' : 'light';
+      setThemeState(initial);
+      document.documentElement.setAttribute('data-theme', initial);
+    }
+  }, []);
+
+  const setTheme = useCallback((newTheme: Theme) => {
+    setThemeState(newTheme);
+    document.documentElement.setAttribute('data-theme', newTheme);
+    localStorage.setItem(THEME_KEY, newTheme);
+  }, []);
+
+  const toggleTheme = useCallback(() => {
+    setTheme(theme === 'dark' ? 'light' : 'dark');
+  }, [theme, setTheme]);
+
+  const useSystemTheme = useCallback(() => {
+    const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+    const prefersHighContrast = window.matchMedia('(prefers-contrast: more)').matches;
+    
+    let systemTheme: Theme = 'light';
+    if (prefersDark && prefersHighContrast) {
+      systemTheme = 'high-contrast-dark';
+    } else if (prefersDark) {
+      systemTheme = 'dark';
+    } else if (prefersHighContrast) {
+      systemTheme = 'high-contrast';
+    }
+    
+    setTheme(systemTheme);
+    localStorage.removeItem(THEME_KEY);
+  }, [setTheme]);
+
+  return (
+    <ThemeContext.Provider value={{ theme, setTheme, toggleTheme, useSystemTheme }}>
+      {children}
+    </ThemeContext.Provider>
+  );
+}
+
+export function useTheme(): ThemeContextValue {
+  const context = useContext(ThemeContext);
+  if (!context) {
+    throw new Error('useTheme must be used within a ThemeProvider');
+  }
+  return context;
+}
+
+export { THEMES };
+export type { Theme };
+`.trim();
+}
+async function generateDarkModeTokens(lightTokens) {
+  const darkTokens = [];
+  const chroma2 = (await import("chroma-js")).default;
+  for (const token of lightTokens.tokens) {
+    if (token.type !== "color" || !token.path.includes("semantic")) {
+      continue;
+    }
+    const pathStr = pathToString(token.path);
+    if (pathStr.includes("dark")) {
+      continue;
+    }
+    try {
+      const color = chroma2(token.resolvedValue);
+      let darkValue;
+      if (token.name.includes("background") || token.name.includes("bg")) {
+        const [h, s, l] = color.hsl();
+        darkValue = chroma2.hsl(h, s, 1 - l).hex();
+      } else if (token.name.includes("text") || token.name.includes("foreground")) {
+        const [h, s, l] = color.hsl();
+        darkValue = chroma2.hsl(h, s, 1 - l).hex();
+      } else if (token.name.includes("border")) {
+        darkValue = color.brighten(0.5).hex();
+      } else {
+        const [h, s, l] = color.hsl();
+        darkValue = chroma2.hsl(h, Math.min(s * 1.1, 1), Math.min(l * 1.2, 0.9)).hex();
+      }
+      darkTokens.push({
+        ...token,
+        value: darkValue,
+        resolvedValue: darkValue
+      });
+    } catch {
+    }
+  }
+  return darkTokens;
+}
+async function generateHighContrastTokens(baseTokens, _minContrast = 7) {
+  const contrastTokens = [];
+  const chroma2 = (await import("chroma-js")).default;
+  for (const token of baseTokens.tokens) {
+    if (token.type !== "color") {
+      continue;
+    }
+    try {
+      const color = chroma2(token.resolvedValue);
+      const [, s, l] = color.hsl();
+      let newL = l;
+      if (l > 0.5) {
+        newL = Math.min(l * 1.2, 1);
+      } else {
+        newL = Math.max(l * 0.8, 0);
+      }
+      const newS = Math.min(s * 1.3, 1);
+      const newColor = chroma2.hsl(color.get("hsl.h"), newS, newL);
+      contrastTokens.push({
+        ...token,
+        value: newColor.hex(),
+        resolvedValue: newColor.hex()
+      });
+    } catch {
+    }
+  }
+  return contrastTokens;
+}
+
+// src/generator.ts
+var defaultOptions = {
+  formats: ["css"],
+  outputDir: "./dist",
+  prefix: "nice",
+  includePrimitives: true,
+  separateFiles: false,
+  includeDarkMode: true,
+  includeComponents: true
+};
+var TokenGenerator = class {
+  constructor(options = {}) {
+    this.plugins = [];
+    this.collection = null;
+    this.themes = [];
+    this.options = { ...defaultOptions, ...options };
+  }
+  /**
+   * Add plugin
+   */
+  use(plugin) {
+    this.plugins.push(plugin);
+    return this;
+  }
+  /**
+   * Load tokens from files
+   */
+  load(files) {
+    const tokenFile = parseTokenFiles(files);
+    let processedTokens = [tokenFile];
+    for (const plugin of this.plugins) {
+      if (plugin.beforeResolve) {
+        processedTokens = plugin.beforeResolve(processedTokens);
+      }
+    }
+    const flatTokens = flattenTokens(processedTokens[0]);
+    let collection = createTokenCollection(flatTokens);
+    collection = resolveTokens(collection);
+    for (const plugin of this.plugins) {
+      if (plugin.afterResolve) {
+        collection = plugin.afterResolve(collection);
+      }
+    }
+    this.collection = collection;
+    return this;
+  }
+  /**
+   * Load tokens from directory
+   */
+  loadDirectory(dir, pattern = "**/*.json") {
+    const glob = __require("fast-glob");
+    const files = glob.sync(path2.join(dir, pattern));
+    return this.load(files);
+  }
+  /**
+   * Add theme
+   */
+  addTheme(name, overrideTokens) {
+    if (!this.collection) {
+      throw new Error("Load tokens first before adding themes");
+    }
+    const theme = createTheme(name, this.collection, overrideTokens);
+    this.themes.push(theme);
+    return this;
+  }
+  /**
+   * Generate output files
+   */
+  async generate() {
+    if (!this.collection) {
+      throw new Error("No tokens loaded");
+    }
+    fs2.mkdirSync(this.options.outputDir, { recursive: true });
+    for (const format of this.options.formats) {
+      await this.generateFormat(format);
+    }
+    if (this.themes.length > 0) {
+      await this.generateThemeFiles();
+    }
+  }
+  /**
+   * Generate single format
+   */
+  async generateFormat(format) {
+    if (!this.collection) {
+      return;
+    }
+    for (const plugin of this.plugins) {
+      if (plugin.customFormat) {
+        const output = plugin.customFormat(this.collection, this.options);
+        if (output) {
+          const ext = this.getExtension(format);
+          fs2.writeFileSync(
+            path2.join(this.options.outputDir, `tokens.${plugin.name}.${ext}`),
+            output
+          );
+        }
+      }
+    }
+    if (this.options.separateFiles) {
+      await this.generateSeparateFiles(format);
+    } else {
+      await this.generateSingleFile(format);
+    }
+  }
+  /**
+   * Generate single output file
+   */
+  async generateSingleFile(format) {
+    if (!this.collection) {
+      return;
+    }
+    const content = this.transform(this.collection, format);
+    const filename = `tokens.${this.getExtension(format)}`;
+    const filepath = path2.join(this.options.outputDir, filename);
+    fs2.writeFileSync(filepath, content);
+    console.log(`Generated: ${filepath}`);
+  }
+  /**
+   * Generate separate files by category
+   */
+  async generateSeparateFiles(format) {
+    if (!this.collection) {
+      return;
+    }
+    const categories = getCategories(this.collection);
+    const ext = this.getExtension(format);
+    for (const category of categories) {
+      const tokens = this.collection.tokens.filter((t) => t.path[0] === category);
+      const catCollection = {
+        tokens,
+        byPath: new Map(tokens.map((t) => [t.path.join("."), t])),
+        byName: new Map(tokens.map((t) => [t.name, t]))
+      };
+      const content = this.transform(catCollection, format);
+      const filename = `${category}.${ext}`;
+      const filepath = path2.join(this.options.outputDir, filename);
+      fs2.writeFileSync(filepath, content);
+      console.log(`Generated: ${filepath}`);
+    }
+    this.generateIndexFile(categories, format);
+  }
+  /**
+   * Generate index file for separated files
+   */
+  generateIndexFile(categories, format) {
+    const ext = this.getExtension(format);
+    let content = "";
+    switch (format) {
+      case "css":
+        content = categories.map((c) => `@import './${c}.css';`).join("\n");
+        break;
+      case "scss":
+        content = categories.map((c) => `@import './${c}';`).join("\n");
+        break;
+      case "js":
+      case "ts":
+        content = categories.map((c) => `export * from './${c}';`).join("\n");
+        break;
+      default:
+        return;
+    }
+    const filepath = path2.join(this.options.outputDir, `index.${ext}`);
+    fs2.writeFileSync(filepath, content);
+    console.log(`Generated: ${filepath}`);
+  }
+  /**
+   * Transform collection to format
+   */
+  transform(collection, format) {
+    const prefix = this.options.prefix ?? "nice";
+    switch (format) {
+      case "css":
+        return transformToCss(collection, prefix);
+      case "scss":
+        return transformToScss(collection, prefix);
+      case "js":
+        return transformToJs(collection);
+      case "ts":
+        return transformToTs(collection);
+      case "json":
+        return JSON.stringify(this.buildNestedObject(collection), null, 2);
+      case "tailwind":
+        return transformToTailwind(collection);
+      default:
+        throw new Error(`Unsupported format: ${format}`);
+    }
+  }
+  /**
+   * Build nested object from flat tokens
+   */
+  buildNestedObject(collection) {
+    const result = {};
+    for (const token of collection.tokens) {
+      let current = result;
+      for (let i = 0; i < token.path.length - 1; i++) {
+        const key = token.path[i];
+        if (!(key in current)) {
+          current[key] = {};
+        }
+        current = current[key];
+      }
+      current[token.path[token.path.length - 1]] = token.resolvedValue;
+    }
+    return result;
+  }
+  /**
+   * Get file extension for format
+   */
+  getExtension(format) {
+    switch (format) {
+      case "css":
+        return "css";
+      case "scss":
+        return "scss";
+      case "js":
+        return "js";
+      case "ts":
+        return "ts";
+      case "json":
+        return "json";
+      case "tailwind":
+        return "tailwind.js";
+      default:
+        return "txt";
+    }
+  }
+  /**
+   * Generate theme-related files
+   */
+  async generateThemeFiles() {
+    const prefix = this.options.prefix ?? "nice";
+    const themesCss = generateThemesCss(this.themes, prefix);
+    fs2.writeFileSync(path2.join(this.options.outputDir, "themes.css"), themesCss);
+    console.log(`Generated: themes.css`);
+    const switcherJs = generateThemeSwitcher();
+    fs2.writeFileSync(path2.join(this.options.outputDir, "theme-switcher.js"), switcherJs);
+    console.log(`Generated: theme-switcher.js`);
+    const reactContext = generateReactThemeContext();
+    fs2.writeFileSync(path2.join(this.options.outputDir, "ThemeContext.tsx"), reactContext);
+    console.log(`Generated: ThemeContext.tsx`);
+  }
+  /**
+   * Get generated token collection
+   */
+  getCollection() {
+    return this.collection;
+  }
+  /**
+   * Get generated themes
+   */
+  getThemes() {
+    return this.themes;
+  }
+};
+function createGenerator(options) {
+  return new TokenGenerator(options);
+}
+async function generateTokens(tokenDir, outputDir, options) {
+  const generator = createGenerator({
+    ...options,
+    outputDir
+  });
+  generator.loadDirectory(tokenDir);
+  await generator.generate();
+}
 
 // src/presets.ts
 function generateColorScale2(baseColor) {
@@ -2053,7 +3184,7 @@ function tokensToCssVariables(tokens, config = {}) {
     combined
   };
 }
-function flattenTokensToVariables(input, prefix, path = []) {
+function flattenTokensToVariables(input, prefix, path3 = []) {
   const result = [];
   if (Array.isArray(input)) {
     for (const token of input) {
@@ -2066,7 +3197,7 @@ function flattenTokensToVariables(input, prefix, path = []) {
     return result;
   }
   for (const [key, value] of Object.entries(input)) {
-    const currentPath = [...path, key];
+    const currentPath = [...path3, key];
     if (typeof value === "object" && value !== null && "$value" in value) {
       const token = value;
       const variable = `--${prefix}-${currentPath.join("-")}`;
@@ -2086,8 +3217,8 @@ function flattenTokensToVariables(input, prefix, path = []) {
 function formatTokenValue(value, type) {
   if (typeof value === "string") {
     if (value.startsWith("{") && value.endsWith("}")) {
-      const path = value.slice(1, -1).replace(/\./g, "-");
-      return `var(--nice-${path})`;
+      const path3 = value.slice(1, -1).replace(/\./g, "-");
+      return `var(--nice-${path3})`;
     }
     return value;
   }