@hanzo/docs-mdx 14.1.0

package/dist/chunk-DMIIE3XZ.js

@@ -0,0 +1,179 @@
+import {
+  ValidationError
+} from "./chunk-RR2X6AE6.js";
+
+// src/loaders/adapter.ts
+import { fileURLToPath } from "url";
+import fs from "fs/promises";
+import { parse } from "querystring";
+import path from "path";
+import { readFileSync } from "fs";
+function toNode(loader) {
+  return async (url, _context, nextLoad) => {
+    if (url.startsWith("file:///") && (!loader.test || loader.test.test(url))) {
+      const parsedUrl = new URL(url);
+      const filePath = fileURLToPath(parsedUrl);
+      const result = await loader.load({
+        filePath,
+        query: Object.fromEntries(parsedUrl.searchParams.entries()),
+        async getSource() {
+          return (await fs.readFile(filePath)).toString();
+        },
+        development: false,
+        compiler: {
+          addDependency() {
+          }
+        }
+      });
+      if (result) {
+        return {
+          source: result.code,
+          format: "module",
+          shortCircuit: true
+        };
+      }
+    }
+    return nextLoad(url);
+  };
+}
+function toVite(loader) {
+  return {
+    filter(id) {
+      return !loader.test || loader.test.test(id);
+    },
+    async transform(value, id) {
+      const [file, query = ""] = id.split("?", 2);
+      const result = await loader.load({
+        filePath: file,
+        query: parse(query),
+        getSource() {
+          return value;
+        },
+        development: this.environment.mode === "dev",
+        compiler: {
+          addDependency: (file2) => {
+            this.addWatchFile(file2);
+          }
+        }
+      });
+      if (result === null) return null;
+      return {
+        code: result.code,
+        map: result.map
+      };
+    }
+  };
+}
+function toWebpack(loader) {
+  return async function(source, callback) {
+    try {
+      const result = await loader.load({
+        filePath: this.resourcePath,
+        query: parse(this.resourceQuery.slice(1)),
+        getSource() {
+          return source;
+        },
+        development: this.mode === "development",
+        compiler: this
+      });
+      if (result === null) {
+        callback(void 0, source);
+      } else {
+        callback(void 0, result.code, result.map);
+      }
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        return callback(new Error(await error.toStringFormatted()));
+      }
+      if (!(error instanceof Error)) throw error;
+      const fpath = path.relative(this.context, this.resourcePath);
+      error.message = `${fpath}:${error.name}: ${error.message}`;
+      callback(error);
+    }
+  };
+}
+function toBun(loader) {
+  function toResult(output) {
+    if (!output) return;
+    return {
+      contents: output.code,
+      loader: "js"
+    };
+  }
+  return (build) => {
+    build.onLoad({ filter: loader.test ?? /.+/ }, (args) => {
+      const [filePath, query = ""] = args.path.split("?", 2);
+      const input = {
+        async getSource() {
+          return Bun.file(filePath).text();
+        },
+        query: parse(query),
+        filePath,
+        development: false,
+        compiler: {
+          addDependency() {
+          }
+        }
+      };
+      if (loader.bun?.load) {
+        return loader.bun.load(readFileSync(filePath).toString(), input);
+      }
+      const result = loader.load(input);
+      if (result instanceof Promise) {
+        return result.then(toResult);
+      }
+      return toResult(result);
+    });
+  };
+}
+
+// src/loaders/config.ts
+import fs2 from "fs/promises";
+function createStandaloneConfigLoader({
+  core,
+  buildConfig,
+  mode
+}) {
+  let prev;
+  async function getConfigHash() {
+    if (mode === "production") return "static";
+    const stats = await fs2.stat(core.getOptions().configPath).catch(() => {
+      throw new Error("Cannot find config file");
+    });
+    return stats.mtime.getTime().toString();
+  }
+  return {
+    async getCore() {
+      const hash = await getConfigHash();
+      if (!prev || hash !== prev.hash) {
+        prev = {
+          hash,
+          init: (async () => {
+            const { loadConfig } = await import("./load-from-file-S5CQ4H6T.js");
+            await core.init({
+              config: loadConfig(core, buildConfig)
+            });
+          })()
+        };
+      }
+      await prev.init;
+      return core;
+    }
+  };
+}
+function createIntegratedConfigLoader(core) {
+  return {
+    async getCore() {
+      return core;
+    }
+  };
+}
+
+export {
+  toNode,
+  toVite,
+  toWebpack,
+  toBun,
+  createStandaloneConfigLoader,
+  createIntegratedConfigLoader
+};

package/dist/chunk-DTFUANSF.js

@@ -0,0 +1,40 @@
+import {
+  buildConfig
+} from "./chunk-OLD35ARB.js";
+
+// src/config/load-from-file.ts
+import { pathToFileURL } from "url";
+async function compileConfig(core) {
+  const { build } = await import("esbuild");
+  const { configPath, outDir } = core.getOptions();
+  const transformed = await build({
+    entryPoints: [{ in: configPath, out: "source.config" }],
+    bundle: true,
+    outdir: outDir,
+    target: "node20",
+    write: true,
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    outExtension: {
+      ".js": ".mjs"
+    },
+    allowOverwrite: true
+  });
+  if (transformed.errors.length > 0) {
+    throw new Error("failed to compile configuration file");
+  }
+}
+async function loadConfig(core, build = false) {
+  if (build) await compileConfig(core);
+  const url = pathToFileURL(core.getCompiledConfigPath());
+  url.searchParams.set("hash", Date.now().toString());
+  const config = import(url.href).then(
+    (loaded) => buildConfig(loaded)
+  );
+  return await config;
+}
+
+export {
+  loadConfig
+};

package/dist/chunk-JWZR25CW.js

@@ -0,0 +1,116 @@
+import {
+  mdxLoaderGlob
+} from "./chunk-4JSFLXXT.js";
+import {
+  fumaMatter
+} from "./chunk-VWJKRQZR.js";
+
+// src/loaders/mdx/index.ts
+import { z } from "zod";
+import fs from "fs/promises";
+import path from "path";
+import { createHash } from "crypto";
+var querySchema = z.object({
+  only: z.literal(["frontmatter", "all"]).default("all"),
+  collection: z.string().optional(),
+  workspace: z.string().optional()
+}).loose();
+var cacheEntry = z.object({
+  code: z.string(),
+  map: z.any().optional(),
+  hash: z.string().optional()
+});
+function createMdxLoader({ getCore }) {
+  return {
+    test: mdxLoaderGlob,
+    async load({
+      getSource,
+      development: isDevelopment,
+      query,
+      compiler,
+      filePath
+    }) {
+      let core = await getCore();
+      const value = await getSource();
+      const matter = fumaMatter(value);
+      const {
+        collection: collectionName,
+        workspace,
+        only
+      } = querySchema.parse(query);
+      if (workspace) {
+        core = core.getWorkspaces().get(workspace) ?? core;
+      }
+      let after;
+      const { experimentalBuildCache = false } = core.getConfig().global;
+      if (!isDevelopment && experimentalBuildCache) {
+        const cacheDir = experimentalBuildCache;
+        const cacheKey = `${collectionName ?? "global"}_${generateCacheHash(filePath)}`;
+        const cached = await fs.readFile(path.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
+        if (cached && cached.hash === generateCacheHash(value)) return cached;
+        after = async () => {
+          await fs.mkdir(cacheDir, { recursive: true });
+          await fs.writeFile(
+            path.join(cacheDir, cacheKey),
+            JSON.stringify({
+              ...out,
+              hash: generateCacheHash(value)
+            })
+          );
+        };
+      }
+      const collection = collectionName ? core.getCollection(collectionName) : void 0;
+      let docCollection;
+      switch (collection?.type) {
+        case "doc":
+          docCollection = collection;
+          break;
+        case "docs":
+          docCollection = collection.docs;
+          break;
+      }
+      if (docCollection) {
+        matter.data = await core.transformFrontmatter(
+          { collection: docCollection, filePath, source: value },
+          matter.data
+        );
+      }
+      if (only === "frontmatter") {
+        return {
+          code: `export const frontmatter = ${JSON.stringify(matter.data)}`,
+          map: null
+        };
+      }
+      const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
+      const { buildMDX } = await import("./build-mdx-LN7FEKIP.js");
+      const compiled = await buildMDX(core, docCollection, {
+        isDevelopment,
+        source: "\n".repeat(lineOffset) + matter.content,
+        filePath,
+        frontmatter: matter.data,
+        _compiler: compiler,
+        environment: "bundler"
+      });
+      const out = {
+        code: String(compiled.value),
+        map: compiled.map
+      };
+      await after?.();
+      return out;
+    }
+  };
+}
+function generateCacheHash(input) {
+  return createHash("md5").update(input).digest("hex");
+}
+function countLines(s) {
+  let num = 0;
+  for (const c of s) {
+    if (c === "\n") num++;
+  }
+  return num;
+}
+
+export {
+  createMdxLoader
+};

package/dist/chunk-K7N6GD4M.js

@@ -0,0 +1,17 @@
+import {
+  createCore
+} from "./chunk-VKSHE52K.js";
+
+// src/webpack/index.ts
+var core;
+function getCore(options) {
+  return core ??= createCore({
+    environment: "webpack",
+    outDir: options.outDir,
+    configPath: options.configPath
+  });
+}
+
+export {
+  getCore
+};

package/dist/chunk-LXB7WYAF.js

@@ -0,0 +1,334 @@
+import {
+  fumaMatter
+} from "./chunk-VWJKRQZR.js";
+import {
+  createCodegen,
+  ident
+} from "./chunk-PW2AZGGD.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("@hanzo/docs-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 '@hanzo/docs/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 '@hanzo/docs/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 '@hanzo/docs/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
+};