@dsai-io/tools 0.0.1

package/dist/config/index.js

@@ -0,0 +1,1039 @@
+import { z } from 'zod';
+import path2 from 'path';
+import { cosmiconfig, cosmiconfigSync } from 'cosmiconfig';
+
+/* @dsai-io/tools - DSAi Design System Build Tools */
+
+var logLevelSchema = z.enum(["silent", "error", "warn", "info", "debug", "verbose"]);
+var outputFormatSchema = z.enum(["css", "scss", "less", "json", "js", "ts", "esm", "cjs"]);
+var frameworkSchema = z.enum(["react", "vue", "angular", "svelte", "vanilla"]);
+var hashTypeSchema = z.enum(["content", "timestamp", "version", "none"]);
+var globPatternSchema = z.string().min(1, "Glob pattern cannot be empty");
+var filePathSchema = z.string().min(1, "File path cannot be empty");
+var versionSchema = z.string().refine(
+  (val) => {
+    const parts = val.split("-");
+    const version = parts[0] ?? "";
+    const preRelease = parts[1];
+    const versionParts = version.split(".");
+    if (versionParts.length !== 3) {
+      return false;
+    }
+    for (const part of versionParts) {
+      const num = Number(part);
+      if (!Number.isInteger(num) || num < 0) {
+        return false;
+      }
+    }
+    if (preRelease !== void 0 && preRelease.length === 0) {
+      return false;
+    }
+    return true;
+  },
+  { message: "Invalid semantic version format" }
+);
+var customTransformSchema = z.object({
+  name: z.string().min(1, "Transform name is required"),
+  description: z.string().optional(),
+  type: z.enum(["value", "attribute", "name"]).optional().default("value"),
+  transform: z.function().args(z.any(), z.any()).returns(z.any()).optional(),
+  filter: z.function().args(z.any()).returns(z.boolean()).optional(),
+  matcher: z.function().args(z.any()).returns(z.boolean()).optional()
+});
+var customFormatSchema = z.object({
+  name: z.string().min(1, "Format name is required"),
+  description: z.string().optional(),
+  formatter: z.function().args(z.any()).returns(z.string()).optional(),
+  extension: z.string().min(1).optional()
+});
+var themeModeSchema = z.object({
+  selector: z.string().min(1, "Theme selector is required"),
+  mediaQuery: z.string().optional(),
+  dataAttribute: z.string().optional(),
+  cssVariables: z.boolean().optional().default(true),
+  generateSeparateFiles: z.boolean().optional().default(false),
+  prefix: z.string().optional()
+});
+var themesConfigSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  defaultMode: z.enum(["light", "dark", "system"]).optional().default("light"),
+  modes: z.record(z.string(), themeModeSchema).optional().default({
+    light: { selector: ":root", cssVariables: true, generateSeparateFiles: false },
+    dark: {
+      selector: '[data-theme="dark"]',
+      mediaQuery: "(prefers-color-scheme: dark)",
+      cssVariables: true,
+      generateSeparateFiles: false
+    }
+  }),
+  outputFileName: z.string().optional().default("themes"),
+  colorScheme: z.object({
+    light: z.string().optional(),
+    dark: z.string().optional()
+  }).optional()
+});
+var iconOptimizationSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  removeComments: z.boolean().optional().default(true),
+  removeDimensions: z.boolean().optional().default(false),
+  removeViewBox: z.boolean().optional().default(false),
+  removeXMLNS: z.boolean().optional().default(true),
+  cleanupIds: z.boolean().optional().default(true),
+  minify: z.boolean().optional().default(true)
+});
+var iconSpriteSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  fileName: z.string().optional().default("icons"),
+  format: z.enum(["symbol", "stack", "css"]).optional().default("symbol"),
+  prefix: z.string().optional().default("icon-")
+});
+var iconsConfigSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  sourceDir: z.string().optional().default("assets/icons"),
+  outputDir: z.string().optional().default("dist/icons"),
+  formats: z.array(z.enum(["svg", "react", "vue", "sprite", "font"])).optional().default(["svg"]),
+  optimization: iconOptimizationSchema.optional(),
+  sprite: iconSpriteSchema.optional(),
+  componentPrefix: z.string().optional().default("Icon"),
+  componentSuffix: z.string().optional().default(""),
+  generateIndex: z.boolean().optional().default(true),
+  generateTypes: z.boolean().optional().default(true)
+});
+var tokenBuildConfigSchema = z.object({
+  format: outputFormatSchema,
+  outputDir: z.string().optional(),
+  outputFileName: z.string().optional(),
+  fileExtension: z.string().optional(),
+  prefix: z.string().optional(),
+  useVariables: z.boolean().optional(),
+  selector: z.string().optional(),
+  transforms: z.array(z.string()).optional(),
+  customTransforms: z.array(customTransformSchema).optional(),
+  filter: z.function().args(z.any()).returns(z.union([z.boolean(), z.promise(z.boolean())])).optional(),
+  header: z.string().optional(),
+  footer: z.string().optional()
+});
+var tokenCacheConfigSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  directory: z.string().optional().default(".cache"),
+  hashType: hashTypeSchema.optional().default("content"),
+  maxAge: z.number().optional().default(864e5)
+});
+var tokenWatchConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  debounce: z.number().optional().default(300),
+  clearScreen: z.boolean().optional().default(true),
+  ignorePatterns: z.array(z.string()).optional().default([])
+});
+var tokensHooksSchema = z.object({
+  onBuildStart: z.function().args(z.any()).returns(z.union([z.void(), z.promise(z.void())])).optional(),
+  onFormatComplete: z.function().args(z.any()).returns(z.union([z.void(), z.promise(z.void())])).optional(),
+  onAllFormatsComplete: z.function().args(z.any()).returns(z.union([z.void(), z.promise(z.void())])).optional(),
+  onBuildComplete: z.function().args(z.any()).returns(z.union([z.void(), z.promise(z.void())])).optional(),
+  onError: z.function().args(z.any()).returns(z.union([z.void(), z.promise(z.void())])).optional()
+});
+var buildPipelineStepSchema = z.enum([
+  "validate",
+  "transform",
+  "style-dictionary",
+  "sync",
+  "sass-theme",
+  "sass-theme-minified",
+  "postprocess",
+  "sass-utilities",
+  "sass-utilities-minified",
+  "bundle"
+]);
+var tokensBuildPipelineSchema = z.object({
+  /**
+   * Steps to include in the build.
+   * Order matters - steps run in sequence.
+   * Default includes all steps for full @dsai-io/tokens build.
+   * Simpler packages can use subset like ['validate', 'transform', 'style-dictionary']
+   */
+  steps: z.array(buildPipelineStepSchema).optional().default([
+    "validate",
+    "transform",
+    "style-dictionary",
+    "sync",
+    "sass-theme",
+    "sass-theme-minified",
+    "postprocess",
+    "sass-utilities",
+    "sass-utilities-minified",
+    "bundle"
+  ]),
+  /**
+   * Paths configuration for build steps
+   */
+  paths: z.object({
+    /** Source file for sync step (Style Dictionary JS output) */
+    syncSource: z.string().optional().default("dist/js/tokens.js"),
+    /** Target file for sync step */
+    syncTarget: z.string().optional().default("src/tokens-flat.ts"),
+    /** SCSS theme input file */
+    sassThemeInput: z.string().optional().default("src/scss/dsai-theme-bs.scss"),
+    /** CSS theme output file */
+    sassThemeOutput: z.string().optional().default("dist/css/dsai-theme-bs.css"),
+    /** CSS theme minified output file */
+    sassThemeMinifiedOutput: z.string().optional().default("dist/css/dsai-theme-bs.min.css"),
+    /** SCSS utilities input file */
+    sassUtilitiesInput: z.string().optional().default("src/scss/dsai-utilities.scss"),
+    /** CSS utilities output file */
+    sassUtilitiesOutput: z.string().optional().default("dist/css/dsai.css"),
+    /** CSS utilities minified output file */
+    sassUtilitiesMinifiedOutput: z.string().optional().default("dist/css/dsai.min.css")
+  }).optional(),
+  /** Style Dictionary config file name */
+  styleDictionaryConfig: z.string().optional().default("sd.config.mjs")
+});
+var tokensConfigSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  sourcePatterns: z.array(z.string()).optional().default(["src/tokens/**/*.json", "src/tokens/**/*.yaml"]),
+  outputDirs: z.object({
+    css: z.string().optional().default("dist/css"),
+    scss: z.string().optional().default("dist/scss"),
+    less: z.string().optional().default("dist/less"),
+    js: z.string().optional().default("dist/js"),
+    ts: z.string().optional().default("dist/ts"),
+    json: z.string().optional().default("dist/json")
+  }).optional(),
+  additionalScssDirectories: z.array(z.string()).optional().default([]),
+  outputFileNames: z.object({
+    variables: z.string().optional().default("variables"),
+    utilities: z.string().optional().default("utilities"),
+    mixins: z.string().optional().default("mixins"),
+    tokens: z.string().optional().default("tokens")
+  }).optional(),
+  prefix: z.string().optional().default("dsai"),
+  mergeOrder: z.array(z.string()).optional().default(["base", "semantic", "component"]),
+  createBundle: z.boolean().optional().default(true),
+  bundleFileName: z.string().optional().default("bundle"),
+  formats: z.array(outputFormatSchema).optional().default(["css", "scss", "json"]),
+  platforms: z.record(z.string(), tokenBuildConfigSchema).optional(),
+  transforms: z.array(z.string()).optional().default([]),
+  customTransforms: z.array(customTransformSchema).optional().default([]),
+  customFormats: z.array(customFormatSchema).optional().default([]),
+  hooks: tokensHooksSchema.optional(),
+  cache: tokenCacheConfigSchema.optional(),
+  watch: tokenWatchConfigSchema.optional(),
+  verbose: z.boolean().optional().default(false),
+  /** Build pipeline configuration */
+  pipeline: tokensBuildPipelineSchema.optional()
+});
+var buildConfigSchema = z.object({
+  outDir: z.string().optional().default("dist"),
+  clean: z.boolean().optional().default(true),
+  sourcemap: z.boolean().optional().default(false),
+  minify: z.boolean().optional().default(true),
+  parallel: z.boolean().optional().default(true),
+  maxConcurrency: z.number().optional().default(4)
+});
+var globalConfigSchema = z.object({
+  logLevel: logLevelSchema.optional().default("info"),
+  colors: z.boolean().optional().default(true),
+  ci: z.boolean().optional().default(false),
+  dryRun: z.boolean().optional().default(false),
+  cwd: z.string().optional(),
+  configPath: z.string().optional(),
+  framework: frameworkSchema.optional(),
+  build: buildConfigSchema.optional()
+});
+var dsaiConfigSchema = z.object({
+  $schema: z.string().optional(),
+  extends: z.union([z.string(), z.array(z.string())]).optional(),
+  global: globalConfigSchema.optional(),
+  tokens: tokensConfigSchema.optional(),
+  themes: themesConfigSchema.optional(),
+  icons: iconsConfigSchema.optional()
+});
+function formatValidationErrors(zodError) {
+  return zodError.errors.map((err) => ({
+    path: err.path.join(".") || "root",
+    message: err.message,
+    code: err.code,
+    expected: "expected" in err ? String(err.expected) : void 0,
+    received: "received" in err ? String(err.received) : void 0
+  }));
+}
+function validateConfig(config) {
+  const result = dsaiConfigSchema.safeParse(config);
+  if (result.success) {
+    return {
+      success: true,
+      data: result.data
+    };
+  }
+  return {
+    success: false,
+    errors: formatValidationErrors(result.error)
+  };
+}
+function validateConfigOrThrow(config) {
+  const result = validateConfig(config);
+  if (!result.success) {
+    const errorMessages = result.errors?.map((e) => `  - ${e.path}: ${e.message}`).join("\n");
+    throw new Error(`Configuration validation failed:
+${errorMessages}`);
+  }
+  return result.data;
+}
+function validateConfigSection(section, config) {
+  const sectionSchemas = {
+    global: globalConfigSchema,
+    tokens: tokensConfigSchema,
+    themes: themesConfigSchema,
+    icons: iconsConfigSchema
+  };
+  const schema = sectionSchemas[section];
+  if (!schema) {
+    return {
+      success: false,
+      errors: [
+        {
+          path: section,
+          message: `Unknown configuration section: ${section}`,
+          code: "unknown_section"
+        }
+      ]
+    };
+  }
+  const result = schema.safeParse(config);
+  if (result.success) {
+    return {
+      success: true,
+      data: result.data
+    };
+  }
+  return {
+    success: false,
+    errors: formatValidationErrors(result.error)
+  };
+}
+function formatErrorMessage(errors) {
+  const lines = ["Configuration validation failed:", ""];
+  for (const error of errors) {
+    lines.push(`  \u2717 ${error.path}`);
+    lines.push(`    ${error.message}`);
+    if (error.expected && error.received) {
+      lines.push(`    Expected: ${error.expected}`);
+      lines.push(`    Received: ${error.received}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/config/defaults.ts
+var DEFAULT_PREFIX = "--dsai-";
+var DEFAULT_LOG_LEVEL = "info";
+var DEFAULT_OUTPUT_DIR = "dist";
+var DEFAULT_SOURCE_DIR = "figma-exports";
+var DEFAULT_COLLECTIONS_DIR = "collections";
+var DEFAULT_ICONS_SOURCE_DIR = "icons";
+var DEFAULT_ICONS_OUTPUT_DIR = "dist/icons";
+var defaultSourcePatterns = ["theme.json", "tokens.json", "*.tokens.json"];
+var defaultFormats = ["css", "scss", "js", "ts", "json"];
+var defaultOutputFileNames = {
+  css: "tokens.css",
+  scss: "_tokens.scss",
+  js: "tokens.js",
+  ts: "tokens.ts",
+  json: "tokens.json",
+  android: "tokens.xml",
+  ios: "tokens.h"
+};
+var defaultSelectorPattern = {
+  default: ":root",
+  others: '[data-dsai-theme="{mode}"]'
+};
+var defaultThemesConfig = {
+  autoDetect: true,
+  default: "Light",
+  ignoreModes: [],
+  selectorPattern: defaultSelectorPattern
+};
+var defaultIconFramework = "react";
+var defaultIconsConfig = {
+  sourceDir: DEFAULT_ICONS_SOURCE_DIR,
+  outputDir: DEFAULT_ICONS_OUTPUT_DIR,
+  framework: defaultIconFramework,
+  typescript: true,
+  optimize: true,
+  prefix: "Icon"
+};
+var defaultTokensConfig = {
+  source: "theme",
+  sourceDir: DEFAULT_SOURCE_DIR,
+  collectionsDir: DEFAULT_COLLECTIONS_DIR,
+  sourcePatterns: defaultSourcePatterns,
+  collectionMapping: {},
+  outputDir: DEFAULT_OUTPUT_DIR,
+  outputDirs: {},
+  outputFileNames: defaultOutputFileNames,
+  prefix: DEFAULT_PREFIX,
+  formats: defaultFormats,
+  additionalScssDirectories: [],
+  additionalCssDirectories: [],
+  mergeOrder: "after",
+  createBundle: false,
+  themes: defaultThemesConfig,
+  transforms: [],
+  customFormats: [],
+  preprocessors: [],
+  filters: [],
+  outputReferences: true,
+  baseFontSize: 16,
+  separateThemeFiles: false,
+  watch: false,
+  watchDirectories: []
+};
+var defaultGlobalConfig = {
+  cwd: process.cwd(),
+  debug: false,
+  logLevel: DEFAULT_LOG_LEVEL
+};
+var defaultConfig = {
+  tokens: defaultTokensConfig,
+  icons: defaultIconsConfig,
+  global: defaultGlobalConfig,
+  configDir: process.cwd()
+};
+var envMappings = {
+  // Global settings
+  DSAI_LOG_LEVEL: "global.logLevel",
+  DSAI_DEBUG: "global.debug",
+  DSAI_CWD: "global.cwd",
+  // Token settings
+  DSAI_PREFIX: "tokens.prefix",
+  DSAI_SOURCE_DIR: "tokens.sourceDir",
+  DSAI_OUTPUT_DIR: "tokens.outputDir",
+  DSAI_WATCH: "tokens.watch",
+  DSAI_CREATE_BUNDLE: "tokens.createBundle",
+  DSAI_BASE_FONT_SIZE: "tokens.baseFontSize",
+  // Theme settings
+  DSAI_DEFAULT_THEME: "tokens.themes.default",
+  DSAI_AUTO_DETECT_THEMES: "tokens.themes.autoDetect",
+  // Icon settings
+  DSAI_ICONS_SOURCE_DIR: "icons.sourceDir",
+  DSAI_ICONS_OUTPUT_DIR: "icons.outputDir",
+  DSAI_ICONS_FRAMEWORK: "icons.framework",
+  DSAI_ICONS_TYPESCRIPT: "icons.typescript",
+  DSAI_ICONS_OPTIMIZE: "icons.optimize",
+  DSAI_ICONS_PREFIX: "icons.prefix"
+};
+var envBooleanKeys = /* @__PURE__ */ new Set([
+  "DSAI_DEBUG",
+  "DSAI_WATCH",
+  "DSAI_CREATE_BUNDLE",
+  "DSAI_AUTO_DETECT_THEMES",
+  "DSAI_ICONS_TYPESCRIPT",
+  "DSAI_ICONS_OPTIMIZE"
+]);
+var envNumberKeys = /* @__PURE__ */ new Set(["DSAI_BASE_FONT_SIZE"]);
+var envArrayKeys = /* @__PURE__ */ new Set(["DSAI_FORMATS", "DSAI_IGNORE_MODES"]);
+function getOutputFileName(format, theme) {
+  let baseName;
+  switch (format) {
+    case "css":
+      baseName = "tokens.css";
+      break;
+    case "scss":
+      baseName = "_tokens.scss";
+      break;
+    case "js":
+      baseName = "tokens.js";
+      break;
+    case "ts":
+      baseName = "tokens.ts";
+      break;
+    case "json":
+      baseName = "tokens.json";
+      break;
+    case "android":
+      baseName = "tokens.xml";
+      break;
+    case "ios":
+      baseName = "tokens.h";
+      break;
+    default:
+      baseName = "tokens.txt";
+  }
+  if (!theme) {
+    return baseName;
+  }
+  const dotIndex = baseName.lastIndexOf(".");
+  if (dotIndex === -1) {
+    return `${baseName}-${theme}`;
+  }
+  const name = baseName.slice(0, dotIndex);
+  const ext = baseName.slice(dotIndex);
+  return `${name}-${theme}${ext}`;
+}
+function getDefaultOutputDir(format) {
+  switch (format) {
+    case "css":
+      return `${DEFAULT_OUTPUT_DIR}/css`;
+    case "scss":
+      return `${DEFAULT_OUTPUT_DIR}/scss`;
+    case "js":
+    case "ts":
+      return `${DEFAULT_OUTPUT_DIR}/js`;
+    case "json":
+      return `${DEFAULT_OUTPUT_DIR}/json`;
+    case "android":
+      return `${DEFAULT_OUTPUT_DIR}/android`;
+    case "ios":
+      return `${DEFAULT_OUTPUT_DIR}/ios`;
+    default:
+      return DEFAULT_OUTPUT_DIR;
+  }
+}
+function getDefaultExtension(format) {
+  switch (format) {
+    case "css":
+      return ".css";
+    case "scss":
+      return ".scss";
+    case "js":
+      return ".js";
+    case "ts":
+      return ".ts";
+    case "json":
+      return ".json";
+    case "android":
+      return ".xml";
+    case "ios":
+      return ".h";
+    default:
+      return ".txt";
+  }
+}
+function resolveGlobalConfig(config, options) {
+  const base = defaultGlobalConfig;
+  const cwd = options.cwd ?? process.cwd();
+  return {
+    cwd: config?.cwd ? path2.resolve(cwd, config.cwd) : cwd,
+    debug: config?.debug ?? base.debug,
+    logLevel: config?.logLevel ?? base.logLevel
+  };
+}
+function resolveThemesConfig(config) {
+  const base = defaultThemesConfig;
+  return {
+    autoDetect: config?.autoDetect ?? base.autoDetect,
+    default: config?.default ?? base.default,
+    ignoreModes: config?.ignoreModes ?? [...base.ignoreModes],
+    selectorPattern: {
+      default: config?.selectorPattern?.default ?? base.selectorPattern.default,
+      others: config?.selectorPattern?.others ?? base.selectorPattern.others
+    }
+  };
+}
+function resolveIconsConfig(config, options) {
+  const base = defaultIconsConfig;
+  const configDir = options.configDir ?? options.cwd ?? process.cwd();
+  return {
+    sourceDir: config?.sourceDir ? path2.resolve(configDir, config.sourceDir) : base.sourceDir,
+    outputDir: config?.outputDir ? path2.resolve(configDir, config.outputDir) : base.outputDir,
+    framework: config?.framework ?? base.framework,
+    typescript: config?.typescript ?? base.typescript,
+    optimize: config?.optimize ?? base.optimize,
+    prefix: config?.prefix ?? base.prefix
+  };
+}
+function resolveTokensConfig(config, options) {
+  const base = defaultTokensConfig;
+  const configDir = options.configDir ?? options.cwd ?? process.cwd();
+  const resolveDir = (dir) => path2.resolve(configDir, dir);
+  const outputDirsMap = new Map(Object.entries(base.outputDirs));
+  if (config?.outputDirs) {
+    for (const [format, dir] of Object.entries(config.outputDirs)) {
+      if (dir !== void 0) {
+        outputDirsMap.set(format, resolveDir(dir));
+      }
+    }
+  }
+  const outputDirs = Object.fromEntries(outputDirsMap);
+  const collectionMappingMap = /* @__PURE__ */ new Map();
+  if (config?.collectionMapping) {
+    for (const [name, filePath] of Object.entries(config.collectionMapping)) {
+      collectionMappingMap.set(name, resolveDir(filePath));
+    }
+  }
+  const collectionMapping = Object.fromEntries(collectionMappingMap);
+  const additionalScssDirectories = (config?.additionalScssDirectories ?? []).map(resolveDir);
+  const additionalCssDirectories = (config?.additionalCssDirectories ?? []).map(resolveDir);
+  const watchDirectories = (config?.watchDirectories ?? []).map(resolveDir);
+  return {
+    source: config?.source ?? base.source,
+    sourceDir: config?.sourceDir ? resolveDir(config.sourceDir) : base.sourceDir,
+    collectionsDir: config?.collectionsDir ? resolveDir(config.collectionsDir) : base.collectionsDir,
+    sourcePatterns: config?.sourcePatterns ?? [...base.sourcePatterns],
+    collectionMapping,
+    outputDir: config?.outputDir ? resolveDir(config.outputDir) : base.outputDir,
+    outputDirs,
+    outputFileNames: { ...base.outputFileNames, ...config?.outputFileNames },
+    prefix: config?.prefix ?? base.prefix,
+    formats: config?.formats ?? [...base.formats],
+    additionalScssDirectories,
+    additionalCssDirectories,
+    mergeOrder: config?.mergeOrder ?? base.mergeOrder,
+    createBundle: config?.createBundle ?? base.createBundle,
+    scssImportHeader: config?.scssImportHeader,
+    themes: resolveThemesConfig(config?.themes),
+    transforms: config?.transforms ?? [],
+    customFormats: config?.customFormats ?? [],
+    preprocessors: config?.preprocessors ?? [],
+    filters: config?.filters ?? [],
+    onBuildStart: config?.onBuildStart,
+    onFormatComplete: config?.onFormatComplete,
+    onAllFormatsComplete: config?.onAllFormatsComplete,
+    onBuildComplete: config?.onBuildComplete,
+    outputReferences: config?.outputReferences ?? base.outputReferences,
+    baseFontSize: config?.baseFontSize ?? base.baseFontSize,
+    separateThemeFiles: config?.separateThemeFiles ?? base.separateThemeFiles,
+    watch: config?.watch ?? base.watch,
+    watchDirectories,
+    pipeline: config?.pipeline
+  };
+}
+function applyOverrides(config, overrides) {
+  return {
+    tokens: overrides.tokens ? { ...config.tokens, ...overrides.tokens } : config.tokens,
+    icons: overrides.icons ? { ...config.icons, ...overrides.icons } : config.icons,
+    global: overrides.global ? { ...config.global, ...overrides.global } : config.global
+  };
+}
+function resolveConfig(config = {}, options = {}) {
+  const mergedConfig = options.overrides ? applyOverrides(config, options.overrides) : config;
+  const configDir = options.configDir ?? options.cwd ?? process.cwd();
+  return {
+    global: resolveGlobalConfig(mergedConfig.global, options),
+    tokens: resolveTokensConfig(mergedConfig.tokens, options),
+    icons: resolveIconsConfig(mergedConfig.icons, options),
+    configDir
+  };
+}
+function mergeConfigs(...configs) {
+  let result = {};
+  for (const config of configs) {
+    result = applyOverrides(result, config);
+  }
+  return result;
+}
+function createResolvedConfig(partial = {}) {
+  return {
+    global: partial.global ?? defaultConfig.global,
+    tokens: partial.tokens ?? defaultConfig.tokens,
+    icons: partial.icons ?? defaultConfig.icons,
+    configDir: partial.configDir ?? process.cwd(),
+    configPath: partial.configPath
+  };
+}
+
+// src/config/loader.ts
+var MODULE_NAME = "dsai";
+var CONFIG_FILE_NAMES = [
+  "dsai.config.ts",
+  "dsai.config.mjs",
+  "dsai.config.js",
+  "dsai.config.cjs",
+  ".dsairc.ts",
+  ".dsairc.mjs",
+  ".dsairc.js",
+  ".dsairc.cjs",
+  ".dsairc.json",
+  ".dsairc.yaml",
+  ".dsairc.yml",
+  ".dsairc",
+  "package.json"
+];
+function createExplorer(options) {
+  return cosmiconfig(MODULE_NAME, {
+    searchPlaces: CONFIG_FILE_NAMES,
+    stopDir: options?.stopDir,
+    packageProp: MODULE_NAME
+  });
+}
+function createExplorerSync(options) {
+  return cosmiconfigSync(MODULE_NAME, {
+    searchPlaces: CONFIG_FILE_NAMES,
+    stopDir: options?.stopDir,
+    packageProp: MODULE_NAME
+  });
+}
+async function loadConfig(options = {}) {
+  const { cwd = process.cwd(), configPath, overrides, skipFile = false } = options;
+  const warnings = [];
+  let fileConfig = {};
+  let resolvedConfigPath;
+  if (!skipFile) {
+    const explorer = createExplorer({ stopDir: path2.dirname(cwd) });
+    let cosmicResult;
+    try {
+      if (configPath) {
+        const absolutePath = path2.isAbsolute(configPath) ? configPath : path2.resolve(cwd, configPath);
+        cosmicResult = await explorer.load(absolutePath);
+      } else {
+        cosmicResult = await explorer.search(cwd);
+      }
+      if (cosmicResult && !cosmicResult.isEmpty) {
+        fileConfig = cosmicResult.config;
+        resolvedConfigPath = cosmicResult.filepath;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      warnings.push(`Failed to load configuration: ${message}`);
+    }
+  }
+  const configDir = resolvedConfigPath ? path2.dirname(resolvedConfigPath) : cwd;
+  const resolvedConfig = resolveConfig(fileConfig, {
+    cwd,
+    configDir,
+    overrides
+  });
+  return {
+    config: resolvedConfig,
+    configPath: resolvedConfigPath,
+    warnings
+  };
+}
+async function searchConfigFile(cwd = process.cwd()) {
+  const explorer = createExplorer();
+  try {
+    const result = await explorer.search(cwd);
+    return result?.filepath;
+  } catch {
+    return void 0;
+  }
+}
+function clearConfigCache() {
+  const explorer = createExplorer();
+  explorer.clearCaches();
+}
+function loadConfigSync(options = {}) {
+  const { cwd = process.cwd(), configPath, overrides, skipFile = false } = options;
+  const warnings = [];
+  let fileConfig = {};
+  let resolvedConfigPath;
+  if (!skipFile) {
+    const explorer = createExplorerSync({ stopDir: path2.dirname(cwd) });
+    try {
+      if (configPath) {
+        const absolutePath = path2.isAbsolute(configPath) ? configPath : path2.resolve(cwd, configPath);
+        const result = explorer.load(absolutePath);
+        if (result && !result.isEmpty) {
+          fileConfig = result.config;
+          resolvedConfigPath = result.filepath;
+        }
+      } else {
+        const result = explorer.search(cwd);
+        if (result && !result.isEmpty) {
+          fileConfig = result.config;
+          resolvedConfigPath = result.filepath;
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      warnings.push(`Failed to load configuration: ${message}`);
+    }
+  }
+  const configDir = resolvedConfigPath ? path2.dirname(resolvedConfigPath) : cwd;
+  const resolvedConfig = resolveConfig(fileConfig, {
+    cwd,
+    configDir,
+    overrides
+  });
+  return {
+    config: resolvedConfig,
+    configPath: resolvedConfigPath,
+    warnings
+  };
+}
+function defineConfig(config) {
+  return config;
+}
+function defineConfigAsync(configFn) {
+  return configFn();
+}
+
+// src/config/env.ts
+function parseBoolean(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = value.toLowerCase().trim();
+  if (normalized === "true" || normalized === "1" || normalized === "yes") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0" || normalized === "no") {
+    return false;
+  }
+  return void 0;
+}
+function parseNumber(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const num = Number(value);
+  return Number.isNaN(num) ? void 0 : num;
+}
+function parseArray(value) {
+  if (value === void 0 || value.trim() === "") {
+    return void 0;
+  }
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function setNestedValue(obj, path3, value) {
+  const parts = path3.split(".");
+  if (parts.length === 1) {
+    const key = parts[0];
+    if (key !== void 0) {
+      Object.defineProperty(obj, key, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    }
+    return;
+  }
+  if (parts.length === 2) {
+    const [first, second] = parts;
+    if (first !== void 0 && second !== void 0) {
+      if (!(first in obj)) {
+        Object.defineProperty(obj, first, {
+          value: {},
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }
+      const nested = obj[first];
+      Object.defineProperty(nested, second, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    }
+    return;
+  }
+  if (parts.length === 3) {
+    const [first, second, third] = parts;
+    if (first !== void 0 && second !== void 0 && third !== void 0) {
+      if (!(first in obj)) {
+        Object.defineProperty(obj, first, {
+          value: {},
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }
+      const nested1 = obj[first];
+      if (!(second in nested1)) {
+        Object.defineProperty(nested1, second, {
+          value: {},
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }
+      const nested2 = nested1[second];
+      Object.defineProperty(nested2, third, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    }
+  }
+}
+function getConfigFromEnv(options = {}) {
+  const env = options.env ?? process.env;
+  const prefix = options.prefix ?? "DSAI_";
+  const config = {};
+  for (const [envKey, configPath] of Object.entries(envMappings)) {
+    if (!envKey.startsWith(prefix)) {
+      continue;
+    }
+    const envValue = env[envKey];
+    if (envValue === void 0) {
+      continue;
+    }
+    let parsedValue;
+    if (envBooleanKeys.has(envKey)) {
+      parsedValue = parseBoolean(envValue);
+    } else if (envNumberKeys.has(envKey)) {
+      parsedValue = parseNumber(envValue);
+    } else if (envArrayKeys.has(envKey)) {
+      parsedValue = parseArray(envValue);
+    } else {
+      parsedValue = envValue;
+    }
+    if (parsedValue !== void 0) {
+      setNestedValue(config, configPath, parsedValue);
+    }
+  }
+  return config;
+}
+function isCI(env = process.env) {
+  return env["CI"] === "true" || env["CONTINUOUS_INTEGRATION"] === "true" || env["GITHUB_ACTIONS"] === "true" || env["GITLAB_CI"] === "true" || env["CIRCLECI"] === "true" || env["TRAVIS"] === "true" || env["BUILDKITE"] === "true" || env["JENKINS_URL"] !== void 0 || env["TF_BUILD"] === "True";
+}
+function shouldDisableColors(env = process.env) {
+  return env["NO_COLOR"] !== void 0 || env["FORCE_COLOR"] === "0" || env["TERM"] === "dumb";
+}
+function getLogLevelFromEnv(env = process.env) {
+  const dsaiLogLevel = env["DSAI_LOG_LEVEL"];
+  const dsaiDebug = env["DSAI_DEBUG"];
+  const debug = env["DEBUG"];
+  const verbose = env["VERBOSE"];
+  if (dsaiLogLevel) {
+    return dsaiLogLevel;
+  }
+  if (dsaiDebug === "true" || debug?.includes("dsai")) {
+    return "debug";
+  }
+  if (verbose === "true") {
+    return "verbose";
+  }
+  return void 0;
+}
+function getEnvOverrides(env = process.env) {
+  const config = getConfigFromEnv({ env });
+  if (isCI(env) && !config.global) {
+    config.global = { debug: false };
+  }
+  const logLevel = getLogLevelFromEnv(env);
+  if (logLevel) {
+    config.global = {
+      ...config.global,
+      logLevel
+    };
+  }
+  return config;
+}
+
+// src/config/migrate.ts
+function checkMigrationNeeded(config, filename) {
+  const warnings = [];
+  const suggestions = [];
+  if (filename?.includes("tokens.config.json")) {
+    warnings.push("tokens.config.json is deprecated. Please migrate to dsai.config.mjs.");
+    suggestions.push("Run: npx @dsai-io/tools migrate to automatically migrate your config.");
+    return {
+      needsMigration: true,
+      detectedFormat: "legacy-tokens",
+      warnings,
+      suggestions
+    };
+  }
+  if (isLegacyTokensConfig(config)) {
+    warnings.push("Legacy configuration format detected. Some options may be deprecated.");
+    suggestions.push("Consider updating to the new configuration format.");
+    return {
+      needsMigration: true,
+      detectedFormat: "legacy-tokens",
+      warnings,
+      suggestions
+    };
+  }
+  return {
+    needsMigration: false,
+    detectedFormat: "current",
+    warnings,
+    suggestions
+  };
+}
+function isLegacyTokensConfig(config) {
+  if (typeof config !== "object" || config === null) {
+    return false;
+  }
+  const obj = config;
+  return typeof obj["output"] === "string" || typeof obj["source"] === "string" && !("sourceDir" in obj);
+}
+function migrateLegacyTokensConfig(legacy) {
+  const tokens = {};
+  if (legacy.source !== void 0 && legacy.source !== null) {
+    tokens.sourceDir = legacy.source;
+  }
+  if (legacy.output !== void 0 && legacy.output !== null) {
+    tokens.outputDir = legacy.output;
+  }
+  if (legacy.prefix !== void 0 && legacy.prefix !== null) {
+    tokens.prefix = legacy.prefix;
+  }
+  if (Array.isArray(legacy.formats)) {
+    const validFormats = ["css", "scss", "js", "ts", "json", "android", "ios"];
+    tokens.formats = legacy.formats.filter(
+      (f) => validFormats.includes(f)
+    );
+  }
+  if (legacy.themes !== void 0 && legacy.themes !== null) {
+    tokens.themes = {
+      default: legacy.themes.default ?? "Light"
+      // ignoreModes can be derived from modes if needed
+    };
+  }
+  return { tokens };
+}
+function migrateConfig(config, filename) {
+  const check = checkMigrationNeeded(config, filename);
+  if (!check.needsMigration) {
+    return {
+      config,
+      warnings: check.warnings
+    };
+  }
+  switch (check.detectedFormat) {
+    case "legacy-tokens":
+      return {
+        config: migrateLegacyTokensConfig(config),
+        warnings: check.warnings
+      };
+    default:
+      return {
+        config,
+        warnings: [...check.warnings, "Unknown config format - using as-is."]
+      };
+  }
+}
+function checkDeprecatedOptions(config) {
+  const warnings = [];
+  const configAny = config;
+  const tokens = configAny["tokens"];
+  if (tokens !== void 0) {
+    if ("output" in tokens) {
+      warnings.push(
+        `Deprecated: Use 'tokens.outputDir' instead of 'tokens.output' (tokens.outputDir)`
+      );
+    }
+    if ("source" in tokens && typeof tokens["source"] === "string") {
+      warnings.push(
+        `Deprecated: Use 'tokens.sourceDir' instead of 'tokens.source' for directory paths (tokens.sourceDir)`
+      );
+    }
+  }
+  return warnings;
+}
+function generateMigrationScript(_oldConfig, newConfig) {
+  const configJson = JSON.stringify(newConfig, null, "	");
+  return `// @ts-check
+/**
+ * DSAI Configuration
+ *
+ * Migrated from legacy format.
+ * Please review and adjust as needed.
+ *
+ * @type {import('@dsai-io/tools').DsaiConfig}
+ */
+import { defineConfig } from '@dsai-io/tools';
+
+export default defineConfig(${configJson.replace(/"([^"]+)":/g, "$1:")});
+`;
+}
+
+export { CONFIG_FILE_NAMES, DEFAULT_COLLECTIONS_DIR, DEFAULT_ICONS_OUTPUT_DIR, DEFAULT_ICONS_SOURCE_DIR, DEFAULT_LOG_LEVEL, DEFAULT_OUTPUT_DIR, DEFAULT_PREFIX, DEFAULT_SOURCE_DIR, buildConfigSchema, checkDeprecatedOptions, checkMigrationNeeded, clearConfigCache, createResolvedConfig, customFormatSchema, customTransformSchema, defaultConfig, defaultFormats, defaultGlobalConfig, defaultIconFramework, defaultIconsConfig, defaultOutputFileNames, defaultSelectorPattern, defaultSourcePatterns, defaultThemesConfig, defaultTokensConfig, defineConfig, defineConfigAsync, dsaiConfigSchema, envArrayKeys, envBooleanKeys, envMappings, envNumberKeys, filePathSchema, formatErrorMessage, formatValidationErrors, frameworkSchema, generateMigrationScript, getConfigFromEnv, getDefaultExtension, getDefaultOutputDir, getEnvOverrides, getLogLevelFromEnv, getOutputFileName, globPatternSchema, globalConfigSchema, hashTypeSchema, iconOptimizationSchema, iconSpriteSchema, iconsConfigSchema, isCI, loadConfig, loadConfigSync, logLevelSchema, mergeConfigs, migrateConfig, migrateLegacyTokensConfig, outputFormatSchema, resolveConfig, searchConfigFile, shouldDisableColors, themeModeSchema, themesConfigSchema, tokenBuildConfigSchema, tokenCacheConfigSchema, tokenWatchConfigSchema, tokensConfigSchema, tokensHooksSchema, validateConfig, validateConfigOrThrow, validateConfigSection, versionSchema };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map