@fumadocs/cli 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Fuma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/build/index.d.ts

@@ -0,0 +1,104 @@
+interface Component {
+    name: string;
+    description?: string;
+    files: string[];
+    /**
+     * Don't list the component in registry index file
+     */
+    unlisted?: boolean;
+    /**
+     * Map imported file paths
+     */
+    mapImportPath?: Record<string, string | {
+        type: 'component';
+        registry: string;
+        name: string;
+        file: string;
+    }>;
+}
+type NamespaceType = 'components' | 'hooks' | 'lib';
+interface PackageJson {
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+}
+interface Registry {
+    /**
+     * The path of registry, needed to resolve relative paths
+     */
+    path: string;
+    /**
+     * Extend on existing registry
+     */
+    on?: Record<string, {
+        type: 'remote';
+        registry: Output;
+    } | {
+        type: 'local';
+        registry: Registry;
+    }>;
+    /**
+     * The root directory project, used to resolve config paths
+     */
+    rootDir: string;
+    namespaces?: Record<string, NamespaceType>;
+    tsconfigPath?: string;
+    packageJson?: string | PackageJson;
+    components: Component[];
+    dependencies?: Record<string, {
+        type: 'runtime' | 'dev';
+        version?: string;
+    }>;
+}
+interface Output {
+    index: OutputIndex[];
+    components: OutputComponent[];
+}
+interface OutputIndex {
+    name: string;
+    description?: string;
+}
+interface OutputFile {
+    path: string;
+    content: string;
+    /**
+     * Import reference path - path in `files`
+     */
+    imports: Record<string, string>;
+}
+interface OutputComponent {
+    name: string;
+    files: OutputFile[];
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    subComponents: string[];
+}
+declare function build(registry: Registry): Promise<Output>;
+
+interface DependencyInfo {
+    type: 'runtime' | 'dev';
+    version?: string;
+}
+interface ComponentBuilder {
+    rootDir: string;
+    registryDir: string;
+    resolveDep: (specifier: string) => DependencyInfo & {
+        name: string;
+    };
+    resolveOutputPath: (path: string) => string;
+    getSubComponent: (path: string) => {
+        component: Component;
+    } | undefined;
+}
+declare function createComponentBuilder(registry: Registry, packageJson: PackageJson | undefined, registryDir: string, rootDir: string): ComponentBuilder;
+
+declare function writeOutput(dir: string, out: Output, options?: {
+    /**
+     * Remove all content from the `dir` directory
+     *
+     * @defaultValue false
+     */
+    cleanDir?: boolean;
+    log?: boolean;
+}): Promise<void>;
+
+export { type Component, type ComponentBuilder, type DependencyInfo, type NamespaceType, type Output, type OutputComponent, type OutputFile, type OutputIndex, type PackageJson, type Registry, build, createComponentBuilder, writeOutput };

package/dist/build/index.js

@@ -0,0 +1,284 @@
+import {
+  exists
+} from "../chunk-WBCEM7RC.js";
+
+// src/build/index.ts
+import * as fs2 from "node:fs/promises";
+import * as path4 from "node:path";
+import picocolors from "picocolors";
+
+// src/build/build-registry.ts
+import * as fs from "node:fs/promises";
+import * as path3 from "node:path";
+import { Project } from "ts-morph";
+
+// src/build/build-file.ts
+import * as path from "node:path";
+async function buildFile(filePath, sourceFile, builder, comp, processedFiles) {
+  processedFiles.add(filePath);
+  const out = {
+    imports: {},
+    content: "",
+    path: filePath
+  };
+  const processed = {
+    files: [out],
+    dependencies: /* @__PURE__ */ new Map(),
+    devDependencies: /* @__PURE__ */ new Map(),
+    subComponents: /* @__PURE__ */ new Set()
+  };
+  async 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 (comp.mapImportPath && name in comp.mapImportPath) {
+      const resolver = comp.mapImportPath[name];
+      if (typeof resolver === "string") {
+        specifier.setLiteralValue(resolver);
+        specifiedFile = getSpecifiedFile();
+        if (!specifiedFile) return;
+      } else {
+        processed.subComponents.add(resolver.name);
+        out.imports[specifier.getLiteralValue()] = resolver.file;
+        return;
+      }
+    }
+    if (specifiedFile.isInNodeModules() || specifiedFile.isDeclarationFile()) {
+      const info = builder.resolveDep(specifier.getLiteralValue());
+      if (info.type === "dev") {
+        processed.devDependencies.set(info.name, info.version ?? "");
+      } else {
+        processed.dependencies.set(info.name, info.version ?? "");
+      }
+      return;
+    }
+    const sub = builder.getSubComponent(specifiedFile.getFilePath());
+    if (sub) {
+      processed.subComponents.add(sub.component.name);
+      out.imports[specifier.getLiteralValue()] = builder.resolveOutputPath(
+        specifiedFile.getFilePath()
+      );
+      return;
+    }
+    const referenceOutputPath = builder.resolveOutputPath(
+      specifiedFile.getFilePath()
+    );
+    if (!processedFiles.has(referenceOutputPath)) {
+      const outFile = await buildFile(
+        referenceOutputPath,
+        specifiedFile,
+        builder,
+        comp,
+        processedFiles
+      );
+      merge(processed, outFile);
+    }
+    out.imports[specifier.getLiteralValue()] = referenceOutputPath;
+  }
+  for (const item of sourceFile.getImportDeclarations()) {
+    await process2(
+      item.getModuleSpecifier(),
+      () => item.getModuleSpecifierSourceFile()
+    );
+  }
+  for (const item of sourceFile.getExportDeclarations()) {
+    const specifier = item.getModuleSpecifier();
+    if (!specifier) continue;
+    await process2(specifier, () => item.getModuleSpecifierSourceFile());
+  }
+  out.content = sourceFile.getFullText();
+  return processed;
+}
+function merge(to, from) {
+  to.files.push(...from.files);
+  for (const [k, v] of from.dependencies.entries()) {
+    to.dependencies.set(k, v);
+  }
+  for (const [k, v] of from.devDependencies.entries()) {
+    to.devDependencies.set(k, v);
+  }
+  from.subComponents.forEach((item) => to.subComponents.add(item));
+}
+
+// src/build/component-builder.ts
+import path2 from "node:path";
+function createComponentBuilder(registry, packageJson, registryDir, rootDir) {
+  const fileToComponent = /* @__PURE__ */ new Map();
+  for (const comp of registry.components) {
+    for (const file of comp.files) {
+      if (fileToComponent.has(file))
+        console.warn(
+          `the same file ${file} exists in multiple component, you should make the shared file a separate component.`
+        );
+      fileToComponent.set(file, comp);
+    }
+  }
+  return {
+    registryDir,
+    rootDir,
+    resolveDep(specifier) {
+      const name = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+      if (registry.dependencies && name in registry.dependencies)
+        return {
+          ...registry.dependencies[name],
+          name
+        };
+      if (packageJson && name in packageJson.devDependencies) {
+        return {
+          type: "dev",
+          version: packageJson.devDependencies[name],
+          name
+        };
+      }
+      if (packageJson && name in packageJson.dependencies) {
+        return {
+          type: "runtime",
+          version: packageJson.dependencies[name],
+          name
+        };
+      }
+      return { type: "runtime", name };
+    },
+    resolveOutputPath(file) {
+      const relativeFile = path2.relative(registryDir, file);
+      if (registry.namespaces)
+        for (const namespace of Object.keys(registry.namespaces)) {
+          const relativePath = path2.relative(namespace, relativeFile);
+          if (relativePath.startsWith("../") || path2.isAbsolute(relativePath))
+            continue;
+          return `${registry.namespaces[namespace]}:${relativePath}`;
+        }
+      return path2.relative(rootDir, file);
+    },
+    getSubComponent(file) {
+      const relativeFile = path2.relative(registryDir, file);
+      const comp = fileToComponent.get(relativeFile);
+      if (!comp) return;
+      return {
+        component: comp
+      };
+    }
+  };
+}
+
+// src/build/build-registry.ts
+async function build(registry) {
+  const registryDir = path3.dirname(registry.path);
+  const rootDir = path3.join(registryDir, registry.rootDir);
+  const output = {
+    index: [],
+    components: []
+  };
+  const project = new Project({
+    tsConfigFilePath: registry.tsconfigPath ? path3.join(registryDir, registry.tsconfigPath) : path3.join(rootDir, "tsconfig.json")
+  });
+  const packageJson = typeof registry.packageJson !== "string" && registry.packageJson ? registry.packageJson : await fs.readFile(
+    registry.packageJson ? path3.join(registryDir, registry.packageJson) : path3.join(rootDir, "package.json")
+  ).then((res) => JSON.parse(res.toString())).catch(() => void 0);
+  const builder = createComponentBuilder(
+    registry,
+    packageJson,
+    registryDir,
+    rootDir
+  );
+  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 buildComps = registry.components.map(async (component) => {
+    const processedFiles = /* @__PURE__ */ new Set();
+    const collect = {
+      files: [],
+      subComponents: /* @__PURE__ */ new Set(),
+      devDependencies: /* @__PURE__ */ new Map(),
+      dependencies: /* @__PURE__ */ new Map()
+    };
+    const read = component.files.map((file) => path3.join(registryDir, file)).map(async (file) => {
+      const content = await fs.readFile(file);
+      const sourceFile = project.createSourceFile(file, content.toString(), {
+        overwrite: true
+      });
+      const outputPath = builder.resolveOutputPath(sourceFile.getFilePath());
+      if (processedFiles.has(outputPath)) return;
+      return buildFile(
+        outputPath,
+        sourceFile,
+        builder,
+        component,
+        processedFiles
+      );
+    });
+    const outFiles = await Promise.all(read);
+    for (const file of outFiles) {
+      if (!file) continue;
+      merge(collect, file);
+    }
+    return [
+      component,
+      {
+        name: component.name,
+        files: collect.files,
+        subComponents: Array.from(collect.subComponents),
+        dependencies: Object.fromEntries(collect.dependencies),
+        devDependencies: Object.fromEntries(collect.devDependencies)
+      }
+    ];
+  });
+  for (const [input, comp] of await Promise.all(buildComps)) {
+    if (!input.unlisted) {
+      output.index.push({
+        name: input.name,
+        description: input.description
+      });
+    }
+    output.components.push(comp);
+  }
+  return output;
+}
+
+// src/build/index.ts
+async function writeOutput(dir, out, options = {}) {
+  const { log = true } = options;
+  if (options.cleanDir && await exists(dir)) {
+    await fs2.rm(dir, {
+      recursive: true
+    });
+    if (log) {
+      console.log(picocolors.bold(picocolors.greenBright("Cleaned directory")));
+    }
+  }
+  async function writeFile2(file, content) {
+    if (!log) return;
+    await fs2.mkdir(path4.dirname(file), { recursive: true });
+    await fs2.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`)}`
+    );
+  }
+  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);
+  }
+  write.push(writeIndex());
+  await Promise.all(write);
+}
+export {
+  build,
+  createComponentBuilder,
+  writeOutput
+};

package/dist/chunk-WBCEM7RC.js

@@ -0,0 +1,19 @@
+// src/utils/fs.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+async function exists(pathLike) {
+  try {
+    await fs.access(pathLike);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isRelative(from, to) {
+  return !path.relative(from, to).startsWith(`..${path.sep}`);
+}
+
+export {
+  exists,
+  isRelative
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node