stera-ui 0.5.0 → 0.6.0

package/dist/add-JUBSRCDJ.js

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+import {
+  CONFIG_FILE,
+  findConfigPath,
+  installDependencies,
+  loadConfig,
+  writeSteraUiCss
+} from "./chunk-2Y64FOD3.js";
+import {
+  ComponentNotFoundError,
+  createSpinner,
+  resolveDependencies
+} from "./chunk-KKUJRJ2N.js";
+import {
+  CHECK,
+  CROSS,
+  dim
+} 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) {
+  return transforms2.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/commands/add.ts
+var transforms = [transformImports];
+async function add(components, options) {
+  const cwd = options.cwd ? path3.resolve(options.cwd) : process.cwd();
+  const configPath = findConfigPath(cwd);
+  if (!configPath) {
+    console.error(
+      `  ${CROSS}  ${CONFIG_FILE} not found. Run "stera-ui init" first.`
+    );
+    process.exit(1);
+  }
+  const config = loadConfig(cwd);
+  if (!config) {
+    console.error(`  ${CROSS}  Failed to parse ${CONFIG_FILE}.`);
+    process.exit(1);
+  }
+  const projectRoot = path3.dirname(configPath);
+  if (components.includes("globals")) {
+    if (components.length > 1) {
+      console.error(
+        `  ${CROSS}  "stera-ui add globals" refreshes design tokens and cannot be combined with other components.`
+      );
+      console.error(
+        `     Run "stera-ui add globals" and "stera-ui add ${components.filter((c) => c !== "globals").join(" ")}" separately.`
+      );
+      process.exit(1);
+    }
+    const spinner2 = createSpinner("Refreshing base styles");
+    let result;
+    try {
+      result = await writeSteraUiCss(config, projectRoot);
+    } catch (err) {
+      spinner2.fail("Failed to refresh base styles");
+      throw err;
+    }
+    spinner2.succeed(
+      `Refreshed ${path3.relative(projectRoot, result.steraUiPath)}`
+    );
+    console.log("");
+    return;
+  }
+  const spinner = createSpinner("Fetching registry");
+  let resolved;
+  try {
+    resolved = await resolveDependencies(components);
+  } catch (err) {
+    if (err instanceof ComponentNotFoundError) {
+      spinner.fail(err.message);
+      console.error(`  Run "stera-ui list" to see available components.`);
+      process.exit(1);
+    }
+    spinner.fail("Failed to fetch registry");
+    throw err;
+  }
+  spinner.succeed("Registry resolved");
+  for (const item of resolved) {
+    for (const file of item.files ?? []) {
+      if (file.content) {
+        file.content = applyTransforms(
+          file.content,
+          { config, filename: file.path },
+          transforms
+        );
+      }
+    }
+  }
+  const requested = new Set(components);
+  console.log("\n  Installing components\n");
+  for (const item of resolved) {
+    const tag = requested.has(item.name) ? "" : dim("  (dependency)");
+    console.log(`  \u2192 ${item.name}${tag}`);
+  }
+  const allNpmDeps = [];
+  for (const item of resolved) {
+    if (item.dependencies) {
+      allNpmDeps.push(...item.dependencies);
+    }
+  }
+  const uniqueNpmDeps = [...new Set(allNpmDeps)].sort();
+  if (uniqueNpmDeps.length > 0) {
+    console.log("\n  npm packages\n");
+    for (const dep of uniqueNpmDeps) {
+      console.log(`  \u2192 ${dep}`);
+    }
+  }
+  console.log("");
+  const { written, skipped } = await writeComponentFiles(
+    resolved,
+    config,
+    projectRoot,
+    { overwrite: options.overwrite }
+  );
+  for (const file of written) {
+    console.log(`  ${CHECK}  ${file}`);
+  }
+  for (const file of skipped) {
+    const label = file.reason === "unchanged" ? "(unchanged)" : "(skipped)";
+    console.log(`  ${dim(`\xB7  ${file.path}  ${label}`)}`);
+  }
+  if (uniqueNpmDeps.length > 0) {
+    console.log("");
+    await installDependencies(uniqueNpmDeps, projectRoot);
+  }
+  console.log("");
+}
+export {
+  add
+};

package/dist/chunk-2Y64FOD3.js

@@ -0,0 +1,161 @@
+#!/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/write-stera-css.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+function stripImportLines(content) {
+  const lines = content.split("\n");
+  const imports = [];
+  const kept = [];
+  for (const line of lines) {
+    if (line.trim().match(/^@import\s+["'].+["']/)) {
+      if (!line.trim().match(/^@import\s+["']tailwindcss["']/)) {
+        imports.push(line.trim());
+      }
+    } else {
+      kept.push(line);
+    }
+  }
+  return { content: kept.join("\n"), imports };
+}
+async function writeSteraUiCss(config, cwd) {
+  const item = await fetchRegistryItem("globals");
+  const rawContent = item.files?.[0]?.content ?? "";
+  const { content, imports } = stripImportLines(rawContent);
+  const cssDir = path3.dirname(path3.resolve(cwd, config.css));
+  const steraUiPath = path3.join(cssDir, "stera-ui.css");
+  await fs3.mkdir(cssDir, { recursive: true });
+  await fs3.writeFile(steraUiPath, content, "utf-8");
+  return {
+    steraUiPath,
+    extraImports: imports,
+    dependencies: item.dependencies ?? []
+  };
+}
+
+export {
+  CONFIG_FILE,
+  LEGACY_CONFIG_FILE,
+  findConfigPath,
+  loadConfig,
+  installDependencies,
+  writeSteraUiCss
+};

package/dist/{chunk-3KADOWKC.js → chunk-4E46BULJ.js}

@@ -41,9 +41,15 @@ var registryItemSchema = z.discriminatedUnion("type", [
     files: z.array(registryItemFileSchema)
   })
 ]);
+var registryIndexEntrySchema = z.object({
+  name: z.string(),
+  type: z.string(),
+  dependencies: z.array(z.string()).optional(),
+  registryDependencies: z.array(z.string()).optional()
+});
 var registryIndexSchema = z.object({
   name: z.string(),
-  items: z.array(registryItemSchema)
+  items: z.array(registryIndexEntrySchema)
 });
 var configSchema = z.object({
   $schema: z.string().optional(),
@@ -67,6 +73,7 @@ export {
   registryItemFileSchema,
   registryItemFontSchema,
   registryItemSchema,
+  registryIndexEntrySchema,
   registryIndexSchema,
   configSchema
 };

package/dist/chunk-BJNLGEZJ.js

@@ -0,0 +1,100 @@
+import {
+  registryIndexSchema,
+  registryItemSchema
+} from "./chunk-4E46BULJ.js";
+
+// src/registry/index.ts
+var REGISTRY_URL = process.env.REGISTRY_URL ?? "https://ui.stera.sh/r";
+var FETCH_TIMEOUT_MS = 15e3;
+var ComponentNotFoundError = class extends Error {
+  components;
+  constructor(components) {
+    super(
+      components.length === 1 ? `Component "${components[0]}" not found in registry.` : `Components not found in registry: ${components.map((c) => `"${c}"`).join(", ")}.`
+    );
+    this.name = "ComponentNotFoundError";
+    this.components = components;
+  }
+};
+var _indexCache = null;
+async function fetchJSON(url) {
+  let res;
+  try {
+    res = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+  } catch (err) {
+    if (err instanceof Error && err.name === "TimeoutError") {
+      throw new Error(
+        `Timed out fetching ${url} after ${FETCH_TIMEOUT_MS / 1e3}s. Check your network connection.`
+      );
+    }
+    throw new Error(
+      `Failed to fetch ${url}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (!res.ok) {
+    throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+async function fetchRegistryIndex() {
+  if (_indexCache) return _indexCache;
+  const data = await fetchJSON(`${REGISTRY_URL}/index.json`);
+  const parsed = registryIndexSchema.safeParse(data);
+  if (!parsed.success) {
+    throw new Error(
+      `Registry index at ${REGISTRY_URL}/index.json returned unexpected data.`
+    );
+  }
+  _indexCache = parsed.data.items;
+  return _indexCache;
+}
+async function fetchRegistryItem(name) {
+  const data = await fetchJSON(`${REGISTRY_URL}/${name}.json`);
+  const parsed = registryItemSchema.safeParse(data);
+  if (!parsed.success) {
+    throw new Error(
+      `Registry item "${name}" returned unexpected data from ${REGISTRY_URL}/${name}.json.`
+    );
+  }
+  return parsed.data;
+}
+async function getComponent(name) {
+  const index = await fetchRegistryIndex();
+  return index.find((item) => item.name === name);
+}
+async function getAllComponents() {
+  return fetchRegistryIndex();
+}
+async function resolveDependencies(names) {
+  const index = await fetchRegistryIndex();
+  const byName = new Map(index.map((entry) => [entry.name, entry]));
+  const needed = [];
+  const seen = /* @__PURE__ */ new Set();
+  const missing = [];
+  const queue = [...names];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    if (seen.has(name)) continue;
+    seen.add(name);
+    const entry = byName.get(name);
+    if (!entry) {
+      missing.push(name);
+      continue;
+    }
+    needed.push(name);
+    queue.push(...entry.registryDependencies ?? []);
+  }
+  if (missing.length > 0) {
+    throw new ComponentNotFoundError(missing);
+  }
+  return Promise.all(needed.map((name) => fetchRegistryItem(name)));
+}
+
+export {
+  ComponentNotFoundError,
+  fetchRegistryIndex,
+  fetchRegistryItem,
+  getComponent,
+  getAllComponents,
+  resolveDependencies
+};

package/dist/chunk-KGMF6UW4.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+// 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";
+
+export {
+  brand,
+  dim,
+  LOGO,
+  CHECK,
+  CROSS
+};