@fumadocs/cli 0.2.1 → 1.0.0

package/dist/build/index.js

@@ -1,12 +1,97 @@
-import {
-  exists
-} from "../chunk-DG6SFM2G.js";
-
 // src/build/index.ts
 import * as fs3 from "fs/promises";
 import * as path4 from "path";
 import picocolors from "picocolors";
 
+// src/build/shadcn.ts
+function mapDeps(deps) {
+  return Object.entries(deps).map(([k, v]) => {
+    if (v) return `${k}@${v}`;
+    return k;
+  });
+}
+function escapeName(name) {
+  return name;
+}
+function toShadcnRegistry(out, baseUrl) {
+  return {
+    homepage: baseUrl,
+    name: out.name,
+    items: out.components.map((comp) => componentToShadcn(comp, baseUrl))
+  };
+}
+function componentToShadcn(comp, baseUrl) {
+  return {
+    extends: "none",
+    type: "registry:block",
+    name: escapeName(comp.name),
+    title: comp.title ?? comp.name,
+    description: comp.description,
+    dependencies: mapDeps(comp.dependencies),
+    devDependencies: mapDeps(comp.devDependencies),
+    registryDependencies: comp.subComponents.map((comp2) => {
+      if (comp2.startsWith("https://") || comp2.startsWith("http://"))
+        return comp2;
+      return new URL(`/r/${escapeName(comp2)}.json`, baseUrl).toString();
+    }),
+    files: comp.files.map((file) => {
+      return {
+        type: {
+          components: "registry:component",
+          lib: "registry:lib",
+          css: "registry:style",
+          route: "registry:page",
+          ui: "registry:ui",
+          block: "registry:block"
+        }[file.type],
+        content: file.content,
+        path: file.path,
+        target: file.target
+      };
+    })
+  };
+}
+
+// src/build/validate.ts
+function validateOutput(registry) {
+  function validateComponent(comp, ctx = {}) {
+    const { stack = /* @__PURE__ */ new Map() } = ctx;
+    for (const file of comp.files) {
+      const parents = stack.get(file.path);
+      if (parents) {
+        parents.add(comp.name);
+      } else {
+        stack.set(file.path, /* @__PURE__ */ new Set([comp.name]));
+      }
+    }
+    for (const name of comp.subComponents) {
+      const subComp = registry.components.find((item) => item.name === name);
+      if (!subComp) {
+        console.warn(`skipped component ${name}: not found`);
+        continue;
+      }
+      validateComponent(subComp, {
+        stack
+      });
+    }
+    for (const file of comp.files) {
+      const parents = stack.get(file.path);
+      if (!parents) continue;
+      if (parents.size <= 1) continue;
+      throw new Error(
+        `Duplicated file in same component ${Array.from(parents).join(", ")}: ${file.path}`
+      );
+    }
+  }
+  const compSet = /* @__PURE__ */ new Set();
+  for (const comp of registry.components) {
+    if (compSet.has(comp.name))
+      throw new Error(`duplicated component name ${comp.name}`);
+    compSet.add(comp.name);
+    validateComponent(comp);
+  }
+}
+
 // src/build/build-registry.ts
 import * as fs2 from "fs/promises";
 import * as path3 from "path";
@@ -14,86 +99,51 @@ import * as path3 from "path";
 // src/build/build-file.ts
 import * as path from "path";
 import { ts } from "ts-morph";
-async function buildFile(inputPath, outputPath, builder, comp, onReference) {
-  const out = {
-    imports: {},
-    content: "",
-    path: outputPath
-  };
-  const importMap = {
-    ...builder.registry.mapImportPath,
-    ...comp.mapImportPath
-  };
-  function process2(specifier, getSpecifiedFile) {
-    let specifiedFile = getSpecifiedFile();
-    if (!specifiedFile) return;
-    const name = specifiedFile.isInNodeModules() ? builder.resolveDep(specifier.getLiteralValue()).name : path.relative(builder.registryDir, specifiedFile.getFilePath());
-    if (name in importMap) {
-      const resolver = importMap[name];
-      if (typeof resolver === "string") {
-        specifier.setLiteralValue(resolver);
-        specifiedFile = getSpecifiedFile();
-        if (!specifiedFile) return;
-      } else if (resolver.type === "dependency") {
-        const info = builder.resolveDep(resolver.name);
-        const value2 = onReference({
-          type: "dependency",
-          name: info.name,
-          version: info.version ?? "",
-          isDev: info.type === "dev"
-        });
-        if (value2) out.imports[specifier.getLiteralValue()] = value2;
-        return;
-      } else {
-        const sub2 = builder.getComponentByName(
-          resolver.name,
-          resolver.registry
-        );
-        if (!sub2)
-          throw new Error(`Failed to resolve sub component ${resolver.name}`);
-        const value2 = onReference({
-          type: "sub-component",
-          resolved: sub2,
-          targetFile: resolver.file
-        });
-        if (value2) out.imports[specifier.getLiteralValue()] = value2;
-        return;
-      }
+async function buildFile(file, builder, comp, writeReference) {
+  const sourceFilePath = path.join(builder.registryDir, file.path);
+  const defaultResolve = (specifier, specified) => {
+    let filePath;
+    if (specified) {
+      filePath = specified.getFilePath();
+    } else if (specifier.startsWith("./") || specifier.startsWith("../")) {
+      filePath = path.join(path.dirname(sourceFilePath), specifier);
+    } else {
+      throw new Error("Unknown specifier " + specifier);
     }
-    if (specifiedFile.isInNodeModules() || specifiedFile.isDeclarationFile()) {
-      const info = builder.resolveDep(specifier.getLiteralValue());
-      const value2 = onReference({
+    if (path.relative(builder.registryDir, filePath).startsWith("../")) {
+      return {
         type: "dependency",
-        name: info.name,
-        version: info.version ?? "",
-        isDev: info.type === "dev"
-      });
-      if (value2) out.imports[specifier.getLiteralValue()] = value2;
-      return;
+        dep: builder.getDepFromSpecifier(specifier),
+        specifier
+      };
     }
-    const sub = builder.getSubComponent(specifiedFile.getFilePath());
+    const sub = builder.getSubComponent(filePath);
     if (sub) {
-      const value2 = onReference({
+      return {
         type: "sub-component",
         resolved: {
           type: "local",
-          component: sub
-        },
-        targetFile: path.relative(
-          builder.registryDir,
-          specifiedFile.getFilePath()
-        )
-      });
-      if (value2) out.imports[specifier.getLiteralValue()] = value2;
-      return;
+          component: sub.component,
+          file: sub.file
+        }
+      };
     }
-    const value = onReference({
+    return {
       type: "file",
-      file: specifiedFile.getFilePath()
-    });
-    if (value) out.imports[specifier.getLiteralValue()] = value;
+      file: filePath
+    };
+  };
+  function process2(specifier, getSpecifiedFile) {
+    const onResolve = comp.onResolve ?? builder.registry.onResolve;
+    let resolved = defaultResolve(
+      specifier.getLiteralValue(),
+      getSpecifiedFile()
+    );
+    if (onResolve) resolved = onResolve(resolved);
+    const out = writeReference(resolved);
+    if (out) specifier.setLiteralValue(out);
   }
-  const sourceFile = await builder.createSourceFile(inputPath);
+  const sourceFile = await builder.createSourceFile(sourceFilePath);
   for (const item of sourceFile.getImportDeclarations()) {
     process2(
       item.getModuleSpecifier(),
@@ -116,8 +166,12 @@ async function buildFile(inputPath, outputPath, builder, comp, onReference) {
       );
     }
   }
-  out.content = sourceFile.getFullText();
-  return out;
+  return {
+    content: sourceFile.getFullText(),
+    type: file.type,
+    path: file.path,
+    target: file.target
+  };
 }
 
 // src/build/component-builder.ts
@@ -125,46 +179,47 @@ import path2 from "path";
 import { Project } from "ts-morph";
 import * as fs from "fs/promises";
 function createComponentBuilder(registry, packageJson) {
-  const rootDir = path2.join(registry.dir, registry.rootDir);
   const project = new Project({
-    tsConfigFilePath: registry.tsconfigPath ? path2.join(rootDir, registry.tsconfigPath) : path2.join(rootDir, "tsconfig.json")
+    tsConfigFilePath: path2.join(registry.dir, registry.tsconfigPath)
   });
   const fileToComponent = /* @__PURE__ */ new Map();
   for (const comp of registry.components) {
     for (const file of comp.files) {
-      const filePath = typeof file === "string" ? file : file.in;
-      if (fileToComponent.has(filePath))
+      if (fileToComponent.has(file.path))
         console.warn(
-          `the same file ${file} exists in multiple component, you should make the shared file a separate component.`
+          `the same file ${file.path} exists in multiple component, you should make the shared file a separate component.`
         );
-      fileToComponent.set(filePath, comp);
+      fileToComponent.set(file.path, [comp, file]);
     }
   }
+  const deps = {
+    ...packageJson?.dependencies,
+    ...registry.dependencies
+  };
+  const devDeps = {
+    ...packageJson?.devDependencies,
+    ...registry.devDependencies
+  };
   return {
     registryDir: registry.dir,
     registry,
-    resolveDep(specifier) {
-      const name = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
-      if (registry.dependencies && name in registry.dependencies)
+    getDepFromSpecifier(specifier) {
+      return specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+    },
+    getDepInfo(name) {
+      if (name in deps)
         return {
-          ...registry.dependencies[name],
-          name
+          name,
+          type: "runtime",
+          version: deps[name]
         };
-      if (packageJson && name in packageJson.devDependencies) {
+      if (name in devDeps)
         return {
+          name,
           type: "dev",
-          version: packageJson.devDependencies[name],
-          name
+          version: devDeps[name]
         };
-      }
-      if (packageJson && name in packageJson.dependencies) {
-        return {
-          type: "runtime",
-          version: packageJson.dependencies[name],
-          name
-        };
-      }
-      return { type: "runtime", name };
+      console.warn(`dep info for ${name} cannot be found`);
     },
     async createSourceFile(file) {
       const content = await fs.readFile(file);
@@ -172,64 +227,17 @@ function createComponentBuilder(registry, packageJson) {
         overwrite: true
       });
     },
-    getComponentByName(name, registryName) {
-      if (registryName) {
-        const child = registry.on[registryName];
-        const comp2 = child.registry.components.find(
-          (comp3) => comp3.name === name
-        );
-        if (comp2) {
-          return {
-            type: child.type,
-            registryName,
-            component: comp2
-          };
-        }
-        return;
-      }
-      const comp = registry.components.find((comp2) => comp2.name === name);
-      if (comp) {
-        return {
-          type: "local",
-          registryName,
-          component: comp
-        };
-      }
-    },
-    resolveOutputPath(file, registryName, namespace) {
-      let targetRegistry = registry;
-      if (registryName && registry.on[registryName].type === "local") {
-        targetRegistry = registry.on[registryName].registry;
-      }
-      const parsed = file.split(":", 2);
-      if (parsed.length > 1) {
-        namespace ??= parsed[0];
-        file = parsed[1];
-      }
-      if (!path2.isAbsolute(file)) {
-        file = path2.join(targetRegistry.dir, file);
-      }
-      const rootDir2 = path2.join(targetRegistry.dir, targetRegistry.rootDir);
-      if (namespace) {
-        return `${namespace}:${path2.relative(rootDir2, file)}`;
-      }
-      if (targetRegistry.namespaces)
-        for (const namespace2 in targetRegistry.namespaces) {
-          const relativePath = path2.relative(
-            path2.join(targetRegistry.dir, namespace2),
-            file
-          );
-          if (!relativePath.startsWith("../")) {
-            return `${targetRegistry.namespaces[namespace2]}:${relativePath}`;
-          }
-        }
-      return path2.relative(rootDir2, file);
+    getComponentByName(name) {
+      return registry.components.find((comp) => comp.name === name);
     },
     getSubComponent(file) {
       const relativeFile = path2.relative(registry.dir, file);
       const comp = fileToComponent.get(relativeFile);
       if (!comp) return;
-      return comp;
+      return {
+        component: comp[0],
+        file: comp[1]
+      };
     }
   };
 }
@@ -237,30 +245,16 @@ function createComponentBuilder(registry, packageJson) {
 // src/build/build-registry.ts
 async function build(registry) {
   const output = {
+    name: registry.name,
     index: [],
     components: []
   };
   function readPackageJson() {
-    if (typeof registry.packageJson !== "string" && registry.packageJson)
-      return registry.packageJson;
-    return fs2.readFile(
-      registry.packageJson ? path3.join(registry.dir, registry.packageJson) : path3.join(registry.dir, registry.rootDir, "package.json")
-    ).then((res) => JSON.parse(res.toString())).catch(() => void 0);
+    if (typeof registry.packageJson !== "string") return registry.packageJson;
+    return fs2.readFile(path3.join(registry.dir, registry.packageJson)).then((res) => JSON.parse(res.toString())).catch(() => void 0);
   }
   const packageJson = await readPackageJson();
   const builder = createComponentBuilder(registry, packageJson);
-  const buildExtendRegistries = Object.values(registry.on ?? {}).map(
-    async (schema) => {
-      if (schema.type === "remote") {
-        return schema.registry;
-      }
-      return await build(schema.registry);
-    }
-  );
-  for (const built of await Promise.all(buildExtendRegistries)) {
-    output.components.push(...built.components);
-    output.index.push(...built.index);
-  }
   const builtComps = await Promise.all(
     registry.components.map((component) => buildComponent(component, builder))
   );
@@ -268,11 +262,13 @@ async function build(registry) {
     if (!input.unlisted) {
       output.index.push({
         name: input.name,
+        title: input.title,
         description: input.description
       });
     }
     output.components.push(comp);
   }
+  validateOutput(output);
   return output;
 }
 async function buildComponent(component, builder) {
@@ -280,70 +276,48 @@ async function buildComponent(component, builder) {
   const subComponents = /* @__PURE__ */ new Set();
   const devDependencies = /* @__PURE__ */ new Map();
   const dependencies = /* @__PURE__ */ new Map();
+  function toImportPath(file) {
+    let filePath = file.target ?? file.path;
+    if (filePath.startsWith("./")) filePath = filePath.slice(2);
+    return `@/${filePath.replaceAll(path3.sep, "/")}`;
+  }
   async function build2(file) {
-    let inputPath;
-    let outputPath;
-    if (typeof file === "string") {
-      let namespace;
-      const parsed = file.split(":", 2);
-      if (parsed.length > 1) {
-        namespace = parsed[0];
-        inputPath = path3.join(builder.registryDir, parsed[1]);
-      } else {
-        inputPath = path3.join(builder.registryDir, file);
-      }
-      outputPath = builder.resolveOutputPath(file, void 0, namespace);
-    } else {
-      inputPath = path3.join(builder.registryDir, file.in);
-      outputPath = file.out;
-    }
-    if (processedFiles.has(inputPath)) return [];
-    processedFiles.add(inputPath);
+    if (processedFiles.has(file.path)) return [];
+    processedFiles.add(file.path);
     const queue = [];
-    const result = await buildFile(
-      inputPath,
-      outputPath,
-      builder,
-      component,
-      (reference) => {
-        if (reference.type === "file") {
-          queue.push(path3.relative(builder.registryDir, reference.file));
-          return builder.resolveOutputPath(reference.file);
+    const result = await buildFile(file, builder, component, (reference) => {
+      if (reference.type === "custom") return reference.specifier;
+      if (reference.type === "file") {
+        const refFile = builder.registry.onUnknownFile?.(reference.file);
+        if (refFile) {
+          queue.push(refFile);
+          return toImportPath(refFile);
         }
-        if (reference.type === "sub-component") {
-          const resolved = reference.resolved;
+        throw new Error(
+          `Unknown file ${reference.file} referenced by ${file.path}`
+        );
+      }
+      if (reference.type === "sub-component") {
+        const resolved = reference.resolved;
+        if (resolved.component.name !== component.name)
           subComponents.add(resolved.component.name);
-          if (resolved.type === "remote") {
-            return reference.targetFile;
-          }
-          for (const childFile of resolved.component.files) {
-            if (typeof childFile === "string" && childFile === reference.targetFile) {
-              return builder.resolveOutputPath(
-                childFile,
-                reference.resolved.registryName
-              );
-            }
-            if (typeof childFile === "object" && childFile.in === reference.targetFile) {
-              return childFile.out;
-            }
-          }
-          throw new Error(
-            `Failed to find sub component ${resolved.component.name}'s ${reference.targetFile} referenced by ${inputPath}`
-          );
-        }
-        if (reference.type === "dependency") {
-          if (reference.isDev)
-            devDependencies.set(reference.name, reference.version);
-          else dependencies.set(reference.name, reference.version);
-        }
+        return toImportPath(resolved.file);
       }
-    );
+      const dep = builder.getDepInfo(reference.dep);
+      if (dep) {
+        const map = dep.type === "dev" ? devDependencies : dependencies;
+        map.set(dep.name, dep.version);
+      }
+      return reference.specifier;
+    });
     return [result, ...(await Promise.all(queue.map(build2))).flat()];
   }
   return [
     component,
     {
       name: component.name,
+      title: component.title,
+      description: component.description,
       files: (await Promise.all(component.files.map(build2))).flat(),
       subComponents: Array.from(subComponents),
       dependencies: Object.fromEntries(dependencies),
@@ -353,40 +327,72 @@ async function buildComponent(component, builder) {
 }
 
 // src/build/index.ts
-async function writeOutput(dir, out, options = {}) {
-  const { log = true } = options;
-  if (options.cleanDir && await exists(dir)) {
+function combineRegistry(...items) {
+  const out = {
+    index: [],
+    components: [],
+    name: items[0].name
+  };
+  for (const item of items) {
+    out.components.push(...item.components);
+    out.index.push(...item.index);
+  }
+  validateOutput(out);
+  return out;
+}
+async function writeShadcnRegistry(out, options) {
+  const { dir, cleanDir = false, baseUrl } = options;
+  if (cleanDir) {
     await fs3.rm(dir, {
-      recursive: true
+      recursive: true,
+      force: true
     });
-    if (log) {
-      console.log(picocolors.bold(picocolors.greenBright("Cleaned directory")));
-    }
+    console.log(picocolors.bold(picocolors.greenBright("Cleaned directory")));
   }
-  async function writeFile2(file, content) {
-    if (!log) return;
-    await fs3.mkdir(path4.dirname(file), { recursive: true });
-    await fs3.writeFile(file, content);
-    const size = (Buffer.byteLength(content) / 1024).toFixed(2);
-    console.log(
-      `${picocolors.greenBright("+")} ${path4.relative(process.cwd(), file)} ${picocolors.dim(`${size.toString()} KB`)}`
-    );
+  await Promise.all(
+    toShadcnRegistry(out, baseUrl).items.map(async (item) => {
+      const file = path4.join(dir, `${item.name}.json`);
+      await writeFile2(file, JSON.stringify(item, null, 2));
+    })
+  );
+}
+async function writeFumadocsRegistry(out, options) {
+  const { dir, cleanDir = false, log = true } = options;
+  if (cleanDir) {
+    await fs3.rm(dir, {
+      recursive: true,
+      force: true
+    });
+    console.log(picocolors.bold(picocolors.greenBright("Cleaned directory")));
   }
-  const write = out.components.map(async (comp) => {
-    const file = path4.join(dir, `${comp.name}.json`);
-    const json = JSON.stringify(comp, null, 2);
-    await writeFile2(file, json);
-  });
   async function writeIndex() {
     const file = path4.join(dir, "_registry.json");
     const json = JSON.stringify(out.index, null, 2);
-    await writeFile2(file, json);
+    await writeFile2(file, json, log);
   }
+  const write = out.components.map(async (comp) => {
+    const file = path4.join(dir, `${comp.name}.json`);
+    const json = JSON.stringify(comp, null, 2);
+    await writeFile2(file, json, log);
+  });
   write.push(writeIndex());
   await Promise.all(write);
 }
+async function writeFile2(file, content, log = true) {
+  await fs3.mkdir(path4.dirname(file), { recursive: true });
+  await fs3.writeFile(file, content);
+  if (log) {
+    const size = (Buffer.byteLength(content) / 1024).toFixed(2);
+    console.log(
+      `${picocolors.greenBright("+")} ${path4.relative(process.cwd(), file)} ${picocolors.dim(`${size} KB`)}`
+    );
+  }
+}
 export {
   build,
+  combineRegistry,
   createComponentBuilder,
-  writeOutput
+  toShadcnRegistry,
+  writeFumadocsRegistry,
+  writeShadcnRegistry
 };