stera-ui 0.6.0 → 0.7.0

package/dist/{add-JUBSRCDJ.js → add-WUTTJN25.js}

@@ -4,8 +4,10 @@ import {
   findConfigPath,
   installDependencies,
   loadConfig,
-  writeSteraUiCss
-} from "./chunk-2Y64FOD3.js";
+  migrateLegacyStyles,
+  writeComponentFiles,
+  writeStyles
+} from "./chunk-5NLD52O5.js";
 import {
   ComponentNotFoundError,
   createSpinner,
@@ -18,112 +20,7 @@ import {
 } from "./chunk-KGMF6UW4.js";
 
 // src/commands/add.ts
-import path3 from "path";
-
-// src/utils/write-files.ts
-import fs from "fs";
-import path2 from "path";
-import { confirm } from "@inquirer/prompts";
-
-// src/utils/resolve-paths.ts
 import path from "path";
-import { loadConfig as loadConfig2, createMatchPath } from "tsconfig-paths";
-var TYPE_TO_ALIAS = {
-  "registry:ui": "ui",
-  "registry:lib": "lib",
-  "registry:hook": "hooks",
-  "registry:component": "components"
-};
-var matcherCache = /* @__PURE__ */ new Map();
-function getTsConfigMatcher(projectRoot) {
-  let matcher = matcherCache.get(projectRoot);
-  if (matcher !== void 0) return matcher;
-  const tsConfig = loadConfig2(projectRoot);
-  matcher = tsConfig.resultType === "success" && Object.keys(tsConfig.paths).length > 0 ? {
-    paths: tsConfig.paths,
-    match: createMatchPath(tsConfig.absoluteBaseUrl, tsConfig.paths)
-  } : null;
-  matcherCache.set(projectRoot, matcher);
-  return matcher;
-}
-function resolveAlias(alias, projectRoot) {
-  const matcher = getTsConfigMatcher(projectRoot);
-  if (matcher) {
-    const hasMatchingPrefix = Object.keys(matcher.paths).some((key) => {
-      const prefix = key.replace(/\/\*$/, "");
-      return alias === prefix || alias.startsWith(`${prefix}/`);
-    });
-    if (hasMatchingPrefix) {
-      const resolved = matcher.match(alias, void 0, () => true, [
-        ".ts",
-        ".tsx"
-      ]);
-      if (resolved) {
-        return path.relative(projectRoot, resolved);
-      }
-    }
-  }
-  throw new Error(
-    `Could not resolve alias "${alias}" from tsconfig.json. Ensure compilerOptions.paths defines a mapping for it (e.g. "${alias}/*"), then re-run. See https://ui.stera.sh/docs/installation.`
-  );
-}
-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/write-files.ts
-async function confirmOverwrite(relativePath) {
-  if (!process.stdin.isTTY) {
-    console.log(
-      `  Skipping ${relativePath} (already exists, use --overwrite to replace)`
-    );
-    return false;
-  }
-  return confirm({
-    message: `${relativePath} already exists. Overwrite?`,
-    default: false
-  });
-}
-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 = path2.relative(projectRoot, outputPath);
-      if (fs.existsSync(outputPath)) {
-        const existing = fs.readFileSync(outputPath, "utf-8");
-        if (existing === file.content) {
-          skipped.push({ path: relativePath, reason: "unchanged" });
-          continue;
-        }
-        if (!options.overwrite) {
-          const confirmed = await confirmOverwrite(relativePath);
-          if (!confirmed) {
-            skipped.push({ path: relativePath, reason: "declined" });
-            continue;
-          }
-        }
-      }
-      const dir = path2.dirname(outputPath);
-      fs.mkdirSync(dir, { recursive: true });
-      fs.writeFileSync(outputPath, file.content ?? "", "utf-8");
-      written.push(relativePath);
-    }
-  }
-  return { written, skipped };
-}
 
 // src/utils/transform.ts
 function applyTransforms(content, ctx, transforms2) {
@@ -197,7 +94,7 @@ var transformImports = (content, ctx) => {
 // src/commands/add.ts
 var transforms = [transformImports];
 async function add(components, options) {
-  const cwd = options.cwd ? path3.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
   const configPath = findConfigPath(cwd);
   if (!configPath) {
     console.error(
@@ -210,7 +107,7 @@ async function add(components, options) {
     console.error(`  ${CROSS}  Failed to parse ${CONFIG_FILE}.`);
     process.exit(1);
   }
-  const projectRoot = path3.dirname(configPath);
+  const projectRoot = path.dirname(configPath);
   if (components.includes("globals")) {
     if (components.length > 1) {
       console.error(
@@ -223,15 +120,29 @@ async function add(components, options) {
     }
     const spinner2 = createSpinner("Refreshing base styles");
     let result;
+    let migrated = null;
     try {
-      result = await writeSteraUiCss(config, projectRoot);
+      migrated = await migrateLegacyStyles(config, projectRoot);
+      result = await writeStyles(config, projectRoot, {
+        overwrite: options.overwrite
+      });
     } catch (err) {
       spinner2.fail("Failed to refresh base styles");
       throw err;
     }
-    spinner2.succeed(
-      `Refreshed ${path3.relative(projectRoot, result.steraUiPath)}`
-    );
+    spinner2.succeed(`Refreshed ${result.written.length} style files`);
+    if (migrated) {
+      console.log(
+        `  ${CHECK}  Migrated ${path.relative(projectRoot, migrated)} to ui/`
+      );
+    }
+    for (const target of result.written) {
+      console.log(`  ${CHECK}  ${target}`);
+    }
+    for (const file of result.skipped) {
+      const reason = file.reason === "unchanged" ? "unchanged" : "kept your version";
+      console.log(`  ${dim(`-  ${file.path} (${reason})`)}`);
+    }
     console.log("");
     return;
   }

package/dist/chunk-5NLD52O5.js

@@ -0,0 +1,376 @@
+#!/usr/bin/env node
+import {
+  createSpinner,
+  fetchRegistryItem
+} from "./chunk-KKUJRJ2N.js";
+
+// src/utils/resolve-config.ts
+import fs from "fs";
+import path from "path";
+var CONFIG_FILE = "stera.config.json";
+var LEGACY_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;
+}
+var warnedLegacyFilename = false;
+function warnLegacyFilenameOnce(legacyPath) {
+  if (warnedLegacyFilename) return;
+  warnedLegacyFilename = true;
+  console.warn(
+    `  \u26A0 Found ${LEGACY_CONFIG_FILE}. Rename to ${CONFIG_FILE} \u2014 legacy filename support will be removed in a future release.
+    (${legacyPath})`
+  );
+}
+function findConfigPath(cwd) {
+  let dir = path.resolve(cwd);
+  while (true) {
+    const configPath = path.join(dir, CONFIG_FILE);
+    if (fs.existsSync(configPath)) return configPath;
+    const legacyPath = path.join(dir, LEGACY_CONFIG_FILE);
+    if (fs.existsSync(legacyPath)) return legacyPath;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function loadConfig(cwd) {
+  const configPath = findConfigPath(cwd);
+  if (!configPath) return null;
+  if (path.basename(configPath) === LEGACY_CONFIG_FILE) {
+    warnLegacyFilenameOnce(configPath);
+  }
+  try {
+    const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    return migrateConfig(raw);
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/install-deps.ts
+import fs2 from "fs";
+import path2 from "path";
+import { detect } from "@antfu/ni";
+import { execa } from "execa";
+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 = path2.join(cwd, "package.json");
+  let existing = /* @__PURE__ */ new Set();
+  if (fs2.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs2.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/patch-css-vars.ts
+import fs3 from "fs";
+function patchCssVariables(filePath, patches) {
+  const content = fs3.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  const patched = [];
+  const compiled = Object.entries(patches).map(([prop, newValue]) => ({
+    prop,
+    newValue,
+    regex: new RegExp(`(\\s*${escapeRegex(prop)}:\\s*).+?(;)`)
+  }));
+  for (let i = 0; i < lines.length; i++) {
+    for (const { prop, newValue, regex } of compiled) {
+      if (regex.test(lines[i])) {
+        lines[i] = lines[i].replace(regex, `$1${newValue}$2`);
+        if (!patched.includes(prop)) patched.push(prop);
+      }
+    }
+  }
+  if (patched.length > 0) {
+    fs3.writeFileSync(filePath, lines.join("\n"), "utf-8");
+  }
+  return patched;
+}
+function removeCssImport(filePath, importPath) {
+  const content = fs3.readFileSync(filePath, "utf-8");
+  const pattern = new RegExp(
+    `@import\\s+['"]${escapeRegex(importPath)}['"]\\s*;?\\n?`
+  );
+  if (!pattern.test(content)) return false;
+  fs3.writeFileSync(filePath, content.replace(pattern, ""), "utf-8");
+  return true;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/utils/css-imports.ts
+import fs4 from "fs/promises";
+async function insertImportLine(filePath, importStatement) {
+  const content = await fs4.readFile(filePath, "utf-8");
+  const importPath = importStatement.match(/["']([^"']+)["']/)?.[1];
+  if (importPath) {
+    const escaped = importPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    if (new RegExp(`@import\\s+["']${escaped}["']`).test(content)) return;
+  }
+  const lines = content.split("\n");
+  let lastImportIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim().startsWith("@import")) {
+      lastImportIndex = i;
+    }
+  }
+  if (lastImportIndex >= 0) {
+    lines.splice(lastImportIndex + 1, 0, importStatement);
+  } else {
+    lines.unshift(importStatement);
+  }
+  await fs4.writeFile(filePath, lines.join("\n"), "utf-8");
+}
+
+// src/utils/write-files.ts
+import fs5 from "fs";
+import path4 from "path";
+import { confirm } from "@inquirer/prompts";
+
+// src/utils/resolve-paths.ts
+import path3 from "path";
+import { loadConfig as loadConfig2, createMatchPath } from "tsconfig-paths";
+var TYPE_TO_ALIAS = {
+  "registry:ui": "ui",
+  "registry:lib": "lib",
+  "registry:hook": "hooks",
+  "registry:component": "components"
+};
+var matcherCache = /* @__PURE__ */ new Map();
+function getTsConfigMatcher(projectRoot) {
+  let matcher = matcherCache.get(projectRoot);
+  if (matcher !== void 0) return matcher;
+  const tsConfig = loadConfig2(projectRoot);
+  matcher = tsConfig.resultType === "success" && Object.keys(tsConfig.paths).length > 0 ? {
+    paths: tsConfig.paths,
+    match: createMatchPath(tsConfig.absoluteBaseUrl, tsConfig.paths)
+  } : null;
+  matcherCache.set(projectRoot, matcher);
+  return matcher;
+}
+function resolveAlias(alias, projectRoot) {
+  const matcher = getTsConfigMatcher(projectRoot);
+  if (matcher) {
+    const hasMatchingPrefix = Object.keys(matcher.paths).some((key) => {
+      const prefix = key.replace(/\/\*$/, "");
+      return alias === prefix || alias.startsWith(`${prefix}/`);
+    });
+    if (hasMatchingPrefix) {
+      const resolved = matcher.match(alias, void 0, () => true, [
+        ".ts",
+        ".tsx"
+      ]);
+      if (resolved) {
+        return path3.relative(projectRoot, resolved);
+      }
+    }
+  }
+  throw new Error(
+    `Could not resolve alias "${alias}" from tsconfig.json. Ensure compilerOptions.paths defines a mapping for it (e.g. "${alias}/*"), then re-run. See https://ui.stera.sh/docs/installation.`
+  );
+}
+function resolveOutputPath(config, projectRoot, file) {
+  const alias = TYPE_TO_ALIAS[file.type];
+  if (alias) {
+    const dir = resolveAlias(config.aliases[alias], projectRoot);
+    const filename = path3.basename(file.path);
+    return path3.join(projectRoot, dir, filename);
+  }
+  if (file.type === "registry:style") {
+    const cssDir = path3.dirname(config.css);
+    const filename = path3.basename(file.path);
+    return path3.join(projectRoot, cssDir, filename);
+  }
+  return path3.join(projectRoot, file.path);
+}
+
+// src/utils/write-files.ts
+async function confirmOverwrite(relativePath) {
+  if (!process.stdin.isTTY) {
+    console.log(
+      `  Skipping ${relativePath} (already exists, use --overwrite to replace)`
+    );
+    return false;
+  }
+  return confirm({
+    message: `${relativePath} already exists. Overwrite?`,
+    default: false
+  });
+}
+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 = path4.relative(projectRoot, outputPath);
+      if (fs5.existsSync(outputPath)) {
+        const existing = fs5.readFileSync(outputPath, "utf-8");
+        if (existing === file.content) {
+          skipped.push({ path: relativePath, reason: "unchanged" });
+          continue;
+        }
+        if (!options.overwrite) {
+          const confirmed = await confirmOverwrite(relativePath);
+          if (!confirmed) {
+            skipped.push({ path: relativePath, reason: "declined" });
+            continue;
+          }
+        }
+      }
+      const dir = path4.dirname(outputPath);
+      fs5.mkdirSync(dir, { recursive: true });
+      fs5.writeFileSync(outputPath, file.content ?? "", "utf-8");
+      written.push(relativePath);
+    }
+  }
+  return { written, skipped };
+}
+
+// src/utils/write-styles.ts
+import fs6 from "fs/promises";
+import { existsSync } from "fs";
+import path5 from "path";
+var INDEX_TARGET = "ui/index.css";
+var TYPOGRAPHY_TARGET = "ui/typography.css";
+var PROTECTED_TARGETS = /* @__PURE__ */ new Set([TYPOGRAPHY_TARGET, "ui/colors.css"]);
+var LEGACY_FILENAME = "stera-ui.css";
+var LEGACY_IMPORT = "./stera-ui.css";
+function partitionImports(content) {
+  const lines = content.split("\n");
+  const hoisted = [];
+  const kept = [];
+  for (const line of lines) {
+    const specifier = line.trim().match(/^@import\s+["'](.+?)["']/)?.[1];
+    if (specifier === void 0) {
+      kept.push(line);
+    } else if (specifier.startsWith("./") || specifier.startsWith("../")) {
+      kept.push(line);
+    } else if (specifier !== "tailwindcss") {
+      hoisted.push(line.trim());
+    }
+  }
+  const cleaned = kept.join("\n").replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "");
+  return { content: cleaned, hoisted };
+}
+async function migrateLegacyStyles(config, cwd) {
+  const globalsPath = path5.resolve(cwd, config.css);
+  const legacyPath = path5.join(path5.dirname(globalsPath), LEGACY_FILENAME);
+  if (!existsSync(legacyPath)) return null;
+  await fs6.rm(legacyPath);
+  if (existsSync(globalsPath)) {
+    removeCssImport(globalsPath, LEGACY_IMPORT);
+    await insertImportLine(globalsPath, `@import "./${INDEX_TARGET}";`);
+  }
+  return legacyPath;
+}
+async function writeStyles(config, cwd, options = {}) {
+  const item = await fetchRegistryItem("globals");
+  const cssDir = path5.dirname(path5.resolve(cwd, config.css));
+  const written = [];
+  const skipped = [];
+  let extraImports = [];
+  for (const file of item.files ?? []) {
+    const target = file.target ?? path5.basename(file.path);
+    const outputPath = path5.join(cssDir, target);
+    let content = file.content ?? "";
+    if (target === INDEX_TARGET) {
+      const partitioned = partitionImports(content);
+      content = partitioned.content;
+      extraImports = partitioned.hoisted;
+    }
+    if (PROTECTED_TARGETS.has(target) && existsSync(outputPath)) {
+      const existing = await fs6.readFile(outputPath, "utf-8");
+      if (existing === content) {
+        skipped.push({ path: target, reason: "unchanged" });
+        continue;
+      }
+      if (!options.overwrite && !await confirmOverwrite(target)) {
+        skipped.push({ path: target, reason: "declined" });
+        continue;
+      }
+    }
+    await fs6.mkdir(path5.dirname(outputPath), { recursive: true });
+    await fs6.writeFile(outputPath, content, "utf-8");
+    written.push(target);
+  }
+  return {
+    indexPath: path5.join(cssDir, INDEX_TARGET),
+    typographyPath: path5.join(cssDir, TYPOGRAPHY_TARGET),
+    extraImports,
+    dependencies: item.dependencies ?? [],
+    written,
+    skipped
+  };
+}
+
+export {
+  CONFIG_FILE,
+  LEGACY_CONFIG_FILE,
+  findConfigPath,
+  loadConfig,
+  installDependencies,
+  patchCssVariables,
+  insertImportLine,
+  writeComponentFiles,
+  TYPOGRAPHY_TARGET,
+  migrateLegacyStyles,
+  writeStyles
+};