@hanzo/docs-mdx 14.1.1 → 14.2.4

package/dist/chunk-UB55AMXC.js

@@ -1,274 +0,0 @@
-import {
-  ident
-} from "./chunk-PW2AZGGD.js";
-
-// src/utils/validation.ts
-var ValidationError = class extends Error {
-  constructor(message, issues) {
-    super(
-      `${message}:
-${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
-    );
-    this.title = message;
-    this.issues = issues;
-  }
-  async toStringFormatted() {
-    const picocolorsModule = await import("picocolors");
-    const picocolors = picocolorsModule.default ?? picocolorsModule;
-    return [
-      picocolors.bold(`[MDX] ${this.title}:`),
-      ...this.issues.map(
-        (issue) => picocolors.redBright(
-          `- ${picocolors.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
-        )
-      )
-    ].join("\n");
-  }
-};
-async function validate(schema, data, context, errorMessage) {
-  if (typeof schema === "function" && !("~standard" in schema)) {
-    schema = schema(context);
-  }
-  if ("~standard" in schema) {
-    const result = await schema["~standard"].validate(
-      data
-    );
-    if (result.issues) {
-      throw new ValidationError(errorMessage, result.issues);
-    }
-    return result.value;
-  }
-  return data;
-}
-
-// src/core.ts
-import path from "path";
-import fs from "fs/promises";
-var _Defaults = {
-  configPath: "source.config.ts",
-  outDir: ".source"
-};
-async function getPlugins(pluginOptions) {
-  const plugins = [];
-  for await (const option of pluginOptions) {
-    if (!option) continue;
-    if (Array.isArray(option)) plugins.push(...await getPlugins(option));
-    else plugins.push(option);
-  }
-  return plugins;
-}
-function createCore(options) {
-  let config;
-  let plugins;
-  const workspaces = /* @__PURE__ */ new Map();
-  async function transformMetadata({
-    collection,
-    filePath,
-    source
-  }, data) {
-    if (collection.schema) {
-      data = await validate(
-        collection.schema,
-        data,
-        { path: filePath, source },
-        collection.type === "doc" ? `invalid frontmatter in ${filePath}` : `invalid data in ${filePath}`
-      );
-    }
-    return data;
-  }
-  return {
-    /**
-     * Convenient cache store, reset when config changes
-     */
-    cache: /* @__PURE__ */ new Map(),
-    async init({ config: newConfig }) {
-      config = await newConfig;
-      this.cache.clear();
-      workspaces.clear();
-      plugins = await getPlugins([
-        postprocessPlugin(),
-        options.plugins,
-        config.global.plugins
-      ]);
-      for (const plugin of plugins) {
-        const out = await plugin.config?.call(this.getPluginContext(), config);
-        if (out) config = out;
-      }
-      if (!options.workspace) {
-        await Promise.all(
-          Object.entries(config.workspaces).map(async ([name, workspace]) => {
-            const core = createCore({
-              ...options,
-              outDir: path.join(options.outDir, name),
-              workspace: {
-                name,
-                parent: this,
-                dir: workspace.dir
-              }
-            });
-            await core.init({ config: workspace.config });
-            workspaces.set(name, core);
-          })
-        );
-      }
-    },
-    getWorkspaces() {
-      return workspaces;
-    },
-    getOptions() {
-      return options;
-    },
-    getConfig() {
-      return config;
-    },
-    /**
-     * The file path of compiled config file, the file may not exist (e.g. on Vite, or still compiling)
-     */
-    getCompiledConfigPath() {
-      return path.join(options.outDir, "source.config.mjs");
-    },
-    getPlugins() {
-      return plugins;
-    },
-    getCollections() {
-      return Array.from(config.collections.values());
-    },
-    getCollection(name) {
-      return config.collections.get(name);
-    },
-    getPluginContext() {
-      return {
-        core: this
-      };
-    },
-    async initServer(server) {
-      const ctx = this.getPluginContext();
-      for (const plugin of plugins) {
-        await plugin.configureServer?.call(ctx, server);
-      }
-      for (const workspace of workspaces.values()) {
-        await workspace.initServer(server);
-      }
-    },
-    async emit(emitOptions = {}) {
-      const { filterPlugin, filterWorkspace, write = false } = emitOptions;
-      const start = performance.now();
-      const ctx = this.getPluginContext();
-      const added = /* @__PURE__ */ new Set();
-      const out = {
-        entries: [],
-        workspaces: {}
-      };
-      for (const li of await Promise.all(
-        plugins.map((plugin) => {
-          if (filterPlugin && !filterPlugin(plugin) || !plugin.emit) return;
-          return plugin.emit.call(ctx);
-        })
-      )) {
-        if (!li) continue;
-        for (const item of li) {
-          if (added.has(item.path)) continue;
-          out.entries.push(item);
-          added.add(item.path);
-        }
-      }
-      if (write) {
-        await Promise.all(
-          out.entries.map(async (entry) => {
-            const file = path.join(options.outDir, entry.path);
-            await fs.mkdir(path.dirname(file), { recursive: true });
-            await fs.writeFile(file, entry.content);
-          })
-        );
-        console.log(
-          options.workspace ? `[MDX: ${options.workspace.name}] generated files in ${performance.now() - start}ms` : `[MDX] generated files in ${performance.now() - start}ms`
-        );
-      }
-      for (const [name, workspace] of workspaces) {
-        if (filterWorkspace && !filterWorkspace(name)) continue;
-        out.workspaces[name] = (await workspace.emit(emitOptions)).entries;
-      }
-      return out;
-    },
-    async transformMeta(options2, data) {
-      const ctx = {
-        ...this.getPluginContext(),
-        ...options2
-      };
-      data = await transformMetadata(options2, data);
-      for (const plugin of plugins) {
-        if (plugin.meta?.transform)
-          data = await plugin.meta.transform.call(ctx, data) ?? data;
-      }
-      return data;
-    },
-    async transformFrontmatter(options2, data) {
-      const ctx = {
-        ...this.getPluginContext(),
-        ...options2
-      };
-      data = await transformMetadata(options2, data);
-      for (const plugin of plugins) {
-        if (plugin.doc?.frontmatter)
-          data = await plugin.doc.frontmatter.call(ctx, data) ?? data;
-      }
-      return data;
-    },
-    async transformVFile(options2, file) {
-      const ctx = {
-        ...this.getPluginContext(),
-        ...options2
-      };
-      for (const plugin of plugins) {
-        if (plugin.doc?.vfile)
-          file = await plugin.doc.vfile.call(ctx, file) ?? file;
-      }
-      return file;
-    }
-  };
-}
-function postprocessPlugin() {
-  const LinkReferenceTypes = `{
-  /**
-   * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
-   */
-  extractedReferences: import("@hanzo/docs-mdx").ExtractedReference[];
-}`;
-  return {
-    "index-file": {
-      generateTypeConfig() {
-        const lines = [];
-        lines.push("{");
-        lines.push("  DocData: {");
-        for (const collection of this.core.getCollections()) {
-          let postprocessOptions;
-          switch (collection.type) {
-            case "doc":
-              postprocessOptions = collection.postprocess;
-              break;
-            case "docs":
-              postprocessOptions = collection.docs.postprocess;
-              break;
-          }
-          if (postprocessOptions?.extractLinkReferences) {
-            lines.push(ident(`${collection.name}: ${LinkReferenceTypes},`, 2));
-          }
-        }
-        lines.push("  }");
-        lines.push("}");
-        return lines.join("\n");
-      },
-      serverOptions(options) {
-        options.doc ??= {};
-        options.doc.passthroughs ??= [];
-        options.doc.passthroughs.push("extractedReferences");
-      }
-    }
-  };
-}
-
-export {
-  ValidationError,
-  _Defaults,
-  createCore
-};

package/dist/chunk-VITVHHR6.js

@@ -1,334 +0,0 @@
-import {
-  createCodegen,
-  ident
-} from "./chunk-PW2AZGGD.js";
-import {
-  fumaMatter
-} from "./chunk-VWJKRQZR.js";
-
-// src/plugins/index-file.ts
-import path2 from "path";
-import { glob } from "tinyglobby";
-
-// src/utils/fs-cache.ts
-import fs from "fs/promises";
-import path from "path";
-var map = /* @__PURE__ */ new Map();
-function createFSCache() {
-  return {
-    read(file) {
-      const fullPath = toFullPath(file);
-      const cached = map.get(fullPath);
-      if (cached) return cached;
-      const read = fs.readFile(fullPath).then((s) => s.toString());
-      map.set(fullPath, read);
-      return read;
-    },
-    delete(file) {
-      map.delete(toFullPath(file));
-    }
-  };
-}
-function toFullPath(file) {
-  if (path.isAbsolute(file)) {
-    return path.relative(process.cwd(), file);
-  }
-  return file;
-}
-
-// src/plugins/index-file.ts
-import { createHash } from "crypto";
-var indexFileCache = createFSCache();
-function indexFile(options = {}) {
-  const {
-    target = "default",
-    addJsExtension,
-    browser = true,
-    dynamic = true
-  } = options;
-  let dynamicCollections;
-  function isDynamic(collection) {
-    return collection.type === "docs" && collection.docs.dynamic || collection.type === "doc" && collection.dynamic;
-  }
-  function generateConfigs(core) {
-    const serverOptions = {};
-    const typeConfigs = [
-      'import("fumadocs-mdx/runtime/types").InternalTypeConfig'
-    ];
-    const ctx = core.getPluginContext();
-    for (const plugin of core.getPlugins()) {
-      const indexFilePlugin = plugin["index-file"];
-      if (!indexFilePlugin) continue;
-      indexFilePlugin.serverOptions?.call(ctx, serverOptions);
-      const config = indexFilePlugin.generateTypeConfig?.call(ctx);
-      if (config) typeConfigs.push(config);
-    }
-    return {
-      serverOptions,
-      tc: typeConfigs.join(" & ")
-    };
-  }
-  return {
-    name: "index-file",
-    config() {
-      dynamicCollections = this.core.getCollections().filter(isDynamic);
-    },
-    configureServer(server) {
-      if (!server.watcher) return;
-      server.watcher.on("all", async (event, file) => {
-        indexFileCache.delete(file);
-        if (dynamicCollections.length === 0) {
-          if (target === "vite") return;
-          if (target === "default" && event === "change") return;
-        }
-        const updatedCollection = this.core.getCollections().find((collection) => collection.hasFile(file));
-        if (!updatedCollection) return;
-        if (!isDynamic(updatedCollection)) {
-          if (target === "vite") return;
-          if (target === "default" && event === "change") return;
-        }
-        await this.core.emit({
-          filterPlugin: (plugin) => plugin.name === "index-file",
-          filterWorkspace: () => false,
-          write: true
-        });
-      });
-    },
-    async emit() {
-      const globCache = /* @__PURE__ */ new Map();
-      const { workspace, outDir } = this.core.getOptions();
-      const { serverOptions, tc } = generateConfigs(this.core);
-      const toEmitEntry = async (path3, content) => {
-        const codegen = createCodegen({
-          target,
-          outDir,
-          jsExtension: addJsExtension,
-          globCache
-        });
-        await content({
-          core: this.core,
-          codegen,
-          serverOptions,
-          tc,
-          workspace: workspace?.name
-        });
-        return {
-          path: path3,
-          content: codegen.toString()
-        };
-      };
-      const out = [
-        toEmitEntry("server.ts", generateServerIndexFile)
-      ];
-      if (dynamic)
-        out.push(toEmitEntry("dynamic.ts", generateDynamicIndexFile));
-      if (browser)
-        out.push(toEmitEntry("browser.ts", generateBrowserIndexFile));
-      return await Promise.all(out);
-    }
-  };
-}
-async function generateServerIndexFile(ctx) {
-  const { core, codegen, serverOptions, tc } = ctx;
-  codegen.lines.push(
-    `import { server } from 'fumadocs-mdx/runtime/server';`,
-    `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
-    "",
-    `const create = server<typeof Config, ${tc}>(${JSON.stringify(serverOptions)});`
-  );
-  async function generateCollectionObject(collection) {
-    const base = getBase(collection);
-    switch (collection.type) {
-      case "docs": {
-        if (collection.docs.dynamic) return;
-        if (collection.docs.async) {
-          const [metaGlob2, headGlob, bodyGlob] = await Promise.all([
-            generateMetaCollectionGlob(ctx, collection.meta, true),
-            generateDocCollectionFrontmatterGlob(ctx, collection.docs, true),
-            generateDocCollectionGlob(ctx, collection.docs)
-          ]);
-          return `await create.docsLazy("${collection.name}", "${base}", ${metaGlob2}, ${headGlob}, ${bodyGlob})`;
-        }
-        const [metaGlob, docGlob] = await Promise.all([
-          generateMetaCollectionGlob(ctx, collection.meta, true),
-          generateDocCollectionGlob(ctx, collection.docs, true)
-        ]);
-        return `await create.docs("${collection.name}", "${base}", ${metaGlob}, ${docGlob})`;
-      }
-      case "doc":
-        if (collection.dynamic) return;
-        if (collection.async) {
-          const [headGlob, bodyGlob] = await Promise.all([
-            generateDocCollectionFrontmatterGlob(ctx, collection, true),
-            generateDocCollectionGlob(ctx, collection)
-          ]);
-          return `await create.docLazy("${collection.name}", "${base}", ${headGlob}, ${bodyGlob})`;
-        }
-        return `await create.doc("${collection.name}", "${base}", ${await generateDocCollectionGlob(
-          ctx,
-          collection,
-          true
-        )})`;
-      case "meta":
-        return `await create.meta("${collection.name}", "${base}", ${await generateMetaCollectionGlob(
-          ctx,
-          collection,
-          true
-        )})`;
-    }
-  }
-  await codegen.pushAsync(
-    core.getCollections().map(async (collection) => {
-      const obj = await generateCollectionObject(collection);
-      if (!obj) return;
-      return `
-export const ${collection.name} = ${obj};`;
-    })
-  );
-}
-async function generateDynamicIndexFile(ctx) {
-  const { core, codegen, serverOptions, tc } = ctx;
-  const { configPath, environment, outDir } = core.getOptions();
-  const partialOptions = {
-    configPath,
-    environment,
-    outDir
-  };
-  codegen.lines.push(
-    `import { dynamic } from 'fumadocs-mdx/runtime/dynamic';`,
-    `import * as Config from '${codegen.formatImportPath(configPath)}';`,
-    "",
-    `const create = await dynamic<typeof Config, ${tc}>(Config, ${JSON.stringify(partialOptions)}, ${JSON.stringify(serverOptions)});`
-  );
-  async function generateCollectionObjectEntry(collection, absolutePath) {
-    const fullPath = path2.relative(process.cwd(), absolutePath);
-    const content = await indexFileCache.read(fullPath).catch(() => "");
-    const parsed = fumaMatter(content);
-    const data = await core.transformFrontmatter(
-      {
-        collection,
-        filePath: fullPath,
-        source: content
-      },
-      parsed.data
-    );
-    const hash = createHash("md5").update(content).digest("hex");
-    const infoStr = [
-      // make sure it's included in vercel/nft
-      `absolutePath: path.resolve(${JSON.stringify(fullPath)})`
-    ];
-    for (const [k, v] of Object.entries({
-      info: {
-        fullPath,
-        path: path2.relative(collection.dir, absolutePath)
-      },
-      data,
-      hash
-    })) {
-      infoStr.push(`${k}: ${JSON.stringify(v)}`);
-    }
-    return `{ ${infoStr.join(", ")} }`;
-  }
-  async function generateCollectionObject(parent) {
-    let collection;
-    if (parent.type === "doc") collection = parent;
-    else if (parent.type === "docs") collection = parent.docs;
-    if (!collection || !collection.dynamic) return;
-    const files = await glob(collection.patterns, {
-      cwd: collection.dir,
-      absolute: true
-    });
-    const entries = await Promise.all(
-      files.map((file) => generateCollectionObjectEntry(collection, file))
-    );
-    switch (parent.type) {
-      case "docs": {
-        const metaGlob = await generateMetaCollectionGlob(
-          ctx,
-          parent.meta,
-          true
-        );
-        return `await create.docs("${parent.name}", "${getBase(parent)}", ${metaGlob}, ${entries.join(", ")})`;
-      }
-      case "doc":
-        return `await create.doc("${collection.name}", "${getBase(collection)}", ${entries.join(", ")})`;
-    }
-  }
-  await codegen.pushAsync(
-    core.getCollections().map(async (collection) => {
-      const obj = await generateCollectionObject(collection);
-      if (!obj) return;
-      return `
-export const ${collection.name} = ${obj};`;
-    })
-  );
-}
-async function generateBrowserIndexFile(ctx) {
-  const { core, codegen, tc } = ctx;
-  codegen.lines.push(
-    `import { browser } from 'fumadocs-mdx/runtime/browser';`,
-    `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
-    "",
-    `const create = browser<typeof Config, ${tc}>();`
-  );
-  async function generateCollectionObject(collection) {
-    switch (collection.type) {
-      case "docs": {
-        if (collection.docs.dynamic) return;
-        return generateCollectionObject(collection.docs);
-      }
-      case "doc":
-        if (collection.dynamic) return;
-        return `create.doc("${collection.name}", ${await generateDocCollectionGlob(ctx, collection)})`;
-    }
-  }
-  codegen.lines.push("const browserCollections = {");
-  await codegen.pushAsync(
-    core.getCollections().map(async (collection) => {
-      const obj = await generateCollectionObject(collection);
-      if (!obj) return;
-      return ident(`${collection.name}: ${obj},`);
-    })
-  );
-  codegen.lines.push("};", "export default browserCollections;");
-}
-function getBase(collection) {
-  return path2.relative(process.cwd(), collection.dir);
-}
-function generateDocCollectionFrontmatterGlob({ codegen, workspace }, collection, eager = false) {
-  return codegen.generateGlobImport(collection.patterns, {
-    query: {
-      collection: collection.name,
-      only: "frontmatter",
-      workspace
-    },
-    import: "frontmatter",
-    base: collection.dir,
-    eager
-  });
-}
-function generateDocCollectionGlob({ codegen, workspace }, collection, eager = false) {
-  return codegen.generateGlobImport(collection.patterns, {
-    query: {
-      collection: collection.name,
-      workspace
-    },
-    base: collection.dir,
-    eager
-  });
-}
-function generateMetaCollectionGlob({ codegen, workspace }, collection, eager = false) {
-  return codegen.generateGlobImport(collection.patterns, {
-    query: {
-      collection: collection.name,
-      workspace
-    },
-    import: "default",
-    base: collection.dir,
-    eager
-  });
-}
-
-export {
-  indexFile
-};