@depup/nextra 4.6.1-depup.0

package/dist/server/page-map/index.js

@@ -0,0 +1,24 @@
+import { normalizePageMap } from "./normalize.js";
+import { convertToPageMap } from "./to-page-map.js";
+import { mergeMetaWithPageMap } from "./merge-meta-with-page-map.js";
+import { getPageMap } from "./get.js";
+import { createIndexPage, getIndexPageMap } from "./index-page.js";
+function getMetadata(page) {
+  if ("generateMetadata" in page && // `@sentry/nextjs` makes `generateMetadata` getter function which can be `undefined`
+  page.generateMetadata) {
+    return page.generateMetadata({});
+  }
+  if ("metadata" in page) {
+    return page.metadata;
+  }
+  return {};
+}
+export {
+  convertToPageMap,
+  createIndexPage,
+  getIndexPageMap,
+  getMetadata,
+  getPageMap,
+  mergeMetaWithPageMap,
+  normalizePageMap
+};

package/dist/server/page-map/merge-meta-with-page-map.d.ts

@@ -0,0 +1,17 @@
+import { Folder, PageMapItem, TItem, DynamicMeta } from '../../types.js';
+import 'mdast';
+import 'next';
+import 'react';
+import 'zod';
+import '../schemas.js';
+import './lib/index.js';
+import 'rehype-katex/lib/index.js';
+import 'better-react-mathjax';
+import 'rehype-pretty-code';
+import '../../types.generated.js';
+import '@mdx-js/mdx';
+import 'rehype-katex';
+
+declare function mergeMetaWithPageMap<T extends Folder | PageMapItem[] | TItem>(pageMap: T, meta: DynamicMeta, shouldCheckIndividualMetaFilesUsage?: boolean): T;
+
+export { mergeMetaWithPageMap };

package/dist/server/page-map/merge-meta-with-page-map.js

@@ -0,0 +1,74 @@
+import path from "path";
+import { pageTitleFromFilename } from "../utils.js";
+function isFolder(value) {
+  return !!value && typeof value === "object" && "items" in value && // @ts-expect-error -- fixme
+  value.type !== "menu";
+}
+function normalizeMetaRecord(obj, map) {
+  return Object.fromEntries(
+    Object.entries(obj).map(([key, value]) => {
+      let val;
+      if (isFolder(value)) {
+        const { items: _items, ...rest } = value;
+        val = rest;
+      } else {
+        val = value;
+      }
+      return [key, map[key] ? val : val || pageTitleFromFilename(key)];
+    })
+  );
+}
+function mergeMetaWithPageMap(pageMap, meta, shouldCheckIndividualMetaFilesUsage = false) {
+  if ("children" in pageMap) {
+    return {
+      ...pageMap,
+      children: mergeMetaWithPageMap(
+        // @ts-expect-error -- fixme
+        pageMap.children,
+        meta,
+        shouldCheckIndividualMetaFilesUsage
+      )
+    };
+  }
+  const result = pageMap.map(({ __pagePath, ...restParent }) => {
+    if ("children" in restParent) {
+      restParent.children = mergeMetaWithPageMap(
+        restParent.children,
+        // @ts-expect-error -- fixme
+        meta[restParent.name]?.items || {}
+      );
+      return restParent;
+    }
+    return restParent;
+  });
+  const normalizedMetaRecord = normalizeMetaRecord(
+    meta,
+    // @ts-expect-error -- fixme
+    Object.fromEntries(result.map((key) => [key.name, key.frontMatter]))
+  );
+  const metaRecord = result[0] && "data" in result[0] && result[0].data;
+  if (metaRecord) {
+    if (shouldCheckIndividualMetaFilesUsage) {
+      const childRoute = result[1].route;
+      const { dir } = path.parse(childRoute);
+      const metaPath = `${dir.replace(/^\/$/, "")}/_meta`;
+      throw new Error(
+        [
+          "Merging an `_meta.global` file with a folder-specific `_meta` is unsupported.",
+          `Move content of \`${metaPath}\` file into the \`_meta.global\` file`
+        ].join("\n")
+      );
+    }
+    ;
+    result[0].data = {
+      ...metaRecord,
+      ...normalizedMetaRecord
+    };
+  } else {
+    result.unshift({ data: normalizedMetaRecord });
+  }
+  return result;
+}
+export {
+  mergeMetaWithPageMap
+};

package/dist/server/page-map/normalize.d.ts

@@ -0,0 +1,17 @@
+import { PageMapItem, Folder, TItem } from '../../types.js';
+import 'mdast';
+import 'next';
+import 'react';
+import 'zod';
+import '../schemas.js';
+import './lib/index.js';
+import 'rehype-katex/lib/index.js';
+import 'better-react-mathjax';
+import 'rehype-pretty-code';
+import '../../types.generated.js';
+import '@mdx-js/mdx';
+import 'rehype-katex';
+
+declare function normalizePageMap(pageMap: PageMapItem[] | Folder | TItem): any;
+
+export { normalizePageMap };

package/dist/server/page-map/normalize.js

@@ -0,0 +1,122 @@
+import { z } from "zod";
+import { metaSchema } from "../schemas.js";
+import { pageTitleFromFilename } from "../utils.js";
+function normalizePageMap(pageMap) {
+  if (Array.isArray(pageMap)) {
+    return sortFolder(
+      pageMap.map((item) => "children" in item ? normalizePageMap(item) : item)
+    );
+  }
+  return sortFolder(pageMap);
+}
+function titlize(item, meta) {
+  const titleFromMeta = meta[item.name]?.title;
+  if (titleFromMeta) return titleFromMeta;
+  if ("frontMatter" in item && item.frontMatter) {
+    const titleFromFrontMatter = item.frontMatter.sidebarTitle || item.frontMatter.title;
+    if (titleFromFrontMatter) return titleFromFrontMatter;
+  }
+  return pageTitleFromFilename(item.name);
+}
+function sortFolder(pageMap) {
+  const newChildren = [];
+  const isFolder = !Array.isArray(pageMap);
+  const folder = isFolder ? { ...pageMap } : { children: pageMap };
+  const meta = {};
+  for (const item of folder.children) {
+    if (isFolder && "frontMatter" in item && item.frontMatter?.asIndexPage && item.route === folder.route) {
+      folder.frontMatter = item.frontMatter;
+    } else if ("children" in item) {
+      newChildren.push(normalizePageMap(item));
+    } else if ("data" in item) {
+      for (const [key, titleOrObject] of Object.entries(item.data)) {
+        const { data, error } = metaSchema.safeParse(titleOrObject);
+        if (error) {
+          throw z.prettifyError(error);
+        }
+        if (key === "*") {
+          delete data.title;
+          delete data.href;
+        }
+        meta[key] = data;
+      }
+    } else {
+      newChildren.push(item);
+    }
+  }
+  const metaKeys = Object.keys(meta);
+  const hasIndexKey = metaKeys.includes("index");
+  const items = newChildren.sort((a, b) => {
+    const indexA = metaKeys.indexOf(a.name);
+    const indexB = metaKeys.indexOf(b.name);
+    if (!hasIndexKey) {
+      if (b.name === "index") return 1;
+      if (a.name === "index") return -1;
+    }
+    if (indexA === -1 && indexB === -1) return a.name < b.name ? -1 : 1;
+    if (indexA === -1) return 1;
+    if (indexB === -1) return -1;
+    return indexA - indexB;
+  });
+  for (const [index, metaKey] of metaKeys.filter((key) => key !== "*").entries()) {
+    const metaItem = meta[metaKey];
+    const item = items.find((item2) => item2.name === metaKey);
+    if (metaItem.type === "menu" && item) {
+      item.items = metaItem.items;
+      const { children } = items.find(
+        (i) => i.name === metaKey
+      );
+      for (const [key, value] of Object.entries(
+        // @ts-expect-error fixme
+        item.items
+      )) {
+        if (!value.href && children.every((i) => i.name !== key)) {
+          throw new Error(
+            `Validation of "_meta" file has failed.
+The field key "${metaKey}.items.${key}" in \`_meta\` file refers to a page that cannot be found, remove this key from "_meta" file.`
+          );
+        }
+      }
+    }
+    if (item) continue;
+    const isValid = metaItem.type === "separator" || metaItem.type === "menu" || metaItem.href;
+    if (!isValid) {
+      throw new Error(
+        `Validation of "_meta" file has failed.
+The field key "${metaKey}" in \`_meta\` file refers to a page that cannot be found, remove this key from "_meta" file.`
+      );
+    }
+    const currentItem = items[index];
+    if (currentItem?.name === metaKey) continue;
+    items.splice(
+      index,
+      // index at which to start changing the array
+      0,
+      // remove zero items
+      // @ts-expect-error fixme
+      { name: metaKey, ...meta[metaKey] }
+    );
+  }
+  if (metaKeys.length) {
+    items.unshift({ data: meta });
+  }
+  const itemsWithTitle = items.map((item) => {
+    const isSeparator = "type" in item && item.type === "separator";
+    if ("name" in item && !isSeparator) {
+      return {
+        ...item,
+        title: titlize(item, meta)
+      };
+    }
+    return item;
+  });
+  const result = isFolder ? {
+    ...folder,
+    title: titlize(folder, {}),
+    children: itemsWithTitle
+  } : itemsWithTitle;
+  return result;
+}
+export {
+  normalizePageMap
+};

package/dist/server/page-map/placeholder.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/server/page-map/to-ast.d.ts

@@ -0,0 +1,18 @@
+import { ArrayExpression } from 'estree';
+import { TItem, Import } from '../../types.js';
+import 'mdast';
+import 'next';
+import 'react';
+import 'zod';
+import '../schemas.js';
+import './lib/index.js';
+import 'rehype-katex/lib/index.js';
+import 'better-react-mathjax';
+import 'rehype-pretty-code';
+import '../../types.generated.js';
+import '@mdx-js/mdx';
+import 'rehype-katex';
+
+declare function convertPageMapToAst(pageMap: TItem[], imports: Import[]): ArrayExpression;
+
+export { convertPageMapToAst };

package/dist/server/page-map/to-ast.js

@@ -0,0 +1,47 @@
+import path from "path";
+import { MARKDOWN_EXTENSION_RE } from "../constants.js";
+import { createAstObject } from "../utils.js";
+function cleanFilePath(filePath) {
+  const { dir, name } = path.parse(filePath);
+  const fileName = `${dir.replace(/^(src\/)?content\/?/, "")}_${name}`;
+  return (
+    // handle non-"\w" characters
+    encodeURI(fileName).replaceAll(/[\W_]+/g, "_").replace(/^_/, "").replace(/^\d/, (match) => `_${match}`)
+  );
+}
+function convertPageMapToAst(pageMap, imports) {
+  const elements = pageMap.map((item) => {
+    if ("children" in item) {
+      return createAstObject({
+        name: item.name,
+        route: item.route,
+        children: convertPageMapToAst(item.children, imports)
+      });
+    }
+    if ("route" in item) {
+      const filePath2 = item.__pagePath;
+      const importName2 = cleanFilePath(filePath2);
+      imports.push({ importName: importName2, filePath: filePath2 });
+      return createAstObject({
+        name: item.name,
+        route: item.route,
+        frontMatter: MARKDOWN_EXTENSION_RE.test(filePath2) ? { type: "Identifier", name: importName2 } : {
+          type: "CallExpression",
+          callee: { type: "Identifier", name: "getMetadata" },
+          arguments: [{ type: "Identifier", name: importName2 }],
+          optional: false
+        }
+      });
+    }
+    const filePath = item.__metaPath;
+    const importName = cleanFilePath(filePath);
+    imports.push({ importName, filePath });
+    return createAstObject({
+      data: { type: "Identifier", name: importName }
+    });
+  });
+  return { type: "ArrayExpression", elements };
+}
+export {
+  convertPageMapToAst
+};

package/dist/server/page-map/to-js.d.ts

@@ -0,0 +1,21 @@
+import { TItem } from '../../types.js';
+import 'mdast';
+import 'next';
+import 'react';
+import 'zod';
+import '../schemas.js';
+import './lib/index.js';
+import 'rehype-katex/lib/index.js';
+import 'better-react-mathjax';
+import 'rehype-pretty-code';
+import '../../types.generated.js';
+import '@mdx-js/mdx';
+import 'rehype-katex';
+
+declare function convertPageMapToJs({ pageMap, mdxPages, globalMetaPath }: {
+    pageMap: TItem[];
+    mdxPages: Record<string, string>;
+    globalMetaPath?: string;
+}): string;
+
+export { convertPageMapToJs };

package/dist/server/page-map/to-js.js

@@ -0,0 +1,72 @@
+import { toJs } from "estree-util-to-js";
+import { MARKDOWN_EXTENSION_RE, METADATA_ONLY_RQ } from "../constants.js";
+import { convertPageMapToAst } from "./to-ast.js";
+const META_RE = /_meta\.[jt]sx?$/;
+function convertPageMapToJs({
+  pageMap,
+  mdxPages,
+  globalMetaPath
+}) {
+  const imports = [];
+  const pageMapAst = convertPageMapToAst(pageMap, imports);
+  const importsAst = imports.map(
+    ({ filePath, importName }) => {
+      const isMdx = MARKDOWN_EXTENSION_RE.test(filePath);
+      const isMeta = META_RE.test(filePath);
+      return {
+        type: "ImportDeclaration",
+        source: {
+          type: "Literal",
+          // Add resource query only for `.md`, `.mdx` files
+          value: `private-next-root-dir/${filePath}${isMdx ? METADATA_ONLY_RQ : ""}`
+        },
+        specifiers: [
+          isMeta || isMdx ? {
+            local: { type: "Identifier", name: importName },
+            ...isMeta ? { type: "ImportDefaultSpecifier" } : {
+              type: "ImportSpecifier",
+              imported: { type: "Identifier", name: "metadata" }
+            }
+          } : {
+            type: "ImportNamespaceSpecifier",
+            local: { type: "Identifier", name: importName }
+          }
+        ]
+      };
+    }
+  );
+  const importsResult = toJs({
+    type: "Program",
+    sourceType: "module",
+    body: importsAst
+  });
+  const pageMapResult = toJs({
+    type: "Program",
+    sourceType: "module",
+    body: [{ type: "ExpressionStatement", expression: pageMapAst }]
+  });
+  let pageMapRawJs = pageMapResult.value.slice(
+    0,
+    -2
+    /* replace semicolon */
+  );
+  if (globalMetaPath) {
+    pageMapRawJs = `mergeMetaWithPageMap(${pageMapRawJs}, globalMeta, true)`;
+  }
+  const rawJs = `import { ${[
+    "normalizePageMap",
+    globalMetaPath && "mergeMetaWithPageMap",
+    imports.some(
+      (o) => !MARKDOWN_EXTENSION_RE.test(o.filePath) && !META_RE.test(o.filePath)
+    ) && "getMetadata"
+  ].filter(Boolean).join(", ")} } from 'nextra/page-map'
+${globalMetaPath ? `import globalMeta from 'private-next-root-dir/${globalMetaPath}'` : ""}
+${importsResult.value}
+export const pageMap = normalizePageMap(${pageMapRawJs})
+
+export const RouteToFilepath = ${JSON.stringify(mdxPages, null, 2)}`;
+  return rawJs;
+}
+export {
+  convertPageMapToJs
+};

package/dist/server/page-map/to-page-map.d.ts

@@ -0,0 +1,26 @@
+import { TItem } from '../../types.js';
+import 'mdast';
+import 'next';
+import 'react';
+import 'zod';
+import '../schemas.js';
+import './lib/index.js';
+import 'rehype-katex/lib/index.js';
+import 'better-react-mathjax';
+import 'rehype-pretty-code';
+import '../../types.generated.js';
+import '@mdx-js/mdx';
+import 'rehype-katex';
+
+declare function convertToPageMap({ filePaths, basePath, locale }: {
+    filePaths: string[];
+    basePath?: string;
+    locale?: string;
+}): {
+    pageMap: TItem[];
+    mdxPages: {
+        [k: string]: string;
+    };
+};
+
+export { convertToPageMap };

package/dist/server/page-map/to-page-map.js

@@ -0,0 +1,101 @@
+import path from "path";
+import { normalizeAppPath } from "next/dist/shared/lib/router/utils/app-paths.js";
+function createNested(map, path2) {
+  let current = map;
+  for (const part of path2.split("/")) {
+    current[part] ||= {};
+    current = current[part];
+  }
+}
+const APP_DIR_SUFFIX_RE = /^(src\/)?app\//;
+function convertToPageMap({
+  filePaths,
+  basePath,
+  locale
+}) {
+  const pages = {};
+  const metaFiles = {};
+  const nestedMap = {};
+  for (const filePath of filePaths) {
+    let { name, dir } = path.parse(filePath);
+    const inAppDir = APP_DIR_SUFFIX_RE.test(filePath);
+    if (inAppDir) {
+      dir = dir.replace(/^(src\/)?app(\/|$)/, "");
+    } else {
+      let filePath2 = dir.replace(/^(src\/)?content(\/|$)/, "");
+      if (locale) filePath2 = filePath2.replace(new RegExp(`^${locale}/?`), "");
+      dir = [basePath, filePath2].filter(Boolean).join("/");
+    }
+    if (name === "_meta") {
+      const key = dir ? `${dir}/${name}` : name;
+      metaFiles[key] = filePath;
+    } else if (name !== "_meta.global") {
+      const key = inAppDir ? (
+        // In Next.js we can organize routes without affecting the URL
+        // https://nextjs.org/docs/app/building-your-application/routing/route-groups#organize-routes-without-affecting-the-url-path
+        //
+        // E.g. we have the following filepath:
+        // app/posts/(with-comments)/aaron-swartz-a-programmable-web/()/page.mdx
+        //
+        // will be normalized to:
+        // app/posts/aaron-swartz-a-programmable-web/page.mdx
+        //
+        // The `normalizeAppPath` function ensures a leading slash is present, so we slice it off.
+        normalizeAppPath(dir).slice(1)
+      ) : [dir, name !== "index" && name].filter(Boolean).join("/");
+      pages[key] = filePath;
+    }
+  }
+  for (const path2 of Object.keys(metaFiles)) {
+    createNested(nestedMap, path2);
+  }
+  for (const path2 of Object.keys(pages)) {
+    createNested(nestedMap, path2 && `${path2}/`);
+  }
+  function fillPageMap(obj, prefix) {
+    return Object.entries(obj).map(([key, value]) => {
+      const path2 = prefix && key ? `${prefix}/${key}` : prefix || key;
+      if (key === "_meta") {
+        const __metaPath = metaFiles[path2];
+        if (!__metaPath) {
+          const o = JSON.stringify({ path: path2, metaFiles }, null, 2);
+          throw new Error(`Can't find "_meta" file for:
+${o}`);
+        }
+        return { __metaPath };
+      }
+      const item = {
+        name: key || "index",
+        route: `/${path2}`
+      };
+      const keys = Object.keys(value);
+      const isFolder = keys.length > 1 || keys.length === 1 && keys[0] !== "";
+      if (isFolder) {
+        return { ...item, children: fillPageMap(value, path2) };
+      }
+      const __pagePath = pages[path2];
+      if (!__pagePath) {
+        const o = JSON.stringify({ path: path2, mdxPages: pages }, null, 2);
+        throw new Error(`Can't find "page" file for:
+${o}`);
+      }
+      return { ...item, __pagePath };
+    });
+  }
+  const pageMap = fillPageMap(nestedMap);
+  const mdxPages = Object.fromEntries(
+    Object.entries(pages).flatMap(([key, value]) => {
+      if (basePath) key = key.replace(new RegExp(`^${basePath}/?`), "");
+      value = value.replace(/^(src\/)?content\//, "");
+      if (locale) value = value.replace(new RegExp(`^${locale}/`), "");
+      if (APP_DIR_SUFFIX_RE.test(value)) {
+        return [];
+      }
+      return [[key, value]];
+    })
+  );
+  return { pageMap, mdxPages };
+}
+export {
+  convertToPageMap
+};

package/dist/server/recma-plugins/index.d.ts

@@ -0,0 +1,3 @@
+export { recmaRewrite } from './recma-rewrite.js';
+import 'estree';
+import './lib/index.js';

package/dist/server/recma-plugins/index.js

@@ -0,0 +1,4 @@
+import { recmaRewrite } from "./recma-rewrite.js";
+export {
+  recmaRewrite
+};

package/dist/server/recma-plugins/recma-rewrite.d.ts

@@ -0,0 +1,11 @@
+import { Program } from 'estree';
+import { Plugin } from './lib/index.js';
+
+declare const recmaRewrite: Plugin<[
+    {
+        isPageImport?: boolean;
+        isRemoteContent?: boolean;
+    }
+], Program>;
+
+export { recmaRewrite };

package/dist/server/recma-plugins/recma-rewrite.js

@@ -0,0 +1,98 @@
+import { DEFAULT_PROPERTY_PROPS } from "../constants.js";
+var Mdx = /* @__PURE__ */ ((Mdx2) => {
+  Mdx2["Wrapper"] = "MDXContent";
+  Mdx2["Content"] = "_createMdxContent";
+  return Mdx2;
+})(Mdx || {});
+const recmaRewrite = ({ isPageImport, isRemoteContent }) => (ast) => {
+  const hasMdxLayout = ast.body.some(
+    (node) => node.type === "VariableDeclaration" && node.kind === "const" && node.declarations[0].id.type === "Identifier" && node.declarations[0].id.name === "MDXLayout"
+  );
+  if (isRemoteContent) {
+    if (hasMdxLayout) {
+      return;
+    }
+    ast.body = ast.body.filter(
+      (node) => node.type !== "FunctionDeclaration" || node.id.name !== "MDXContent" /* Wrapper */
+    );
+    const returnStatement = ast.body.find(
+      (node) => node.type === "ReturnStatement"
+    );
+    const { properties } = returnStatement.argument;
+    for (const node of properties) {
+      if (node.type === "Property" && node.key.type === "Identifier" && node.key.name === "default" && node.value.type === "Identifier" && node.value.name === "MDXContent" /* Wrapper */) {
+        node.value.name = "_createMdxContent" /* Content */;
+        break;
+      }
+    }
+    return;
+  }
+  const defaultExport = ast.body.find(
+    (node) => node.type === "ExportDefaultDeclaration"
+  );
+  if (hasMdxLayout) {
+    Object.assign(defaultExport, defaultExport.declaration);
+    ast.body.unshift(HOC_IMPORT_AST);
+    ast.body.push({
+      type: "ExportDefaultDeclaration",
+      declaration: createHocCallAst("MDXContent" /* Wrapper */)
+    });
+    return;
+  }
+  if (isPageImport) {
+    ast.body.unshift(HOC_IMPORT_AST);
+    defaultExport.declaration = createHocCallAst("_createMdxContent" /* Content */);
+    return;
+  }
+  defaultExport.declaration = {
+    type: "Identifier",
+    name: "_createMdxContent" /* Content */
+  };
+};
+const HOC_IMPORT_AST = {
+  type: "ImportDeclaration",
+  source: { type: "Literal", value: "nextra/setup-page" },
+  specifiers: [
+    {
+      type: "ImportSpecifier",
+      imported: { type: "Identifier", name: "HOC_MDXWrapper" },
+      local: { type: "Identifier", name: "HOC_MDXWrapper" }
+    }
+  ]
+};
+function createHocCallAst(componentName) {
+  return {
+    type: "CallExpression",
+    callee: { type: "Identifier", name: "HOC_MDXWrapper" },
+    optional: false,
+    arguments: [
+      { type: "Identifier", name: componentName },
+      {
+        type: "ObjectExpression",
+        properties: [
+          {
+            ...DEFAULT_PROPERTY_PROPS,
+            shorthand: true,
+            key: { type: "Identifier", name: "metadata" },
+            value: { type: "Identifier", name: "metadata" }
+          },
+          {
+            ...DEFAULT_PROPERTY_PROPS,
+            shorthand: true,
+            key: { type: "Identifier", name: "toc" },
+            value: { type: "Identifier", name: "toc" }
+          },
+          {
+            ...DEFAULT_PROPERTY_PROPS,
+            shorthand: true,
+            key: { type: "Identifier", name: "sourceCode" },
+            value: { type: "Identifier", name: "sourceCode" }
+          }
+        ]
+      }
+    ]
+  };
+}
+export {
+  recmaRewrite
+};