@depup/nextra 4.6.1-depup.0

package/dist/client/pages.d.ts

@@ -0,0 +1,131 @@
+import { EvaluateResult } from '../types.js';
+import 'mdast';
+import 'next';
+import 'react';
+import 'zod';
+import '../server/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';
+
+/**
+ * Function to import an MDX/Markdown page from the `content` directory.
+ *
+ * This function is essential for Nextra's dynamic page loading from a catch-all route.
+ *
+ * @returns
+ * A Promise that resolves to an object containing:
+ *  - `default`: The MDX component to render
+ *  - `toc`: Table of contents list
+ *  - `metadata`: Page's front matter or `metadata` object including `title`, `description`, etc.
+ *
+ * @example
+ * ### Basic usage in a dynamic Next.js route
+ *
+ * ```ts
+ * const { default: MDXContent, toc, metadata } = await importPage(['docs', 'getting-started'])
+ * ```
+ *
+ * ### Usage with i18n
+ *
+ * ```ts
+ * const { default: MDXContent } = await importPage(['docs', 'getting-started'], 'en')
+ * ```
+ *
+ * ### Import page's front matter in `generateMetadata` function
+ *
+ * ```ts
+ * // app/[[...mdxPath]]/page.tsx
+ * import { importPage } from 'nextra/pages'
+ *
+ * export async function generateMetadata(props) {
+ *   const params = await props.params
+ *   const { metadata } = await importPage(params.mdxPath)
+ *   return metadata
+ * }
+ * ```
+ *
+ * ### Import page in a catch-all route
+ *
+ * ```tsx
+ * // app/[[...mdxPath]]/page.tsx
+ * import { generateStaticParamsFor, importPage } from 'nextra/pages'
+ * import { useMDXComponents as getMDXComponents } from 'path/to/your/mdx-components'
+ *
+ * export const generateStaticParams = generateStaticParamsFor('mdxPath')
+ *
+ * const Wrapper = getMDXComponents().wrapper
+ *
+ * export default async function Page(props) {
+ *   const params = await props.params
+ *   const result = await importPage(params.mdxPath)
+ *   const { default: MDXContent, toc, metadata } = result
+ *   return (
+ *     <Wrapper toc={toc} metadata={metadata}>
+ *       <MDXContent {...props} params={params} />
+ *     </Wrapper>
+ *   )
+ * }
+ * ```
+ *
+ * @see
+ * - [Content Directory Documentation](https://nextra.site/docs/file-conventions/content-directory)
+ * - [Next.js Dynamic Routes](https://nextjs.org/docs/app/building-your-application/routing/dynamic-routes)
+ * - [Next.js Metadata API](https://nextjs.org/docs/app/building-your-application/optimizing/metadata)
+ */
+declare function importPage(
+/**
+ * Array of path segments representing the route to the page.
+ *
+ * E.g., for the route `/docs/getting-started/installation`, pass `['docs', 'getting-started', 'installation']`.
+ * @default []
+ */
+pathSegments?: string[], 
+/**
+ * The language segment when using i18n.
+ * @default ''
+ */
+lang?: string): Promise<EvaluateResult>;
+/**
+ * Generates static parameters based on your `content` directory structure.
+ *
+ * This helper function is designed to work with Next.js' `generateStaticParams` function to create
+ * static paths for all your MDX/Markdown pages.
+ *
+ * @returns A function that generates an array of parameters for static page generation.
+ *
+ * @example
+ * ### Basic usage with a catch-all route
+ *
+ * ```ts
+ * // app/[[...slug]]/page.tsx
+ * export const generateStaticParams = generateStaticParamsFor('slug')
+ * ```
+ *
+ * ### Usage with i18n support
+ *
+ * ```ts
+ * // app/[locale]/[[...mdxPath]]/page.tsx
+ * export const generateStaticParams = generateStaticParamsFor('mdxPath', 'locale')
+ * ```
+ *
+ * @see
+ * - [Next.js `generateStaticParams` function](https://nextjs.org/docs/app/api-reference/functions/generate-static-params)
+ * - [Content Directory Structure](https://nextra.site/docs/file-conventions/content-directory)
+ */
+declare function generateStaticParamsFor(
+/** The name of your catch-all route segment (e.g., `'slug'`, `'mdxPath'`). */
+segmentKey: string, 
+/**
+ * The name of the locale segment when you have i18n.
+ * @default "lang"
+ */
+localeSegmentKey?: string): () => Promise<{
+    [x: string]: string | string[];
+}[]>;
+
+export { generateStaticParamsFor, importPage };

package/dist/client/pages.js

@@ -0,0 +1,39 @@
+"use no memo";
+import { notFound } from "next/navigation";
+import { getRouteToFilepath } from "../server/page-map/get.js";
+import { logger } from "../server/utils.js";
+async function importPage(pathSegments = [], lang = "") {
+  const RouteToFilepath = await getRouteToFilepath(lang);
+  const pathname = pathSegments.join("/");
+  const decodedPath = decodeURIComponent(pathname);
+  const pagePath = RouteToFilepath[decodedPath];
+  try {
+    return require(`private-next-content-dir/${lang && `${lang}/`}${pagePath}`);
+  } catch (error) {
+    logger.error("Error while loading", {
+      pathSegments
+    }, error);
+    notFound();
+  }
+}
+function generateStaticParamsFor(segmentKey, localeSegmentKey = "lang") {
+  return async () => {
+    const locales = JSON.parse(process.env.NEXTRA_LOCALES);
+    const result = [];
+    for (const locale of locales) {
+      const RouteToFilepath = await getRouteToFilepath(locale);
+      const routes = Object.keys(RouteToFilepath);
+      result.push(...routes.map((route) => ({
+        ...locale && {
+          [localeSegmentKey]: locale
+        },
+        [segmentKey]: route.split("/")
+      })));
+    }
+    return result;
+  };
+}
+export {
+  generateStaticParamsFor,
+  importPage
+};

package/dist/client/remove-links.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode, ReactElement } from 'react';
+
+type TOCElement = ReactElement | string;
+declare function removeLinks(node: ReactNode): TOCElement[] | string;
+
+export { removeLinks };

package/dist/client/remove-links.js

@@ -0,0 +1,35 @@
+"use no memo";
+import { Children, cloneElement } from "react";
+function hasProps(node) {
+  return !!node && typeof node === "object";
+}
+function removeLinks(node) {
+  if (typeof node === "string") {
+    return node;
+  }
+  return Children.map(node, (child) => {
+    if (hasProps(child) && // @ts-expect-error -- fixme
+    child.props.href) {
+      if (child.props["data-footnote-ref"]) {
+        return;
+      }
+      child = child.props.children;
+    }
+    if (typeof child === "string") {
+      return child;
+    }
+    if (Array.isArray(child)) {
+      return removeLinks(child);
+    }
+    if (!hasProps(child)) {
+      return child;
+    }
+    const children = removeLinks(child.props.children);
+    return cloneElement(child, {
+      children
+    });
+  });
+}
+export {
+  removeLinks
+};

package/dist/client/setup-page.d.ts

@@ -0,0 +1,18 @@
+import { ComponentProps, FC } from 'react';
+import { MDXWrapper } from '../types.js';
+import 'mdast';
+import 'next';
+import 'zod';
+import '../server/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';
+
+type WrapperProps = ComponentProps<MDXWrapper>;
+declare function HOC_MDXWrapper(MDXContent: MDXWrapper, hocProps: Omit<WrapperProps, 'children'>): FC<WrapperProps>;
+
+export { HOC_MDXWrapper };

package/dist/client/setup-page.js

@@ -0,0 +1,14 @@
+"use no memo";
+import { jsx } from "react/jsx-runtime";
+import { useMDXComponents as getMDXComponents } from "next-mdx-import-source-file";
+import { createElement } from "react";
+const Wrapper = getMDXComponents().wrapper;
+function HOC_MDXWrapper(MDXContent, hocProps) {
+  return function MDXWrapper(props) {
+    const children = createElement(MDXContent, props);
+    return Wrapper ? /* @__PURE__ */ jsx(Wrapper, { ...hocProps, children }) : children;
+  };
+}
+export {
+  HOC_MDXWrapper
+};

package/dist/server/compile-metadata.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `nextra/dist/server/page-map/placeholder.js` imports all `metadata`s from `.md`/`.mdx` files to
+ * build `pageMap`.
+ * If a request includes the resource query `?metadata`, compiling MDX to JSX is unnecessary.
+ * This step can be skipped to improve performance in the development environment.
+ */
+declare function compileMetadata(source: string, { filePath, lastCommitTime }: {
+    filePath: string;
+    lastCommitTime?: number;
+}): Promise<string>;
+
+export { compileMetadata };

package/dist/server/compile-metadata.js

@@ -0,0 +1,39 @@
+import { createProcessor } from "@mdx-js/mdx";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkMath from "remark-math";
+import {
+  remarkAssignFrontMatter,
+  remarkExportOnlyMetadata,
+  remarkMdxFrontMatter,
+  remarkMdxTitle
+} from "./remark-plugins/index.js";
+async function compileMetadata(source, { filePath, lastCommitTime }) {
+  const format = filePath.endsWith(".mdx") ? "mdx" : "md";
+  const compiler = createProcessor({
+    format,
+    remarkPlugins: [
+      remarkFrontmatter,
+      // parse and attach yaml node
+      remarkMdxFrontMatter,
+      remarkMdxTitle,
+      [remarkAssignFrontMatter, { lastCommitTime }],
+      remarkExportOnlyMetadata,
+      remarkMath
+      // https://github.com/shuding/nextra/issues/4164
+    ],
+    recmaPlugins: [recmaExportOnlyMetadata]
+  });
+  const vFile = await compiler.process({ value: source, path: filePath });
+  return vFile.value;
+}
+const transformer = (ast) => {
+  const importReact = ast.body[0];
+  ast.body = ast.body.filter(
+    (node) => node.type === "ExportNamedDeclaration" && node.declaration.declarations[0].id.name === "metadata"
+  );
+  ast.body.unshift(importReact);
+};
+const recmaExportOnlyMetadata = () => transformer;
+export {
+  compileMetadata
+};

package/dist/server/compile.d.ts

@@ -0,0 +1,39 @@
+import { ProcessorOptions } from '@mdx-js/mdx';
+import { LoaderOptions } from '../types.js';
+import { NextraConfig } from '../types.generated.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 'rehype-katex';
+
+type MdxOptions = NextraConfig['mdxOptions'] & Pick<ProcessorOptions, 'jsx' | 'outputFormat' | 'providerImportSource'>;
+type CompileMdxOptions = Pick<LoaderOptions, 'staticImage' | 'search' | 'defaultShowCopyCode' | 'readingTime' | 'latex' | 'codeHighlight' | 'whiteListTagsStyling'> & {
+    /** @default {} */
+    mdxOptions: MdxOptions;
+    /** @default '' */
+    filePath: string;
+    useCachedCompiler: boolean;
+    /** @default false */
+    isPageImport: boolean;
+    lastCommitTime: number;
+};
+/**
+ * @example
+ * ```ts
+ * // Usage with MDXRemote
+ * import { compileMdx } from 'nextra/compile'
+ * import { MDXRemote } from 'nextra/mdx-remote'
+ *
+ * const rawJs = await compileMdx(rawMdx)
+ * const content = <MDXRemote compiledSource={rawJs} components={...} scope={...} />
+ * ```
+ */
+declare function compileMdx(rawMdx: string, { staticImage, search, readingTime, latex, codeHighlight, defaultShowCopyCode, mdxOptions, filePath, useCachedCompiler, isPageImport, whiteListTagsStyling, lastCommitTime }?: Partial<CompileMdxOptions>): Promise<string>;
+
+export { compileMdx };

package/dist/server/compile.js

@@ -0,0 +1,158 @@
+import { createProcessor } from "@mdx-js/mdx";
+import { remarkMermaid } from "@theguild/remark-mermaid";
+import { remarkNpm2Yarn } from "@theguild/remark-npm2yarn";
+import rehypeKatex from "rehype-katex";
+import rehypePrettyCode from "rehype-pretty-code";
+import rehypeRaw from "rehype-raw";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import remarkReadingTime from "remark-reading-time";
+import remarkSmartypants from "remark-smartypants";
+import { MARKDOWN_URL_EXTENSION_RE } from "./constants.js";
+import { recmaRewrite } from "./recma-plugins/index.js";
+import {
+  DEFAULT_REHYPE_PRETTY_CODE_OPTIONS,
+  rehypeAttachCodeMeta,
+  rehypeBetterReactMathjax,
+  rehypeExtractTocContent,
+  rehypeParseCodeMeta,
+  rehypeTwoslashPopup
+} from "./rehype-plugins/index.js";
+import {
+  remarkAssignFrontMatter,
+  remarkCustomHeadingId,
+  remarkExportSourceCode,
+  remarkHeadings,
+  remarkLinkRewrite,
+  remarkMdxDisableExplicitJsx,
+  remarkMdxFrontMatter,
+  remarkMdxTitle,
+  remarkRemoveImports,
+  remarkStaticImage
+} from "./remark-plugins/index.js";
+const cachedCompilerForFormat = /* @__PURE__ */ Object.create(null);
+async function compileMdx(rawMdx, {
+  staticImage,
+  search,
+  readingTime,
+  latex,
+  codeHighlight,
+  defaultShowCopyCode,
+  mdxOptions = {},
+  filePath = "",
+  useCachedCompiler,
+  isPageImport = false,
+  whiteListTagsStyling = [],
+  lastCommitTime
+} = {}) {
+  const {
+    jsx = false,
+    format: _format = "mdx",
+    outputFormat = "function-body",
+    remarkPlugins,
+    rehypePlugins,
+    recmaPlugins,
+    rehypePrettyCodeOptions,
+    providerImportSource = "next-mdx-import-source-file"
+  } = mdxOptions;
+  const format = _format === "detect" ? filePath.endsWith(".mdx") ? "mdx" : "md" : _format;
+  const fileCompatible = filePath ? { value: rawMdx, path: filePath } : rawMdx;
+  const isRemoteContent = outputFormat === "function-body";
+  const compiler = !useCachedCompiler || isRemoteContent ? createCompiler() : cachedCompilerForFormat[`${format}:${isPageImport}`] ||= createCompiler();
+  const processor = compiler();
+  try {
+    const vFile = await processor.process(fileCompatible);
+    const rawJs = vFile.value.replaceAll("__esModule", String.raw`_\_esModule`);
+    return rawJs;
+  } catch (error) {
+    console.error(`[nextra] Error compiling ${filePath}.`);
+    throw error;
+  }
+  function createCompiler() {
+    return createProcessor({
+      jsx,
+      format,
+      outputFormat,
+      providerImportSource,
+      // Fix TypeError: _jsx is not a function for remote content
+      development: process.env.NODE_ENV === "development",
+      remarkPlugins: [
+        ...remarkPlugins || [],
+        remarkMermaid,
+        // should be before remarkRemoveImports because contains `import { Mermaid } from ...`
+        [
+          remarkNpm2Yarn,
+          // should be before remarkRemoveImports because contains `import { Tabs as $Tabs, Tab as $Tab } from ...`
+          {
+            packageName: "nextra/components",
+            tabNamesProp: "items",
+            storageKey: "selectedPackageManager"
+          }
+        ],
+        isRemoteContent && remarkRemoveImports,
+        remarkFrontmatter,
+        // parse and attach yaml node
+        remarkMdxFrontMatter,
+        readingTime && remarkReadingTime,
+        // before mdx title
+        remarkCustomHeadingId,
+        remarkMdxTitle,
+        [remarkAssignFrontMatter, { lastCommitTime }],
+        remarkGfm,
+        format !== "md" && [
+          remarkMdxDisableExplicitJsx,
+          // Replace the <summary> and <details> with customized components
+          { whiteList: ["details", "summary", ...whiteListTagsStyling] }
+        ],
+        [remarkHeadings, { isRemoteContent }],
+        staticImage && remarkStaticImage,
+        latex && remarkMath,
+        // Remove the markdown file extension from links
+        [
+          remarkLinkRewrite,
+          {
+            pattern: MARKDOWN_URL_EXTENSION_RE,
+            replace: "",
+            excludeExternalLinks: true
+          }
+        ],
+        remarkSmartypants,
+        remarkExportSourceCode
+      ].filter((v) => !!v),
+      rehypePlugins: [
+        ...rehypePlugins || [],
+        format === "md" && [
+          // To render `<details>` and `<summary>` correctly
+          rehypeRaw,
+          // fix Error: Cannot compile `mdxjsEsm` node for npm2yarn and mermaid
+          {
+            passThrough: ["mdxjsEsm", "mdxJsxFlowElement", "mdxTextExpression"]
+          }
+        ],
+        [rehypeParseCodeMeta, { defaultShowCopyCode }],
+        // Should be before `rehypePrettyCode`
+        latex && (typeof latex === "object" ? latex.renderer === "mathjax" ? [rehypeBetterReactMathjax, latex.options, isRemoteContent] : [rehypeKatex, latex.options] : rehypeKatex),
+        ...codeHighlight === false ? [] : [
+          [
+            rehypePrettyCode,
+            {
+              ...DEFAULT_REHYPE_PRETTY_CODE_OPTIONS,
+              ...rehypePrettyCodeOptions
+            }
+          ],
+          rehypeTwoslashPopup,
+          [rehypeAttachCodeMeta, { search }]
+        ],
+        rehypeExtractTocContent
+      ].filter((v) => !!v),
+      recmaPlugins: [
+        ...recmaPlugins || [],
+        [recmaRewrite, { isPageImport, isRemoteContent }]
+      ]
+    });
+  }
+}
+export {
+  compileMdx
+};

package/dist/server/constants.d.ts

@@ -0,0 +1,15 @@
+declare const MARKDOWN_EXTENSION_RE: RegExp;
+declare const CWD: string;
+declare const MARKDOWN_URL_EXTENSION_RE: RegExp;
+declare const IS_PRODUCTION: boolean;
+declare const EXTERNAL_URL_RE: RegExp;
+declare const DEFAULT_PROPERTY_PROPS: {
+    type: "Property";
+    kind: "init";
+    method: false;
+    shorthand: false;
+    computed: false;
+};
+declare const METADATA_ONLY_RQ = "?metadata";
+
+export { CWD, DEFAULT_PROPERTY_PROPS, EXTERNAL_URL_RE, IS_PRODUCTION, MARKDOWN_EXTENSION_RE, MARKDOWN_URL_EXTENSION_RE, METADATA_ONLY_RQ };

package/dist/server/constants.js

@@ -0,0 +1,22 @@
+const MARKDOWN_EXTENSION_RE = /\.mdx?$/;
+const CWD = process.cwd();
+const MARKDOWN_URL_EXTENSION_RE = /\.mdx?(?:(?=[#?])|$)/;
+const IS_PRODUCTION = process.env.NODE_ENV === "production";
+const EXTERNAL_URL_RE = /^https?:\/\//;
+const DEFAULT_PROPERTY_PROPS = {
+  type: "Property",
+  kind: "init",
+  method: false,
+  shorthand: false,
+  computed: false
+};
+const METADATA_ONLY_RQ = "?metadata";
+export {
+  CWD,
+  DEFAULT_PROPERTY_PROPS,
+  EXTERNAL_URL_RE,
+  IS_PRODUCTION,
+  MARKDOWN_EXTENSION_RE,
+  MARKDOWN_URL_EXTENSION_RE,
+  METADATA_ONLY_RQ
+};

package/dist/server/fetch-filepaths-from-github.d.ts

@@ -0,0 +1,10 @@
+type Params = {
+    user: string;
+    repo: string;
+    branch: string;
+    docsPath: string;
+    outputPath: string;
+};
+declare function fetchFilePathsFromGitHub({ user, repo, branch, docsPath, outputPath }: Params): Promise<void>;
+
+export { fetchFilePathsFromGitHub };

package/dist/server/fetch-filepaths-from-github.js

@@ -0,0 +1,36 @@
+import fs from "fs/promises";
+import { MARKDOWN_EXTENSION_RE } from "./constants.js";
+async function fetchFilePathsFromGitHub({
+  user,
+  repo,
+  branch,
+  docsPath,
+  outputPath
+}) {
+  const url = `https://api.github.com/repos/${user}/${repo}/git/trees/${branch}?recursive=1`;
+  const response = await fetch(url);
+  const data = await response.json();
+  if (data.message) {
+    console.error(
+      "\u274C GitHub API rate limit exceeded, skipping\u2026",
+      JSON.stringify(data, null, 2)
+    );
+    process.exit(0);
+  }
+  const filePaths = data.tree.filter((item) => item.path.startsWith(docsPath)).map((item) => item.path.replace(docsPath, ""));
+  const result = {
+    user,
+    repo,
+    branch,
+    docsPath,
+    filePaths: filePaths.filter(
+      (filePath) => MARKDOWN_EXTENSION_RE.test(filePath)
+    )
+  };
+  const json = JSON.stringify(result, null, 2);
+  await fs.writeFile(outputPath, json);
+  console.log(`\u2705 Remote files from "${url}" saved!`);
+}
+export {
+  fetchFilePathsFromGitHub
+};

package/dist/server/index.d.ts

@@ -0,0 +1,39 @@
+import { NextConfig } from 'next';
+export { $NextraMetadata, DynamicFolder, DynamicMeta, DynamicMetaItem, EvaluateResult, Folder, FrontMatter, Heading, Import, LoaderOptions, MDXWrapper, MathJaxOptions, MdxFile, MenuItem, Meta, MetaJsonFile, MetaRecord, NextraMetadata, Page, PageMapItem, PagefindSearchOptions, ReadingTime, SeparatorItem, TItem } from '../types.js';
+import { NextraConfig } from '../types.generated.js';
+import 'mdast';
+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 '@mdx-js/mdx';
+import 'rehype-katex';
+
+/**
+ * Nextra is a Next.js plugin that allows you to create Markdown-based content with ease.
+ *
+ * @example
+ * ```js filename="next.config.mjs"
+ * import nextra from 'nextra'
+ *
+ * // Set up Nextra with its configuration
+ * const withNextra = nextra({
+ *   // ... Add Nextra-specific options here
+ * })
+ *
+ * // Export the final Next.js config with Nextra included
+ * export default withNextra({
+ *   // ... Add regular Next.js options here
+ * })
+ * ```
+ * @see
+ * - [`NextraConfig` options](https://nextra.site/api/nextra)
+ * - [Nextra documentation](https://nextra.site)
+ * - [`NextConfig` options](https://nextjs.org/docs/pages/api-reference/config/next-config-js)
+ */
+declare const nextra: (nextraConfig: NextraConfig) => (nextConfig?: NextConfig) => NextConfig;
+
+export { NextraConfig, nextra as default };