@depup/nextra 4.6.1-depup.0

package/dist/server/remark-plugins/remark-headings.js

@@ -0,0 +1,133 @@
+import Slugger from "github-slugger";
+import { visit } from "unist-util-visit";
+import { visitChildren } from "unist-util-visit-children";
+import { MARKDOWN_EXTENSION_RE } from "../constants.js";
+import { createAstObject } from "../utils.js";
+const getFlattenedValue = (node) => node.children.map(
+  (child) => "children" in child ? getFlattenedValue(child) : "value" in child ? child.value : ""
+).join("");
+const remarkHeadings = ({ exportName = "toc", isRemoteContent }) => {
+  const headings = [];
+  const slugger = new Slugger();
+  return (ast, file) => {
+    const PartialComponentToHeadingsName = /* @__PURE__ */ Object.create(null);
+    visit(
+      ast,
+      [
+        "heading",
+        // push partial component's `toc` export name to headings list
+        "mdxJsxFlowElement",
+        // verify .md/.mdx exports and attach named `toc` export
+        "mdxjsEsm"
+      ],
+      (node, index, parent) => {
+        if (node.type === "heading") {
+          if (node.depth === 1) {
+            return;
+          }
+          node.data ||= {};
+          const headingProps = node.data.hProperties ||= {};
+          const value = getFlattenedValue(node);
+          const id = slugger.slug(headingProps.id || value);
+          headingProps.id = id;
+          headings.push({ depth: node.depth, value, id });
+          return;
+        }
+        const isTab = node.type === "mdxJsxFlowElement" && node.name === "Tabs.Tab";
+        if (isTab) {
+          const itemsAttr = parent?.type === "mdxJsxFlowElement" && parent.name === "Tabs" && parent.attributes.find(
+            (attr) => attr.type === "mdxJsxAttribute" && attr.name === "items"
+          );
+          if (!itemsAttr) return;
+          const tabName = itemsAttr.value.data.estree.body[0].expression.elements.map(
+            (el) => el.value
+          )[index];
+          const id = slugger.slug(tabName);
+          node.children.unshift({
+            type: "mdxJsxFlowElement",
+            name: "h3",
+            data: { _mdxExplicitJsx: true },
+            children: [{ type: "text", value: tabName }],
+            attributes: [
+              { type: "mdxJsxAttribute", name: "id", value: id },
+              {
+                type: "mdxJsxAttribute",
+                name: "style",
+                value: {
+                  type: "mdxJsxAttributeValueExpression",
+                  value: "",
+                  data: {
+                    estree: {
+                      type: "Program",
+                      sourceType: "module",
+                      comments: [],
+                      body: [
+                        {
+                          type: "ExpressionStatement",
+                          expression: createAstObject({
+                            visibility: "hidden",
+                            width: 0,
+                            height: 0
+                          })
+                        }
+                      ]
+                    }
+                  }
+                }
+              }
+            ]
+          });
+        }
+        const isDetails = node.type === "mdxJsxFlowElement" && node.name === "details";
+        if (isDetails) {
+          const visitor = visitChildren((node2) => {
+            const isSummary = node2.type === "mdxJsxTextElement" && node2.name === "summary";
+            if (isSummary) {
+              const value = getFlattenedValue(node2);
+              const id = slugger.slug(value);
+              node2.attributes.push({
+                type: "mdxJsxAttribute",
+                name: "id",
+                value: id
+              });
+            } else if ("children" in node2) {
+              visitor(node2);
+            }
+          });
+          visitor(node);
+        }
+        if (isRemoteContent) {
+        } else if (node.type === "mdxjsEsm") {
+          for (const child of node.data.estree.body) {
+            if (child.type !== "ImportDeclaration") continue;
+            const importPath = child.source.value;
+            const isMdxImport = MARKDOWN_EXTENSION_RE.test(importPath);
+            if (!isMdxImport) continue;
+            const componentName = child.specifiers.find(
+              (o) => o.type === "ImportDefaultSpecifier"
+            )?.local.name;
+            if (!componentName) continue;
+            const { length } = Object.keys(PartialComponentToHeadingsName);
+            const exportAsName = `${exportName}${length}`;
+            PartialComponentToHeadingsName[componentName] = exportAsName;
+            child.specifiers.push({
+              type: "ImportSpecifier",
+              imported: { type: "Identifier", name: exportName },
+              local: { type: "Identifier", name: exportAsName }
+            });
+          }
+        } else {
+          const headingsName = PartialComponentToHeadingsName[node.name];
+          if (headingsName) {
+            headings.push(headingsName);
+          }
+        }
+      }
+    );
+    file.data.toc = headings;
+  };
+};
+export {
+  getFlattenedValue,
+  remarkHeadings
+};

package/dist/server/remark-plugins/remark-link-rewrite.d.ts

@@ -0,0 +1,11 @@
+import { Root } from 'mdast';
+import { Plugin } from './lib/index.js';
+
+type RemarkLinkRewriteOptions = {
+    pattern: RegExp;
+    replace: string;
+    excludeExternalLinks?: boolean;
+};
+declare const remarkLinkRewrite: Plugin<[RemarkLinkRewriteOptions], Root>;
+
+export { type RemarkLinkRewriteOptions, remarkLinkRewrite };

package/dist/server/remark-plugins/remark-link-rewrite.js

@@ -0,0 +1,12 @@
+import { visit } from "unist-util-visit";
+import { EXTERNAL_URL_RE } from "../constants.js";
+const remarkLinkRewrite = ({ pattern, replace, excludeExternalLinks }) => (ast) => {
+  visit(ast, "link", (node) => {
+    if (!excludeExternalLinks || !EXTERNAL_URL_RE.test(node.url)) {
+      node.url = node.url.replace(pattern, replace);
+    }
+  });
+};
+export {
+  remarkLinkRewrite
+};

package/dist/server/remark-plugins/remark-mdx-disable-explicit-jsx.d.ts

@@ -0,0 +1,10 @@
+import { Root } from 'mdast';
+import { Plugin } from './lib/index.js';
+
+declare const remarkMdxDisableExplicitJsx: Plugin<[
+    {
+        whiteList: string[];
+    }
+], Root>;
+
+export { remarkMdxDisableExplicitJsx };

package/dist/server/remark-plugins/remark-mdx-disable-explicit-jsx.js

@@ -0,0 +1,10 @@
+import { visit } from "unist-util-visit";
+const remarkMdxDisableExplicitJsx = ({ whiteList }) => (ast) => {
+  const test = whiteList.map((name) => ({ name }));
+  visit(ast, test, (node) => {
+    delete node.data._mdxExplicitJsx;
+  });
+};
+export {
+  remarkMdxDisableExplicitJsx
+};

package/dist/server/remark-plugins/remark-mdx-frontmatter.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'mdast';
+import { Plugin } from './lib/index.js';
+
+declare const remarkMdxFrontMatter: Plugin<[], Root>;
+
+export { remarkMdxFrontMatter };

package/dist/server/remark-plugins/remark-mdx-frontmatter.js

@@ -0,0 +1,37 @@
+import { valueToEstree } from "estree-util-value-to-estree";
+import { parse as parseYaml } from "yaml";
+import { createAstExportConst } from "../utils.js";
+import { isExportNode } from "./remark-mdx-title.js";
+function createNode(data) {
+  return {
+    type: "mdxjsEsm",
+    data: {
+      estree: {
+        body: [createAstExportConst("metadata", valueToEstree(data))]
+      }
+    }
+  };
+}
+const transformer = (ast) => {
+  const yamlNodeIndex = ast.children.findIndex((node) => node.type === "yaml");
+  const esmNodeIndex = ast.children.findIndex(
+    (node) => isExportNode(node, "metadata")
+  );
+  const hasYaml = yamlNodeIndex !== -1;
+  const hasEsm = esmNodeIndex !== -1;
+  if (hasYaml) {
+    if (hasEsm) {
+      throw new Error(
+        "Both YAML front matter and `metadata` aren't supported. Keep only 1."
+      );
+    }
+    const node = ast.children[yamlNodeIndex];
+    ast.children[yamlNodeIndex] = createNode(parseYaml(node.value) ?? {});
+  } else if (!hasEsm) {
+    ast.children.unshift(createNode({}));
+  }
+};
+const remarkMdxFrontMatter = () => transformer;
+export {
+  remarkMdxFrontMatter
+};

package/dist/server/remark-plugins/remark-mdx-title.d.ts

@@ -0,0 +1,10 @@
+import { Property } from 'estree';
+import { Root, RootContent } from 'mdast';
+import { MdxjsEsmHast } from 'mdast-util-mdxjs-esm';
+import { Plugin } from './lib/index.js';
+
+declare function getFrontMatterASTObject(node: MdxjsEsmHast): Property[];
+declare function isExportNode(node: MdxjsEsmHast | RootContent, varName: string): node is MdxjsEsmHast;
+declare const remarkMdxTitle: Plugin<[], Root>;
+
+export { getFrontMatterASTObject, isExportNode, remarkMdxTitle };

package/dist/server/remark-plugins/remark-mdx-title.js

@@ -0,0 +1,53 @@
+import path from "path";
+import { EXIT, visit } from "unist-util-visit";
+import { pageTitleFromFilename } from "../utils.js";
+import { getFlattenedValue } from "./remark-headings.js";
+function getFrontMatterASTObject(node) {
+  const [n] = node.data.estree.body;
+  return n.declaration.declarations[0].init.properties;
+}
+function isExportNode(node, varName) {
+  if (node.type !== "mdxjsEsm") return false;
+  const n = node.data.estree.body[0];
+  if (n.type !== "ExportNamedDeclaration") return false;
+  const name = n.declaration?.declarations?.[0].id.name;
+  if (!name) return false;
+  return name === varName;
+}
+const transformer = (ast, file) => {
+  let title = "";
+  const frontMatterNode = ast.children.find(
+    (node) => isExportNode(node, "metadata")
+  );
+  for (const { key, value } of getFrontMatterASTObject(frontMatterNode)) {
+    if (key.type === "Literal" && key.value === "title") {
+      title = value.value;
+      break;
+    }
+    if (key.type === "Identifier" && key.name === "title") {
+      title = value.value;
+      break;
+    }
+  }
+  if (!title) {
+    visit(ast, { type: "heading", depth: 1 }, (node) => {
+      title = getFlattenedValue(node);
+      return EXIT;
+    });
+    if (!title) {
+      const [filePath] = file.history;
+      if (filePath) {
+        title = pageTitleFromFilename(path.parse(filePath).name);
+      }
+    }
+    if (title) {
+      file.data.title = title;
+    }
+  }
+};
+const remarkMdxTitle = () => transformer;
+export {
+  getFrontMatterASTObject,
+  isExportNode,
+  remarkMdxTitle
+};

package/dist/server/remark-plugins/remark-remove-imports.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'mdast';
+import { Plugin } from './lib/index.js';
+
+declare const remarkRemoveImports: Plugin<[], Root>;
+
+export { remarkRemoveImports };

package/dist/server/remark-plugins/remark-remove-imports.js

@@ -0,0 +1,12 @@
+import { remove } from "unist-util-remove";
+const transformer = (ast) => {
+  remove(
+    ast,
+    (node) => node.type === "mdxjsEsm" && // @ts-expect-error -- fixme
+    node.data.estree.body[0].type === "ImportDeclaration"
+  );
+};
+const remarkRemoveImports = () => transformer;
+export {
+  remarkRemoveImports
+};

package/dist/server/remark-plugins/remark-static-image.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'mdast';
+import { Plugin } from './lib/index.js';
+
+declare const remarkStaticImage: Plugin<[], Root>;
+
+export { remarkStaticImage };

package/dist/server/remark-plugins/remark-static-image.js

@@ -0,0 +1,107 @@
+import path from "path";
+import { visit } from "unist-util-visit";
+import { EXTERNAL_URL_RE } from "../constants.js";
+const VALID_BLUR_EXT = [".jpeg", ".png", ".webp", ".avif", ".jpg"];
+const VARIABLE_PREFIX = "__img";
+const transformer = (ast) => {
+  const definitionNodes = [];
+  const imageImports = /* @__PURE__ */ new Set();
+  const imageNodes = [];
+  visit(ast, "definition", (node) => {
+    definitionNodes.push(node);
+  });
+  visit(ast, ["image", "imageReference"], (_node) => {
+    const node = _node;
+    let url = decodeURI(
+      node.type === "image" ? node.url : definitionNodes.find(
+        (definition) => definition.identifier === node.identifier
+      )?.url ?? ""
+    );
+    if (!url) {
+      return;
+    }
+    if (EXTERNAL_URL_RE.test(url)) {
+      return;
+    }
+    if (url.startsWith("/")) {
+      url = path.posix.join("private-next-root-dir", "public", url);
+    }
+    imageImports.add(url);
+    node.url = url;
+    imageNodes.push(node);
+  });
+  const imageUrls = [...imageImports];
+  for (const node of imageNodes) {
+    const { url } = node;
+    const imageIndex = imageUrls.indexOf(url);
+    const variableName = `${VARIABLE_PREFIX}${imageIndex}`;
+    const hasBlur = VALID_BLUR_EXT.some((ext) => url.endsWith(ext));
+    Object.assign(node, {
+      type: "mdxJsxFlowElement",
+      name: "img",
+      attributes: [
+        // do not render empty alt in html markup
+        node.alt && {
+          type: "mdxJsxAttribute",
+          name: "alt",
+          value: node.alt
+        },
+        hasBlur && {
+          type: "mdxJsxAttribute",
+          name: "placeholder",
+          value: "blur"
+        },
+        {
+          type: "mdxJsxAttribute",
+          name: "src",
+          value: {
+            type: "mdxJsxAttributeValueExpression",
+            value: variableName,
+            data: {
+              estree: {
+                body: [
+                  {
+                    type: "ExpressionStatement",
+                    expression: { type: "Identifier", name: variableName }
+                  }
+                ]
+              }
+            }
+          }
+        }
+      ].filter((v) => !!v)
+    });
+  }
+  if (imageUrls.length) {
+    ast.children.unshift(
+      ...imageUrls.map(
+        (imageUrl, index) => ({
+          type: "mdxjsEsm",
+          data: {
+            estree: {
+              body: [
+                {
+                  type: "ImportDeclaration",
+                  source: { type: "Literal", value: imageUrl },
+                  specifiers: [
+                    {
+                      type: "ImportDefaultSpecifier",
+                      local: {
+                        type: "Identifier",
+                        name: `${VARIABLE_PREFIX}${index}`
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          }
+        })
+      )
+    );
+  }
+};
+const remarkStaticImage = () => transformer;
+export {
+  remarkStaticImage
+};