stera-ui 0.1.0

package/dist/registry/index.d.ts

@@ -0,0 +1,32 @@
+import { RegistryItem } from '../schema/index.js';
+import 'zod';
+
+interface RegistryIndexItem {
+    name: string;
+    type: string;
+    dependencies?: string[];
+    registryDependencies?: string[];
+}
+/**
+ * Fetch the registry index (component list without file contents).
+ */
+declare function fetchRegistryIndex(): Promise<RegistryIndexItem[]>;
+/**
+ * Fetch a single registry item with its file contents.
+ */
+declare function fetchRegistryItem(name: string): Promise<RegistryItem>;
+/**
+ * Get a component from the registry index (no file contents).
+ */
+declare function getComponent(name: string): Promise<RegistryIndexItem | undefined>;
+/**
+ * Get all components from the registry index.
+ */
+declare function getAllComponents(): Promise<RegistryIndexItem[]>;
+/**
+ * Resolve all dependencies for the given component names.
+ * Fetches full registry items (with file contents) for each.
+ */
+declare function resolveDependencies(names: string[]): Promise<RegistryItem[]>;
+
+export { RegistryItem, fetchRegistryIndex, fetchRegistryItem, getAllComponents, getComponent, resolveDependencies };

package/dist/registry/index.js

@@ -0,0 +1,59 @@
+// src/registry/index.ts
+var REGISTRY_URL = process.env.REGISTRY_URL ?? "https://ui.stera.site/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,
+  getAllComponents,
+  getComponent,
+  resolveDependencies
+};

package/dist/schema/index.d.ts

@@ -0,0 +1,191 @@
+import { z } from 'zod';
+
+declare const registryItemTypeSchema: z.ZodEnum<["registry:ui", "registry:component", "registry:hook", "registry:lib", "registry:style"]>;
+type RegistryItemType = z.infer<typeof registryItemTypeSchema>;
+declare const registryItemFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    type: z.ZodEnum<["registry:ui", "registry:component", "registry:hook", "registry:lib", "registry:style"]>;
+    content: z.ZodOptional<z.ZodString>;
+    target: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+    path: string;
+    content?: string | undefined;
+    target?: string | undefined;
+}, {
+    type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+    path: string;
+    content?: string | undefined;
+    target?: string | undefined;
+}>;
+type RegistryItemFile = z.infer<typeof registryItemFileSchema>;
+declare const registryItemSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<["registry:ui", "registry:component", "registry:hook", "registry:lib", "registry:style"]>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    registryDependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        type: z.ZodEnum<["registry:ui", "registry:component", "registry:hook", "registry:lib", "registry:style"]>;
+        content: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+        path: string;
+        content?: string | undefined;
+        target?: string | undefined;
+    }, {
+        type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+        path: string;
+        content?: string | undefined;
+        target?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+    files: {
+        type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+        path: string;
+        content?: string | undefined;
+        target?: string | undefined;
+    }[];
+    dependencies?: string[] | undefined;
+    registryDependencies?: string[] | undefined;
+}, {
+    name: string;
+    type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+    files: {
+        type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+        path: string;
+        content?: string | undefined;
+        target?: string | undefined;
+    }[];
+    dependencies?: string[] | undefined;
+    registryDependencies?: string[] | undefined;
+}>;
+type RegistryItem = z.infer<typeof registryItemSchema>;
+declare const registryIndexSchema: z.ZodObject<{
+    name: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<["registry:ui", "registry:component", "registry:hook", "registry:lib", "registry:style"]>;
+        dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        registryDependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            type: z.ZodEnum<["registry:ui", "registry:component", "registry:hook", "registry:lib", "registry:style"]>;
+            content: z.ZodOptional<z.ZodString>;
+            target: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+            path: string;
+            content?: string | undefined;
+            target?: string | undefined;
+        }, {
+            type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+            path: string;
+            content?: string | undefined;
+            target?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+        files: {
+            type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+            path: string;
+            content?: string | undefined;
+            target?: string | undefined;
+        }[];
+        dependencies?: string[] | undefined;
+        registryDependencies?: string[] | undefined;
+    }, {
+        name: string;
+        type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+        files: {
+            type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+            path: string;
+            content?: string | undefined;
+            target?: string | undefined;
+        }[];
+        dependencies?: string[] | undefined;
+        registryDependencies?: string[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    items: {
+        name: string;
+        type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+        files: {
+            type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+            path: string;
+            content?: string | undefined;
+            target?: string | undefined;
+        }[];
+        dependencies?: string[] | undefined;
+        registryDependencies?: string[] | undefined;
+    }[];
+}, {
+    name: string;
+    items: {
+        name: string;
+        type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+        files: {
+            type: "registry:ui" | "registry:component" | "registry:hook" | "registry:lib" | "registry:style";
+            path: string;
+            content?: string | undefined;
+            target?: string | undefined;
+        }[];
+        dependencies?: string[] | undefined;
+        registryDependencies?: string[] | undefined;
+    }[];
+}>;
+type RegistryIndex = z.infer<typeof registryIndexSchema>;
+declare const configSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    version: z.ZodLiteral<1>;
+    css: z.ZodString;
+    aliases: z.ZodObject<{
+        components: z.ZodString;
+        utils: z.ZodString;
+        ui: z.ZodString;
+        lib: z.ZodString;
+        hooks: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        components: string;
+        utils: string;
+        ui: string;
+        lib: string;
+        hooks: string;
+    }, {
+        components: string;
+        utils: string;
+        ui: string;
+        lib: string;
+        hooks: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    css: string;
+    aliases: {
+        components: string;
+        utils: string;
+        ui: string;
+        lib: string;
+        hooks: string;
+    };
+    $schema?: string | undefined;
+}, {
+    version: 1;
+    css: string;
+    aliases: {
+        components: string;
+        utils: string;
+        ui: string;
+        lib: string;
+        hooks: string;
+    };
+    $schema?: string | undefined;
+}>;
+type SteraConfig = z.infer<typeof configSchema>;
+
+export { type RegistryIndex, type RegistryItem, type RegistryItemFile, type RegistryItemType, type SteraConfig, configSchema, registryIndexSchema, registryItemFileSchema, registryItemSchema, registryItemTypeSchema };

package/dist/schema/index.js

@@ -0,0 +1,45 @@
+// 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 {
+  configSchema,
+  registryIndexSchema,
+  registryItemFileSchema,
+  registryItemSchema,
+  registryItemTypeSchema
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,103 @@
+import { RegistryItem } from '../schema/index.js';
+import 'zod';
+
+interface SteraConfig {
+    $schema?: string;
+    version: 1;
+    css: string;
+    aliases: {
+        components: string;
+        utils: string;
+        ui: string;
+        lib: string;
+        hooks: string;
+    };
+}
+declare const CONFIG_FILE = "components.json";
+declare function findConfigPath(cwd: string): string | null;
+declare function loadConfig(cwd: string): SteraConfig | null;
+
+interface TransformContext {
+    config: SteraConfig;
+    filename: string;
+}
+type TransformFn = (content: string, ctx: TransformContext) => string;
+/**
+ * Apply a sequence of transforms to file content.
+ */
+declare function applyTransforms(content: string, ctx: TransformContext, transforms: TransformFn[]): string;
+
+/**
+ * Rewrite import paths in component files to match the user's configured aliases.
+ *
+ * Registry components use default aliases (e.g. `@/lib/utils`, `@/components/ui/button`).
+ * If the user configured different aliases, this transform rewrites the paths.
+ *
+ * When aliases match defaults (the common case), this is a no-op.
+ */
+declare const transformImports: TransformFn;
+
+/**
+ * Given a registry file, determine where it should be written in the consumer's project.
+ */
+declare function resolveOutputPath(config: SteraConfig, projectRoot: string, file: {
+    path: string;
+    type: string;
+}): string;
+
+interface ProjectInfo {
+    hasSrc: boolean;
+    framework: "next" | "vite" | "other";
+    rsc: boolean;
+    existingCssFile: string | null;
+}
+/**
+ * Detect the project structure to inform configuration defaults.
+ *
+ * Checks for:
+ * - src/ directory
+ * - Framework (Next.js, Vite)
+ * - React Server Components (Next.js App Router)
+ * - Existing Tailwind CSS entry file
+ */
+declare function detectProject(cwd: string): ProjectInfo;
+
+/**
+ * Check if Stera has already been initialised in the user's project.
+ * Looks for the presence of `stera-ui.css` alongside the user's CSS file.
+ */
+declare function hasGlobalsCss(config: SteraConfig, projectRoot: string): boolean;
+
+type PackageManager = "pnpm" | "npm" | "yarn" | "bun";
+declare function detectPackageManager(cwd: string): PackageManager;
+/**
+ * Install npm dependencies, skipping any already in the consumer's package.json.
+ */
+declare function installDependencies(deps: string[], cwd: string): Promise<void>;
+
+interface WriteOptions {
+    overwrite?: boolean;
+}
+interface WriteResult {
+    written: string[];
+    skipped: string[];
+}
+/**
+ * Write component files to the consumer's project.
+ * Checks for existing files and prompts before overwriting.
+ */
+declare function writeComponentFiles(items: RegistryItem[], config: SteraConfig, projectRoot: string, options?: WriteOptions): Promise<WriteResult>;
+
+declare const brand: (text: string) => string;
+declare const dim: (text: string) => string;
+declare const LOGO: string;
+declare const CHECK: string;
+declare const CROSS = "\u2717";
+declare const WARN = "!";
+
+declare function createSpinner(text: string): {
+    succeed(msg: string): void;
+    fail(msg: string): void;
+};
+
+export { CHECK, CONFIG_FILE, CROSS, LOGO, type ProjectInfo, type TransformContext, type TransformFn, WARN, type WriteOptions, type WriteResult, applyTransforms, brand, createSpinner, detectPackageManager, detectProject, dim, findConfigPath, hasGlobalsCss, installDependencies, loadConfig, resolveOutputPath, transformImports, writeComponentFiles };