stera-ui 0.5.0 → 0.6.1

package/dist/chunk-KKUJRJ2N.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+import {
+  CHECK,
+  CROSS,
+  brand
+} from "./chunk-KGMF6UW4.js";
+
+// 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()
+});
+
+// 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 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)));
+}
+
+// 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}
+`);
+    }
+  };
+}
+
+export {
+  ComponentNotFoundError,
+  fetchRegistryItem,
+  getAllComponents,
+  resolveDependencies,
+  createSpinner
+};

package/dist/{chunk-F4NT3JC6.js → chunk-SIXUH4HI.js}

@@ -1,6 +1,6 @@
 import {
   fetchRegistryItem
-} from "./chunk-T3QWOVJR.js";
+} from "./chunk-BJNLGEZJ.js";
 
 // src/utils/transform.ts
 function applyTransforms(content, ctx, transforms) {
@@ -22,19 +22,31 @@ var transformImports = (content, ctx) => {
   const { aliases } = ctx.config;
   const rules = [];
   if (aliases.utils !== DEFAULT_ALIASES.utils) {
-    rules.push({ type: "exact", from: DEFAULT_ALIASES.utils, to: 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 });
+    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 });
+    rules.push({
+      type: "prefix",
+      from: DEFAULT_ALIASES.hooks,
+      to: aliases.hooks
+    });
   }
   if (rules.length === 0) {
     return content;
@@ -68,16 +80,30 @@ var TYPE_TO_ALIAS = {
   "registry:hook": "hooks",
   "registry:component": "components"
 };
-function resolveAlias(alias, projectRoot) {
+var matcherCache = /* @__PURE__ */ new Map();
+function getTsConfigMatcher(projectRoot) {
+  let matcher = matcherCache.get(projectRoot);
+  if (matcher !== void 0) return matcher;
   const tsConfig = loadConfig(projectRoot);
-  if (tsConfig.resultType === "success" && Object.keys(tsConfig.paths).length > 0) {
-    const hasMatchingPrefix = Object.keys(tsConfig.paths).some((key) => {
+  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 match = createMatchPath(tsConfig.absoluteBaseUrl, tsConfig.paths);
-      const resolved = match(alias, void 0, () => true, [".ts", ".tsx"]);
+      const resolved = matcher.match(alias, void 0, () => true, [
+        ".ts",
+        ".tsx"
+      ]);
       if (resolved) {
         return path.relative(projectRoot, resolved);
       }
@@ -379,7 +405,9 @@ async function installDependencies(deps, cwd) {
   if (fs5.existsSync(pkgPath)) {
     try {
       const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
-      existing = new Set(Object.keys({ ...pkg.dependencies, ...pkg.devDependencies }));
+      existing = new Set(
+        Object.keys({ ...pkg.dependencies, ...pkg.devDependencies })
+      );
     } catch {
     }
   }
@@ -407,19 +435,18 @@ or use "pnpm add -w <package>" manually to install at the root.`
 // src/utils/write-files.ts
 import fs6 from "fs";
 import path6 from "path";
-import readline from "readline/promises";
+import { confirm } from "@inquirer/prompts";
 async function confirmOverwrite(relativePath) {
   if (!process.stdin.isTTY) {
-    console.log(`  Skipping ${relativePath} (already exists, use --overwrite to replace)`);
+    console.log(
+      `  Skipping ${relativePath} (already exists, use --overwrite to replace)`
+    );
     return false;
   }
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
+  return confirm({
+    message: `${relativePath} already exists. Overwrite?`,
+    default: false
   });
-  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 = [];
@@ -431,13 +458,13 @@ async function writeComponentFiles(items, config, projectRoot, options = {}) {
       if (fs6.existsSync(outputPath)) {
         const existing = fs6.readFileSync(outputPath, "utf-8");
         if (existing === file.content) {
-          skipped.push(relativePath);
+          skipped.push({ path: relativePath, reason: "unchanged" });
           continue;
         }
         if (!options.overwrite) {
           const confirmed = await confirmOverwrite(relativePath);
           if (!confirmed) {
-            skipped.push(relativePath);
+            skipped.push({ path: relativePath, reason: "declined" });
             continue;
           }
         }