stera-ui 0.1.0 → 0.1.2

package/dist/chunk-57DNZ2YS.js

@@ -0,0 +1,46 @@
+// src/schema/index.ts
+import { z } from "zod";
+var registryItemTypeSchema = z.enum([
+  "registry:ui",
+  "registry:component",
+  "registry:hook",
+  "registry:lib",
+  "registry:style"
+]);
+var registryItemFileSchema = z.object({
+  path: z.string(),
+  type: registryItemTypeSchema,
+  content: z.string().optional(),
+  target: z.string().optional()
+});
+var registryItemSchema = z.object({
+  name: z.string(),
+  type: registryItemTypeSchema,
+  dependencies: z.array(z.string()).optional(),
+  registryDependencies: z.array(z.string()).optional(),
+  files: z.array(registryItemFileSchema)
+});
+var registryIndexSchema = z.object({
+  name: z.string(),
+  items: z.array(registryItemSchema)
+});
+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()
+  })
+});
+
+export {
+  registryItemTypeSchema,
+  registryItemFileSchema,
+  registryItemSchema,
+  registryIndexSchema,
+  configSchema
+};

package/dist/chunk-PUJGGJCB.js

@@ -0,0 +1,362 @@
+// 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);
+  return { hasSrc, framework, rsc, existingCssFile };
+}
+
+// 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 { spawn } from "child_process";
+
+// 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
+function detectPackageManager(cwd) {
+  if (fs4.existsSync(path5.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs4.existsSync(path5.join(cwd, "bun.lockb"))) return "bun";
+  if (fs4.existsSync(path5.join(cwd, "yarn.lock"))) return "yarn";
+  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 = detectPackageManager(cwd);
+  const [cmd, args] = getInstallArgs(pm, toInstall);
+  const spinner = createSpinner(`Installing with ${pm}`);
+  await new Promise((resolve, reject) => {
+    const proc = spawn(cmd, args, { cwd, stdio: "pipe" });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        spinner.succeed(`Installed with ${pm}`);
+        resolve();
+      } else {
+        spinner.fail(`Install failed (exit ${code})`);
+        reject(new Error(`${pm} exited with code ${code}`));
+      }
+    });
+    proc.on("error", (err) => {
+      spinner.fail(`Install failed`);
+      reject(err);
+    });
+  });
+}
+
+// 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 };
+}
+
+export {
+  applyTransforms,
+  transformImports,
+  resolveOutputPath,
+  CONFIG_FILE,
+  findConfigPath,
+  loadConfig2 as loadConfig,
+  detectProject,
+  hasGlobalsCss,
+  brand,
+  dim,
+  LOGO,
+  CHECK,
+  CROSS,
+  WARN,
+  createSpinner,
+  detectPackageManager,
+  installDependencies,
+  writeComponentFiles
+};

package/dist/chunk-T3QWOVJR.js

@@ -0,0 +1,60 @@
+// src/registry/index.ts
+var REGISTRY_URL = process.env.REGISTRY_URL ?? "https://ui.stera.sh/r";
+var _indexCache = null;
+async function fetchJSON(url) {
+  const res = await fetch(url);
+  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`
+  );
+  _indexCache = data.items;
+  return _indexCache;
+}
+async function fetchRegistryItem(name) {
+  return fetchJSON(`${REGISTRY_URL}/${name}.json`);
+}
+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 resolved = /* @__PURE__ */ new Map();
+  const queue = [...names];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    if (resolved.has(name)) continue;
+    let item;
+    try {
+      item = await fetchRegistryItem(name);
+    } catch {
+      console.error(`Component "${name}" not found in registry.`);
+      process.exit(1);
+    }
+    resolved.set(name, item);
+    if (item.registryDependencies) {
+      for (const dep of item.registryDependencies) {
+        if (!resolved.has(dep)) {
+          queue.push(dep);
+        }
+      }
+    }
+  }
+  return Array.from(resolved.values());
+}
+
+export {
+  fetchRegistryIndex,
+  fetchRegistryItem,
+  getComponent,
+  getAllComponents,
+  resolveDependencies
+};