@xyd-js/content 0.1.0-xyd.2

package/dist/index.js

@@ -0,0 +1,216 @@
+// src/utils/index.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { VFile } from "vfile";
+import { compile as mdxCompile } from "@mdx-js/mdx";
+
+// src/mdx/options.ts
+import remarkFrontmatter from "remark-frontmatter";
+import remarkMdxFrontmatter from "remark-mdx-frontmatter";
+import remarkGfm from "remark-gfm";
+
+// src/mdx/toc.ts
+var remarkMdxToc = (options) => () => async (ast) => {
+  const { visit: visit4 } = await import("unist-util-visit");
+  const { toString } = await import("mdast-util-to-string");
+  const { valueToEstree } = await import("estree-util-value-to-estree");
+  const { name: isIdentifierName } = await import("estree-util-is-identifier-name");
+  const mdast = ast;
+  const name = options.name ?? "toc";
+  if (!isIdentifierName(name)) {
+    throw new Error(`Invalid name for an identifier: ${name}`);
+  }
+  const toc = [];
+  const flatToc = [];
+  const createEntry = (node, depth) => {
+    let attributes = node.data || {};
+    if (node.type === "mdxJsxFlowElement") {
+      attributes = Object.fromEntries(
+        node.attributes.filter((attribute) => attribute.type === "mdxJsxAttribute" && typeof attribute.value === "string").map((attribute) => [attribute.name, attribute.value])
+      );
+    }
+    return {
+      depth,
+      value: toString(node, { includeImageAlt: false }),
+      attributes,
+      children: []
+    };
+  };
+  visit4(mdast, ["heading", "mdxJsxFlowElement"], (node) => {
+    let depth = 0;
+    if (node.type === "mdxJsxFlowElement") {
+      let valid = false;
+      if (/^h[1-6]$/.test(node.name || "")) {
+        valid = true;
+        depth = parseInt(node.name.substring(1));
+      } else if (options.customTags) {
+        for (const tag of options.customTags) {
+          if (tag.name.test(node.name || "")) {
+            valid = true;
+            depth = tag.depth(node.name || "");
+            break;
+          }
+        }
+      }
+      if (!valid) {
+        return;
+      }
+    } else if (node.type === "heading") {
+      depth = node.depth;
+    } else {
+      return;
+    }
+    if (depth && ((options == null ? void 0 : options.minDepth) && options.minDepth > depth)) {
+      return;
+    }
+    const entry = createEntry(node, depth);
+    flatToc.push(entry);
+    let parent = toc;
+    for (let i = flatToc.length - 1; i >= 0; --i) {
+      const current = flatToc[i];
+      if (current.depth < entry.depth) {
+        parent = current.children;
+        break;
+      }
+    }
+    parent.push(entry);
+  });
+  const tocExport = {
+    type: "mdxjsEsm",
+    value: "",
+    data: {
+      estree: {
+        type: "Program",
+        sourceType: "module",
+        body: [
+          {
+            type: "ExportNamedDeclaration",
+            specifiers: [],
+            source: null,
+            declaration: {
+              type: "VariableDeclaration",
+              kind: "const",
+              declarations: [
+                {
+                  type: "VariableDeclarator",
+                  id: {
+                    type: "Identifier",
+                    name
+                  },
+                  init: valueToEstree(toc)
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  };
+  mdast.children.unshift(tocExport);
+};
+
+// src/mdx/code.ts
+import { visit } from "unist-util-visit";
+function remarkInjectCodeMeta() {
+  return (tree) => {
+    visit(tree, "code", (node) => {
+      if (node.meta) {
+        node.data = node.data || {};
+        node.data.hProperties = {
+          ...node.data.hProperties || {},
+          meta: node.meta
+        };
+      }
+    });
+  };
+}
+
+// src/mdx/themeSettings.ts
+import { visit as visit2 } from "unist-util-visit";
+var extractThemeSettings = () => {
+  return (tree) => {
+    visit2(tree, "exportNamedDeclaration", (node) => {
+      const declaration = node.declaration;
+      if (declaration && declaration.declarations) {
+        declaration.declarations.forEach((decl) => {
+          if (decl.id.name === "themeSettings") {
+            global.themeSettings = decl.init;
+          }
+        });
+      }
+    });
+  };
+};
+
+// src/mdx/page.ts
+import { visit as visit3 } from "unist-util-visit";
+var extractPage = () => {
+  return (tree) => {
+    visit3(tree, "exportNamedDeclaration", (node) => {
+      const declaration = node.declaration;
+      if (declaration && declaration.declarations) {
+        declaration.declarations.forEach((decl) => {
+          if (decl.id.name === "page") {
+            global.page = decl.init;
+          }
+        });
+      }
+    });
+  };
+};
+
+// src/mdx/options.ts
+function mdxOptions(toc) {
+  return {
+    remarkPlugins: [
+      remarkFrontmatter,
+      remarkMdxFrontmatter,
+      remarkGfm,
+      remarkInjectCodeMeta,
+      remarkMdxToc(toc),
+      extractThemeSettings,
+      extractPage
+    ],
+    rehypePlugins: []
+  };
+}
+
+// src/utils/index.ts
+async function compileBySlug(slug, mdx2) {
+  const filePath = path.join(process.cwd(), `${slug}.${mdx2 ? "mdx" : "md"}`);
+  await fs.access(filePath);
+  const content = await fs.readFile(filePath, "utf-8");
+  return await compile(content, filePath);
+}
+async function compile(content, filePath) {
+  const vfile = new VFile({
+    path: filePath,
+    value: content,
+    contents: content
+  });
+  const mdOptions = mdxOptions({
+    minDepth: 2
+    // TODO: configurable?
+  });
+  const compiled = await mdxCompile(vfile, {
+    remarkPlugins: mdOptions.remarkPlugins,
+    rehypePlugins: mdOptions.rehypePlugins,
+    recmaPlugins: [],
+    outputFormat: "function-body",
+    development: false
+  });
+  return String(compiled);
+}
+
+// src/vite-plugins/index.ts
+import mdx from "@mdx-js/rollup";
+function vitePlugins(options) {
+  return [
+    mdx(mdxOptions(options.toc))
+  ];
+}
+export {
+  compileBySlug,
+  mdxOptions,
+  vitePlugins
+};

package/dist/navigation.d.ts

@@ -0,0 +1,6 @@
+import { Sidebar, PageFrontMatter, Header } from '@xyd-js/core';
+
+declare function pageFrontMatters(navigation: Sidebar[]): Promise<PageFrontMatter>;
+declare function filterNavigationByLevels(headers: Header[], slug: string): (nav: Sidebar) => boolean;
+
+export { filterNavigationByLevels, pageFrontMatters };