@hanzo/docs-mdx 14.1.0

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/bin.d.ts

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

package/dist/bin.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+// src/bin.ts
+import { existsSync } from "fs";
+async function start() {
+  const [configPath, outDir] = process.argv.slice(2);
+  const isNext = existsSync("next.config.js") || existsSync("next.config.mjs") || existsSync("next.config.mts") || existsSync("next.config.ts");
+  if (isNext) {
+    const { postInstall } = await import("./next/index.js");
+    await postInstall({ configPath, outDir });
+  } else {
+    const { postInstall } = await import("./vite/index.js");
+    await postInstall({ configPath, outDir });
+  }
+}
+void start();

package/dist/build-mdx-LN7FEKIP.js

@@ -0,0 +1,8 @@
+import {
+  buildMDX
+} from "./chunk-AXJB5MGS.js";
+import "./chunk-YKRCQ42E.js";
+import "./chunk-VWJKRQZR.js";
+export {
+  buildMDX
+};

package/dist/build-mdx-RXJZQXGA.js

@@ -0,0 +1,8 @@
+import {
+  buildMDX
+} from "./chunk-7W73RILB.js";
+import "./chunk-Y7ISNZ7X.js";
+import "./chunk-VWJKRQZR.js";
+export {
+  buildMDX
+};

package/dist/bun/index.d.ts

@@ -0,0 +1,25 @@
+import { BunPlugin } from 'bun';
+import { C as CoreOptions } from '../core-BhWOtait.js';
+import '@mdx-js/mdx';
+import '@standard-schema/spec';
+import 'unified';
+import '@hanzo/docs-core/mdx-plugins';
+import '@hanzo/docs-core/source/schema';
+import 'chokidar';
+import 'vfile';
+import '@hanzo/docs-core/source';
+import '../runtime/types.js';
+import '@hanzo/docs-core/mdx-plugins/remark-structure';
+import '@hanzo/docs-core/toc';
+import 'mdast';
+import 'mdx/types';
+
+interface MdxPluginOptions extends Partial<CoreOptions> {
+    /**
+     * Skip meta file transformation step
+     */
+    disableMetaFile?: boolean;
+}
+declare function createMdxPlugin(options?: MdxPluginOptions): BunPlugin;
+
+export { type MdxPluginOptions, createMdxPlugin };

package/dist/bun/index.js

@@ -0,0 +1,52 @@
+import {
+  createMdxLoader
+} from "../chunk-JWZR25CW.js";
+import {
+  createMetaLoader
+} from "../chunk-ZAYZWFWP.js";
+import {
+  createIntegratedConfigLoader,
+  toBun
+} from "../chunk-DMIIE3XZ.js";
+import "../chunk-4JSFLXXT.js";
+import {
+  buildConfig
+} from "../chunk-MYAVS2LD.js";
+import "../chunk-U5YPLCO5.js";
+import {
+  _Defaults,
+  createCore
+} from "../chunk-RR2X6AE6.js";
+import "../chunk-PW2AZGGD.js";
+import "../chunk-VWJKRQZR.js";
+
+// src/bun/index.ts
+import { pathToFileURL } from "url";
+function createMdxPlugin(options = {}) {
+  const {
+    environment = "bun",
+    outDir = _Defaults.outDir,
+    configPath = _Defaults.configPath,
+    disableMetaFile = false
+  } = options;
+  return {
+    name: "bun-plugin-hanzo-docs-mdx",
+    async setup(build) {
+      const importPath = pathToFileURL(configPath).href;
+      const core = createCore({
+        environment,
+        outDir,
+        configPath
+      });
+      await core.init({
+        config: buildConfig(await import(importPath))
+      });
+      const configLoader = createIntegratedConfigLoader(core);
+      toBun(createMdxLoader(configLoader))(build);
+      if (!disableMetaFile) toBun(createMetaLoader(configLoader))(build);
+    }
+  };
+}
+export {
+  createMdxPlugin
+};

package/dist/chunk-4JSFLXXT.js

@@ -0,0 +1,8 @@
+// src/loaders/index.ts
+var metaLoaderGlob = /\.(json|yaml)(\?.+?)?$/;
+var mdxLoaderGlob = /\.mdx?(\?.+?)?$/;
+
+export {
+  metaLoaderGlob,
+  mdxLoaderGlob
+};

package/dist/chunk-5OBUOALK.js

@@ -0,0 +1,141 @@
+// src/runtime/server.ts
+import * as path from "path";
+function server(options = {}) {
+  const { doc: { passthroughs: docPassthroughs = [] } = {} } = options;
+  function fileInfo(file, base) {
+    if (file.startsWith("./")) {
+      file = file.slice(2);
+    }
+    return {
+      path: file,
+      fullPath: path.join(base, file)
+    };
+  }
+  function mapDocData(entry) {
+    const data = {
+      body: entry.default,
+      toc: entry.toc,
+      structuredData: entry.structuredData,
+      _exports: entry
+    };
+    for (const key of docPassthroughs) {
+      data[key] = entry[key];
+    }
+    return data;
+  }
+  return {
+    async doc(_name, base, glob) {
+      const out = await Promise.all(
+        Object.entries(glob).map(async ([k, v]) => {
+          const data = typeof v === "function" ? await v() : v;
+          return {
+            ...mapDocData(data),
+            ...data.frontmatter,
+            ...createDocMethods(fileInfo(k, base), () => data)
+          };
+        })
+      );
+      return out;
+    },
+    async docLazy(_name, base, head, body) {
+      const out = await Promise.all(
+        Object.entries(head).map(async ([k, v]) => {
+          const data = typeof v === "function" ? await v() : v;
+          const content = body[k];
+          return {
+            ...data,
+            ...createDocMethods(fileInfo(k, base), content),
+            async load() {
+              return mapDocData(await content());
+            }
+          };
+        })
+      );
+      return out;
+    },
+    async meta(_name, base, glob) {
+      const out = await Promise.all(
+        Object.entries(glob).map(async ([k, v]) => {
+          const data = typeof v === "function" ? await v() : v;
+          return {
+            info: fileInfo(k, base),
+            ...data
+          };
+        })
+      );
+      return out;
+    },
+    async docs(name, base, metaGlob, docGlob) {
+      const entry = {
+        docs: await this.doc(name, base, docGlob),
+        meta: await this.meta(name, base, metaGlob),
+        toFumadocsSource() {
+          return toFumadocsSource(this.docs, this.meta);
+        }
+      };
+      return entry;
+    },
+    async docsLazy(name, base, metaGlob, docHeadGlob, docBodyGlob) {
+      const entry = {
+        docs: await this.docLazy(name, base, docHeadGlob, docBodyGlob),
+        meta: await this.meta(name, base, metaGlob),
+        toFumadocsSource() {
+          return toFumadocsSource(this.docs, this.meta);
+        }
+      };
+      return entry;
+    }
+  };
+}
+function toFumadocsSource(pages, metas) {
+  const files = [];
+  for (const entry of pages) {
+    files.push({
+      type: "page",
+      path: entry.info.path,
+      absolutePath: entry.info.fullPath,
+      data: entry
+    });
+  }
+  for (const entry of metas) {
+    files.push({
+      type: "meta",
+      path: entry.info.path,
+      absolutePath: entry.info.fullPath,
+      data: entry
+    });
+  }
+  return {
+    files
+  };
+}
+function createDocMethods(info, load) {
+  return {
+    info,
+    async getText(type) {
+      if (type === "raw") {
+        const fs = await import("fs/promises");
+        return (await fs.readFile(info.fullPath)).toString();
+      }
+      const data = await load();
+      if (typeof data._markdown !== "string")
+        throw new Error(
+          "getText('processed') requires `includeProcessedMarkdown` to be enabled in your collection config."
+        );
+      return data._markdown;
+    },
+    async getMDAST() {
+      const data = await load();
+      if (!data._mdast)
+        throw new Error(
+          "getMDAST() requires `includeMDAST` to be enabled in your collection config."
+        );
+      return JSON.parse(data._mdast);
+    }
+  };
+}
+
+export {
+  server,
+  toFumadocsSource
+};

package/dist/chunk-72JS4QVZ.js

@@ -0,0 +1,17 @@
+import {
+  createCore
+} from "./chunk-UB55AMXC.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-7I4W7XGI.js

@@ -0,0 +1,179 @@
+import {
+  ValidationError
+} from "./chunk-UB55AMXC.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-7W73RILB.js

@@ -0,0 +1,173 @@
+import {
+  flattenNode,
+  remarkInclude
+} from "./chunk-Y7ISNZ7X.js";
+
+// src/loaders/mdx/build-mdx.ts
+import { createProcessor } from "@mdx-js/mdx";
+import { VFile } from "vfile";
+
+// src/loaders/mdx/remark-postprocess.ts
+import { visit } from "unist-util-visit";
+import { toMarkdown } from "mdast-util-to-markdown";
+import { valueToEstree } from "estree-util-value-to-estree";
+import { removePosition } from "unist-util-remove-position";
+import remarkMdx from "remark-mdx";
+function remarkPostprocess({
+  _format,
+  includeProcessedMarkdown = false,
+  includeMDAST = false,
+  extractLinkReferences = false,
+  valueToExport = []
+}) {
+  let _stringifyProcessor;
+  const getStringifyProcessor = () => {
+    return _stringifyProcessor ??= _format === "mdx" ? this : (
+      // force Markdown processor to stringify MDX nodes
+      this().use(remarkMdx).freeze()
+    );
+  };
+  return (tree, file) => {
+    const frontmatter = file.data.frontmatter ??= {};
+    if (!frontmatter.title) {
+      visit(tree, "heading", (node) => {
+        if (node.depth === 1) {
+          frontmatter.title = flattenNode(node);
+          return false;
+        }
+      });
+    }
+    file.data["mdx-export"] ??= [];
+    file.data["mdx-export"].push({
+      name: "frontmatter",
+      value: frontmatter
+    });
+    if (extractLinkReferences) {
+      const urls = [];
+      visit(tree, "link", (node) => {
+        urls.push({
+          href: node.url
+        });
+        return "skip";
+      });
+      file.data["mdx-export"].push({
+        name: "extractedReferences",
+        value: urls
+      });
+    }
+    if (includeProcessedMarkdown) {
+      const processor = getStringifyProcessor();
+      const markdown = toMarkdown(tree, {
+        ...processor.data("settings"),
+        // from https://github.com/remarkjs/remark/blob/main/packages/remark-stringify/lib/index.js
+        extensions: processor.data("toMarkdownExtensions") || []
+      });
+      file.data["mdx-export"].push({
+        name: "_markdown",
+        value: markdown
+      });
+    }
+    if (includeMDAST) {
+      const options = includeMDAST === true ? {} : includeMDAST;
+      const mdast = JSON.stringify(
+        options.removePosition ? removePosition(structuredClone(tree)) : tree
+      );
+      file.data["mdx-export"].push({
+        name: "_mdast",
+        value: mdast
+      });
+    }
+    for (const { name, value } of file.data["mdx-export"]) {
+      tree.children.unshift(getMdastExport(name, value));
+    }
+    file.data["mdx-export"] = [];
+    for (const name of valueToExport) {
+      if (!(name in file.data)) continue;
+      tree.children.unshift(getMdastExport(name, file.data[name]));
+    }
+  };
+}
+function getMdastExport(name, value) {
+  return {
+    type: "mdxjsEsm",
+    value: "",
+    data: {
+      estree: {
+        type: "Program",
+        sourceType: "module",
+        body: [
+          {
+            type: "ExportNamedDeclaration",
+            attributes: [],
+            specifiers: [],
+            source: null,
+            declaration: {
+              type: "VariableDeclaration",
+              kind: "let",
+              declarations: [
+                {
+                  type: "VariableDeclarator",
+                  id: {
+                    type: "Identifier",
+                    name
+                  },
+                  init: valueToEstree(value)
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  };
+}
+
+// src/loaders/mdx/build-mdx.ts
+async function buildMDX(core, collection, {
+  filePath,
+  frontmatter,
+  source,
+  _compiler,
+  environment,
+  isDevelopment
+}) {
+  const mdxOptions = await core.getConfig().getMDXOptions(collection, environment);
+  function getProcessor(format) {
+    const cache = core.cache;
+    const key = `build-mdx:${collection?.name ?? "global"}:${format}`;
+    let processor = cache.get(key);
+    if (!processor) {
+      const postprocessOptions = {
+        _format: format,
+        ...collection?.postprocess
+      };
+      processor = createProcessor({
+        outputFormat: "program",
+        development: isDevelopment,
+        ...mdxOptions,
+        remarkPlugins: [
+          remarkInclude,
+          ...mdxOptions.remarkPlugins ?? [],
+          [remarkPostprocess, postprocessOptions]
+        ],
+        format
+      });
+      cache.set(key, processor);
+    }
+    return processor;
+  }
+  let vfile = new VFile({
+    value: source,
+    path: filePath,
+    cwd: collection?.cwd,
+    data: { frontmatter, _compiler, _getProcessor: getProcessor }
+  });
+  if (collection) {
+    vfile = await core.transformVFile({ collection, filePath, source }, vfile);
+  }
+  return getProcessor(filePath.endsWith(".mdx") ? "mdx" : "md").process(vfile);
+}
+
+export {
+  buildMDX
+};