stera-ui 0.2.0 → 0.3.0

package/dist/chunk-26HP67ZM.js

@@ -0,0 +1,695 @@
+// src/utils/transform.ts
+function applyTransforms(content, ctx, transforms) {
+  return transforms.reduce((acc, fn) => fn(acc, ctx), content);
+}
+
+// src/utils/transform-imports.ts
+var DEFAULT_ALIASES = {
+  utils: "@/lib/utils",
+  ui: "@/components/ui",
+  components: "@/components",
+  lib: "@/lib",
+  hooks: "@/hooks"
+};
+var transformImports = (content, ctx) => {
+  if (!ctx.filename.endsWith(".ts") && !ctx.filename.endsWith(".tsx")) {
+    return content;
+  }
+  const { aliases } = ctx.config;
+  const rules = [];
+  if (aliases.utils !== DEFAULT_ALIASES.utils) {
+    rules.push({ type: "exact", from: DEFAULT_ALIASES.utils, to: aliases.utils });
+  }
+  if (aliases.ui !== DEFAULT_ALIASES.ui) {
+    rules.push({ type: "prefix", from: DEFAULT_ALIASES.ui, to: aliases.ui });
+  }
+  if (aliases.components !== DEFAULT_ALIASES.components) {
+    rules.push({ type: "prefix", from: DEFAULT_ALIASES.components, to: aliases.components });
+  }
+  if (aliases.lib !== DEFAULT_ALIASES.lib) {
+    rules.push({ type: "prefix", from: DEFAULT_ALIASES.lib, to: aliases.lib });
+  }
+  if (aliases.hooks !== DEFAULT_ALIASES.hooks) {
+    rules.push({ type: "prefix", from: DEFAULT_ALIASES.hooks, to: aliases.hooks });
+  }
+  if (rules.length === 0) {
+    return content;
+  }
+  return content.replace(
+    /from\s+(["'])([^"']+)\1/g,
+    (match, quote, importPath) => {
+      for (const rule of rules) {
+        if (rule.type === "exact" && importPath === rule.from) {
+          return `from ${quote}${rule.to}${quote}`;
+        }
+        if (rule.type === "prefix" && importPath.startsWith(rule.from + "/")) {
+          const rest = importPath.slice(rule.from.length);
+          return `from ${quote}${rule.to}${rest}${quote}`;
+        }
+        if (rule.type === "prefix" && importPath === rule.from) {
+          return `from ${quote}${rule.to}${quote}`;
+        }
+      }
+      return match;
+    }
+  );
+};
+
+// src/utils/resolve-paths.ts
+import path from "path";
+import { loadConfig, createMatchPath } from "tsconfig-paths";
+var TYPE_TO_ALIAS = {
+  "registry:ui": "ui",
+  "registry:lib": "lib",
+  "registry:hook": "hooks",
+  "registry:component": "components"
+};
+function resolveAlias(alias, projectRoot) {
+  const tsConfig = loadConfig(projectRoot);
+  if (tsConfig.resultType === "success") {
+    const match = createMatchPath(tsConfig.absoluteBaseUrl, tsConfig.paths);
+    const resolved = match(alias, void 0, () => true, [".ts", ".tsx"]);
+    if (resolved) {
+      return path.relative(projectRoot, resolved);
+    }
+  }
+  return alias.replace(/^@\//, "");
+}
+function resolveOutputPath(config, projectRoot, file) {
+  const alias = TYPE_TO_ALIAS[file.type];
+  if (alias) {
+    const dir = resolveAlias(config.aliases[alias], projectRoot);
+    const filename = path.basename(file.path);
+    return path.join(projectRoot, dir, filename);
+  }
+  if (file.type === "registry:style") {
+    const cssDir = path.dirname(config.css);
+    const filename = path.basename(file.path);
+    return path.join(projectRoot, cssDir, filename);
+  }
+  return path.join(projectRoot, file.path);
+}
+
+// src/utils/resolve-config.ts
+import fs from "fs";
+import path2 from "path";
+var CONFIG_FILE = "components.json";
+function migrateConfig(raw) {
+  if (!("version" in raw) && "tailwind" in raw) {
+    const legacy = raw;
+    return {
+      version: 1,
+      css: legacy.tailwind.css || "src/styles/globals.css",
+      aliases: legacy.aliases
+    };
+  }
+  return raw;
+}
+function findConfigPath(cwd) {
+  let dir = path2.resolve(cwd);
+  while (true) {
+    const configPath = path2.join(dir, CONFIG_FILE);
+    if (fs.existsSync(configPath)) return configPath;
+    const parent = path2.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function loadConfig2(cwd) {
+  const configPath = findConfigPath(cwd);
+  if (!configPath) return null;
+  try {
+    const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    return migrateConfig(raw);
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/detect-project.ts
+import fs2 from "fs";
+import path3 from "path";
+function hasFile(cwd, filenames) {
+  return filenames.some((f) => fs2.existsSync(path3.join(cwd, f)));
+}
+function findTailwindCssFile(cwd) {
+  const candidates = [
+    "src/app/globals.css",
+    "src/styles/globals.css",
+    "src/index.css",
+    "app/globals.css",
+    "styles/globals.css",
+    "index.css"
+  ];
+  for (const candidate of candidates) {
+    const fullPath = path3.join(cwd, candidate);
+    if (!fs2.existsSync(fullPath)) continue;
+    const content = fs2.readFileSync(fullPath, "utf-8");
+    if (content.includes('@import "tailwindcss"') || content.includes("@import 'tailwindcss'") || content.includes("@tailwind base")) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function detectProject(cwd) {
+  const hasSrc = fs2.existsSync(path3.join(cwd, "src"));
+  let framework = "other";
+  if (hasFile(cwd, ["next.config.ts", "next.config.js", "next.config.mjs"])) {
+    framework = "next";
+  } else if (hasFile(cwd, ["vite.config.ts", "vite.config.js", "vite.config.mjs"])) {
+    framework = "vite";
+  }
+  let rsc = false;
+  if (framework === "next") {
+    const appDir = hasSrc ? "src/app" : "app";
+    rsc = fs2.existsSync(path3.join(cwd, appDir));
+  }
+  const existingCssFile = findTailwindCssFile(cwd);
+  let layoutFile = null;
+  if (framework === "next") {
+    const appDir = hasSrc ? "src/app" : "app";
+    for (const ext of ["tsx", "jsx", "ts", "js"]) {
+      const candidate = `${appDir}/layout.${ext}`;
+      if (fs2.existsSync(path3.join(cwd, candidate))) {
+        layoutFile = candidate;
+        break;
+      }
+    }
+  } else if (framework === "vite") {
+    if (fs2.existsSync(path3.join(cwd, "index.html"))) {
+      layoutFile = "index.html";
+    }
+  }
+  return { hasSrc, framework, rsc, existingCssFile, layoutFile };
+}
+
+// src/utils/detect-globals.ts
+import fs3 from "fs";
+import path4 from "path";
+function hasGlobalsCss(config, projectRoot) {
+  const cssPath = path4.resolve(projectRoot, config.css);
+  if (!fs3.existsSync(cssPath)) {
+    return false;
+  }
+  const steraPath = path4.join(path4.dirname(cssPath), "stera-ui.css");
+  return fs3.existsSync(steraPath);
+}
+
+// src/utils/install-deps.ts
+import fs4 from "fs";
+import path5 from "path";
+import { detect } from "@antfu/ni";
+import { execa } from "execa";
+
+// src/utils/format.ts
+var BRAND = "\x1B[38;2;166;244;48m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var enabled = process.stdout.isTTY && !process.env.NO_COLOR;
+var wrap = (code, text) => enabled ? `${code}${text}${RESET}` : text;
+var brand = (text) => wrap(BRAND, text);
+var dim = (text) => wrap(DIM, text);
+var LOGO = brand("\u273B");
+var CHECK = brand("\u2713");
+var CROSS = "\u2717";
+var WARN = "!";
+
+// src/utils/spinner.ts
+var FRAMES = ["\u2022", "\u2726", "\u2736", "\u273B"].map(brand);
+var INTERVAL_MS = 150;
+function createSpinner(text) {
+  const isTTY = process.stdout.isTTY;
+  if (!isTTY) {
+    process.stdout.write(`  ${text}...
+`);
+    return {
+      succeed(msg) {
+        process.stdout.write(`  ${CHECK}  ${msg}
+`);
+      },
+      fail(msg) {
+        process.stdout.write(`  ${CROSS}  ${msg}
+`);
+      }
+    };
+  }
+  let frameIndex = 0;
+  const interval = setInterval(() => {
+    process.stdout.write(`\r  ${FRAMES[frameIndex % FRAMES.length]}  ${text}`);
+    frameIndex++;
+  }, INTERVAL_MS);
+  const clear = () => {
+    clearInterval(interval);
+    process.stdout.write("\r" + " ".repeat(text.length + 6) + "\r");
+  };
+  return {
+    succeed(msg) {
+      clear();
+      process.stdout.write(`  ${CHECK}  ${msg}
+`);
+    },
+    fail(msg) {
+      clear();
+      process.stdout.write(`  ${CROSS}  ${msg}
+`);
+    }
+  };
+}
+
+// src/utils/install-deps.ts
+async function detectPackageManager(cwd) {
+  const detected = await detect({ programmatic: true, cwd });
+  if (detected === "pnpm@6" || detected === "pnpm") return "pnpm";
+  if (detected === "yarn@berry" || detected === "yarn") return "yarn";
+  if (detected === "bun") return "bun";
+  if (detected === "npm") return "npm";
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (userAgent.startsWith("pnpm")) return "pnpm";
+  if (userAgent.startsWith("yarn")) return "yarn";
+  if (userAgent.startsWith("bun")) return "bun";
+  return "npm";
+}
+function getInstallArgs(pm, deps) {
+  switch (pm) {
+    case "pnpm":
+      return ["pnpm", ["add", ...deps]];
+    case "yarn":
+      return ["yarn", ["add", ...deps]];
+    case "bun":
+      return ["bun", ["add", ...deps]];
+    default:
+      return ["npm", ["install", ...deps]];
+  }
+}
+async function installDependencies(deps, cwd) {
+  if (deps.length === 0) return;
+  const pkgPath = path5.join(cwd, "package.json");
+  let existing = /* @__PURE__ */ new Set();
+  if (fs4.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+      existing = new Set(Object.keys({ ...pkg.dependencies, ...pkg.devDependencies }));
+    } catch {
+    }
+  }
+  const toInstall = deps.filter((dep) => !existing.has(dep));
+  if (toInstall.length === 0) return;
+  const pm = await detectPackageManager(cwd);
+  const [cmd, args] = getInstallArgs(pm, toInstall);
+  const spinner = createSpinner(`Installing with ${pm}`);
+  try {
+    await execa(cmd, args, { cwd });
+    spinner.succeed(`Installed with ${pm}`);
+  } catch (error) {
+    spinner.fail(`Install failed`);
+    if (error instanceof Error && "stdout" in error && typeof error.stdout === "string" && error.stdout.includes("ERR_PNPM_ADDING_TO_ROOT")) {
+      throw new Error(
+        `Cannot install dependencies at a pnpm workspace root.
+Run stera-ui init from within a specific workspace package instead,
+or use "pnpm add -w <package>" manually to install at the root.`
+      );
+    }
+    throw error;
+  }
+}
+
+// src/utils/write-files.ts
+import fs5 from "fs";
+import path6 from "path";
+import readline from "readline/promises";
+async function confirmOverwrite(relativePath) {
+  if (!process.stdin.isTTY) {
+    console.log(`  Skipping ${relativePath} (already exists, use --overwrite to replace)`);
+    return false;
+  }
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const answer = await rl.question(`  ${relativePath} already exists. Overwrite? (y/N) `);
+  rl.close();
+  return answer.toLowerCase() === "y";
+}
+async function writeComponentFiles(items, config, projectRoot, options = {}) {
+  const written = [];
+  const skipped = [];
+  for (const item of items) {
+    for (const file of item.files ?? []) {
+      const outputPath = resolveOutputPath(config, projectRoot, file);
+      const relativePath = path6.relative(projectRoot, outputPath);
+      if (fs5.existsSync(outputPath)) {
+        const existing = fs5.readFileSync(outputPath, "utf-8");
+        if (existing === file.content) {
+          skipped.push(relativePath);
+          continue;
+        }
+        if (!options.overwrite) {
+          const confirmed = await confirmOverwrite(relativePath);
+          if (!confirmed) {
+            skipped.push(relativePath);
+            continue;
+          }
+        }
+      }
+      const dir = path6.dirname(outputPath);
+      fs5.mkdirSync(dir, { recursive: true });
+      fs5.writeFileSync(outputPath, file.content ?? "", "utf-8");
+      written.push(relativePath);
+    }
+  }
+  return { written, skipped };
+}
+
+// src/utils/update-fonts.ts
+import { existsSync, promises as fs6 } from "fs";
+import path7 from "path";
+import {
+  Project,
+  ScriptKind,
+  SyntaxKind,
+  VariableDeclarationKind
+} from "ts-morph";
+var ROOT_FONT_VARIABLES = /* @__PURE__ */ new Set([
+  "--font-sans",
+  "--font-serif",
+  "--font-mono"
+]);
+function massageTreeForFonts(fonts, project) {
+  const result = {
+    cssVars: {},
+    dependencies: [],
+    cssImports: []
+  };
+  if (fonts.length === 0) return result;
+  const isNext = project.framework === "next";
+  for (const font of fonts) {
+    if (isNext) {
+      result.cssVars[font.font.variable] = `var(${font.font.variable})`;
+    } else {
+      const fontName = font.name.replace(/^font-/, "");
+      const fontSourceDep = font.font.dependency ?? `@fontsource-variable/${fontName}`;
+      result.dependencies.push(fontSourceDep);
+      result.cssImports.push(`@import "${fontSourceDep}";`);
+      result.cssVars[font.font.variable] = font.font.family;
+    }
+  }
+  return result;
+}
+async function updateFonts(fonts, project, cwd, options = {}) {
+  if (fonts.length === 0) return;
+  if (project.framework !== "next") return;
+  const layoutPath = findLayoutFile(project, cwd);
+  if (!layoutPath) return;
+  if (options.silent) {
+    try {
+      const layoutContent = await fs6.readFile(layoutPath, "utf-8");
+      const updatedContent = transformLayoutFonts(layoutContent, fonts);
+      if (updatedContent !== layoutContent) {
+        await fs6.writeFile(layoutPath, updatedContent, "utf-8");
+      }
+    } catch {
+    }
+    return;
+  }
+  const spinner = createSpinner("Updating fonts");
+  try {
+    const layoutContent = await fs6.readFile(layoutPath, "utf-8");
+    const updatedContent = transformLayoutFonts(layoutContent, fonts);
+    if (updatedContent !== layoutContent) {
+      await fs6.writeFile(layoutPath, updatedContent, "utf-8");
+    }
+    spinner.succeed("Updated layout with font imports");
+  } catch {
+    spinner.fail("Failed to update fonts");
+  }
+}
+function findLayoutFile(project, cwd) {
+  if (!project.layoutFile) return null;
+  const fullPath = path7.join(cwd, project.layoutFile);
+  return existsSync(fullPath) ? fullPath : null;
+}
+function transformLayoutFonts(input, fonts) {
+  const project = new Project({ compilerOptions: {} });
+  const sourceFile = project.createSourceFile("layout.tsx", input, {
+    scriptKind: ScriptKind.TSX
+  });
+  const googleFonts = fonts.filter((f) => f.font.provider === "google");
+  const fontVariableNames = [];
+  const fontUtilityClasses = [];
+  for (const font of googleFonts) {
+    const importName = font.font.import;
+    if (!importName) continue;
+    const existingImport = sourceFile.getImportDeclaration(
+      (decl) => decl.getModuleSpecifierValue() === "next/font/google"
+    );
+    let hasExistingImport = false;
+    if (existingImport) {
+      const namedImports = existingImport.getNamedImports();
+      hasExistingImport = namedImports.some(
+        (imp) => imp.getName() === importName
+      );
+      if (!hasExistingImport) {
+        existingImport.addNamedImport(importName);
+      }
+    } else {
+      sourceFile.addImportDeclaration({
+        moduleSpecifier: "next/font/google",
+        namedImports: [importName]
+      });
+    }
+    const varName = getFontVariableName(importName, font.font.variable);
+    const fontOptions = buildFontOptions(font);
+    const existingVarDecl = findFontVariableDeclaration(
+      sourceFile,
+      font.font.variable
+    );
+    if (hasExistingImport && !existingVarDecl && isRootFontVariable(font.font.variable)) {
+      continue;
+    }
+    if (existingVarDecl) {
+      existingVarDecl.setInitializer(`${importName}(${fontOptions})`);
+      if (existingVarDecl.getName() !== varName) {
+        existingVarDecl.rename(varName);
+      }
+    } else {
+      const insertPosition = findInsertPosition(sourceFile);
+      const statement = sourceFile.insertVariableStatement(insertPosition, {
+        declarationKind: VariableDeclarationKind.Const,
+        declarations: [
+          {
+            name: varName,
+            initializer: `${importName}(${fontOptions})`
+          }
+        ]
+      });
+      statement.appendWhitespace("\n");
+    }
+    fontVariableNames.push(varName);
+    if (shouldApplyFontUtilityToHtml(font)) {
+      fontUtilityClasses.push(font.font.variable.replace("--", ""));
+    }
+  }
+  const fontFamilyClasses = /* @__PURE__ */ new Set(["font-sans", "font-serif", "font-mono"]);
+  const lastFontFamilyClass = [...fontUtilityClasses].reverse().find((cls) => fontFamilyClasses.has(cls));
+  const filteredUtilityClasses = fontUtilityClasses.filter(
+    (cls) => !fontFamilyClasses.has(cls)
+  );
+  if (lastFontFamilyClass) {
+    filteredUtilityClasses.unshift(lastFontFamilyClass);
+  }
+  if (fontVariableNames.length > 0) {
+    updateHtmlClassName(sourceFile, fontVariableNames, filteredUtilityClasses);
+  }
+  return sourceFile.getFullText();
+}
+function buildFontOptions(font) {
+  const options = {};
+  if (font.font.subsets?.length) options.subsets = font.font.subsets;
+  if (font.font.weight?.length) options.weight = font.font.weight;
+  options.variable = font.font.variable;
+  return JSON.stringify(options).replace(/"([^"]+)":/g, "$1:").replace(/"/g, "'");
+}
+function isRootFontVariable(variable) {
+  return ROOT_FONT_VARIABLES.has(variable);
+}
+function shouldApplyFontUtilityToHtml(font) {
+  return !font.font.selector && isRootFontVariable(font.font.variable);
+}
+function getFontVariableName(importName, variable) {
+  const baseName = toCamelCase(importName);
+  if (isRootFontVariable(variable)) return baseName;
+  return `${baseName}${toPascalCase(variable.replace(/^--font-/, ""))}`;
+}
+function toCamelCase(str) {
+  return str.split("_").map(
+    (part, index) => index === 0 ? part.toLowerCase() : part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()
+  ).join("");
+}
+function toPascalCase(str) {
+  return str.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function findFontVariableDeclaration(sourceFile, variable) {
+  for (const statement of sourceFile.getVariableStatements()) {
+    for (const declaration of statement.getDeclarations()) {
+      const initializer = declaration.getInitializer();
+      if (!initializer || initializer.getKind() !== SyntaxKind.CallExpression)
+        continue;
+      const args = initializer.getArguments();
+      if (args.length === 0) continue;
+      const argText = args[0].getText();
+      if (argText.includes("variable:") && argText.includes(variable)) {
+        return declaration;
+      }
+    }
+  }
+  return null;
+}
+function findInsertPosition(sourceFile) {
+  const imports = sourceFile.getImportDeclarations();
+  if (imports.length > 0) {
+    return imports[imports.length - 1].getChildIndex() + 1;
+  }
+  return 0;
+}
+function updateHtmlClassName(sourceFile, fontVariableNames, fontUtilityClasses) {
+  const jsxElements = sourceFile.getDescendantsOfKind(
+    SyntaxKind.JsxOpeningElement
+  );
+  for (const element of jsxElements) {
+    if (element.getTagNameNode().getText() !== "html") continue;
+    const newUtilityClasses = fontUtilityClasses.map((cls) => `"${cls}"`);
+    const newVarExpressions = fontVariableNames.map(
+      (name) => `${name}.variable`
+    );
+    const allNewArgs = [...newUtilityClasses, ...newVarExpressions];
+    const classNameAttr = element.getAttribute("className");
+    if (!classNameAttr) {
+      element.addAttribute({
+        name: "className",
+        initializer: `{cn(${allNewArgs.join(", ")})}`
+      });
+      ensureCnImport(sourceFile);
+      return;
+    }
+    if (classNameAttr.getKind() !== SyntaxKind.JsxAttribute) return;
+    const jsxAttr = classNameAttr.asKindOrThrow(SyntaxKind.JsxAttribute);
+    const initializer = jsxAttr.getInitializer();
+    if (!initializer) return;
+    if (initializer.getKind() === SyntaxKind.StringLiteral) {
+      const currentValue = initializer.getText().slice(1, -1);
+      ensureCnImport(sourceFile);
+      jsxAttr.setInitializer(
+        `{cn("${currentValue}", ${allNewArgs.join(", ")})}`
+      );
+    } else if (initializer.getKind() === SyntaxKind.JsxExpression) {
+      const jsxExpr = initializer.asKindOrThrow(SyntaxKind.JsxExpression);
+      const expr = jsxExpr.getExpression();
+      if (!expr) return;
+      const exprText = expr.getText();
+      if (exprText.startsWith("cn(")) {
+        const hasAllFontVars = newVarExpressions.every(
+          (v) => exprText.includes(v)
+        );
+        const hasAllUtilityClasses = fontUtilityClasses.every(
+          (cls) => exprText.includes(`"${cls}"`)
+        );
+        if (hasAllFontVars && hasAllUtilityClasses) continue;
+        let cleanedExpr = exprText;
+        for (const varExpr of newVarExpressions) {
+          cleanedExpr = cleanedExpr.replace(
+            new RegExp(`,?\\s*${varExpr.replace(".", "\\.")}`, "g"),
+            ""
+          );
+        }
+        cleanedExpr = cleanedExpr.replace(/cn\(\s*,/, "cn(");
+        const newExpr = cleanedExpr.replace(
+          /\)$/,
+          `, ${allNewArgs.join(", ")})`
+        );
+        jsxExpr.replaceWithText(`{${newExpr}}`);
+      } else if (/^\w+\.variable$/.test(exprText)) {
+        ensureCnImport(sourceFile);
+        jsxExpr.replaceWithText(`{cn(${allNewArgs.join(", ")})}`);
+      } else if (exprText.startsWith("`") && exprText.endsWith("`")) {
+        const cnArgs = parseTemplateLiteralToCnArgs(exprText);
+        ensureCnImport(sourceFile);
+        const allNewArgsSet = new Set(allNewArgs);
+        const fontFamilyLiterals = new Set(
+          ["font-sans", "font-serif", "font-mono"].map((c) => `"${c}"`)
+        );
+        const cleanedCnArgs = cnArgs.filter(
+          (arg) => !allNewArgsSet.has(arg) && !fontFamilyLiterals.has(arg)
+        );
+        jsxExpr.replaceWithText(
+          `{cn(${[...cleanedCnArgs, ...allNewArgs].join(", ")})}`
+        );
+      } else {
+        ensureCnImport(sourceFile);
+        jsxExpr.replaceWithText(`{cn(${exprText}, ${allNewArgs.join(", ")})}`);
+      }
+    }
+  }
+}
+function ensureCnImport(sourceFile) {
+  const existingImport = sourceFile.getImportDeclaration(
+    (decl) => decl.getNamedImports().some((imp) => imp.getName() === "cn")
+  );
+  if (!existingImport) {
+    const utilsImport = sourceFile.getImportDeclaration(
+      (decl) => decl.getModuleSpecifierValue().includes("/lib/utils")
+    );
+    if (utilsImport) {
+      const namedImports = utilsImport.getNamedImports();
+      if (!namedImports.some((imp) => imp.getName() === "cn")) {
+        utilsImport.addNamedImport("cn");
+      }
+    } else {
+      sourceFile.addImportDeclaration({
+        moduleSpecifier: "@/lib/utils",
+        namedImports: ["cn"]
+      });
+    }
+  }
+}
+function parseTemplateLiteralToCnArgs(templateLiteral) {
+  const staticArgs = [];
+  const variableArgs = [];
+  const content = templateLiteral.slice(1, -1);
+  const parts = content.split(/(\$\{[^}]+\})/);
+  for (const part of parts) {
+    if (!part) continue;
+    if (part.startsWith("${") && part.endsWith("}")) {
+      const expr = part.slice(2, -1).trim();
+      if (expr) variableArgs.push(expr);
+    } else {
+      const staticParts = part.trim().split(/\s+/).filter(Boolean);
+      for (const staticPart of staticParts) {
+        staticArgs.push(`"${staticPart}"`);
+      }
+    }
+  }
+  return [...staticArgs, ...variableArgs];
+}
+
+export {
+  applyTransforms,
+  transformImports,
+  resolveOutputPath,
+  CONFIG_FILE,
+  findConfigPath,
+  loadConfig2 as loadConfig,
+  detectProject,
+  hasGlobalsCss,
+  brand,
+  dim,
+  LOGO,
+  CHECK,
+  CROSS,
+  WARN,
+  createSpinner,
+  detectPackageManager,
+  installDependencies,
+  writeComponentFiles,
+  massageTreeForFonts,
+  updateFonts
+};