stera-ui 0.8.0 → 0.9.0

package/dist/add-WUTTJN25.js

@@ -1,215 +0,0 @@
-#!/usr/bin/env node
-import {
-  CONFIG_FILE,
-  findConfigPath,
-  installDependencies,
-  loadConfig,
-  migrateLegacyStyles,
-  writeComponentFiles,
-  writeStyles
-} from "./chunk-5NLD52O5.js";
-import {
-  ComponentNotFoundError,
-  createSpinner,
-  resolveDependencies
-} from "./chunk-KKUJRJ2N.js";
-import {
-  CHECK,
-  CROSS,
-  dim
-} from "./chunk-KGMF6UW4.js";
-
-// src/commands/add.ts
-import path from "path";
-
-// 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 ? path.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 = path.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;
-    let migrated = null;
-    try {
-      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 ${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;
-  }
-  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-4E46BULJ.js

@@ -1,79 +0,0 @@
-// src/schema/index.ts
-import { z } from "zod";
-var registryItemTypeSchema = z.enum([
-  "registry:ui",
-  "registry:component",
-  "registry:hook",
-  "registry:lib",
-  "registry:style",
-  "registry:font"
-]);
-var registryItemFileSchema = z.object({
-  path: z.string(),
-  type: registryItemTypeSchema,
-  content: z.string().optional(),
-  target: z.string().optional()
-});
-var registryItemFontSchema = z.object({
-  family: z.string(),
-  provider: z.literal("google"),
-  import: z.string(),
-  variable: z.string(),
-  weight: z.array(z.string()).optional(),
-  subsets: z.array(z.string()).optional(),
-  selector: z.string().optional(),
-  dependency: z.string().optional()
-});
-var registryItemCommonSchema = z.object({
-  name: z.string(),
-  dependencies: z.array(z.string()).optional(),
-  registryDependencies: z.array(z.string()).optional(),
-  files: z.array(registryItemFileSchema).optional()
-});
-var registryItemSchema = z.discriminatedUnion("type", [
-  registryItemCommonSchema.extend({
-    type: z.literal("registry:font"),
-    font: registryItemFontSchema,
-    files: z.array(registryItemFileSchema).optional()
-  }),
-  registryItemCommonSchema.extend({
-    type: registryItemTypeSchema.exclude(["registry:font"]),
-    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(registryIndexEntrySchema)
-});
-var configSchema = z.object({
-  $schema: z.string().optional(),
-  version: z.literal(1),
-  css: z.string(),
-  aliases: z.object({
-    components: z.string(),
-    utils: z.string(),
-    ui: z.string(),
-    lib: z.string(),
-    hooks: z.string()
-  }),
-  fonts: z.object({
-    strategy: z.enum(["stera-default", "keep-existing", "skip"]),
-    nextFont: z.boolean().optional()
-  }).optional()
-});
-
-export {
-  registryItemTypeSchema,
-  registryItemFileSchema,
-  registryItemFontSchema,
-  registryItemSchema,
-  registryIndexEntrySchema,
-  registryIndexSchema,
-  configSchema
-};

package/dist/chunk-5NLD52O5.js

@@ -1,376 +0,0 @@
-#!/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
-};