@depup/nextra 4.6.1-depup.0

package/dist/server/tsdoc/types.d.ts

@@ -0,0 +1,64 @@
+type GeneratedType = {
+    /** Type fields. */
+    entries: TypeField[];
+};
+type Tags = Record<string, string>;
+type ReturnField = {
+    /** Function return type. */
+    type: string;
+};
+type GeneratedDefinition = {
+    /**
+     * Where type definition is located on disk.
+     */
+    filePath?: string;
+    /**
+     * Definition name.
+     */
+    name: string;
+    /**
+     * Definition description.
+     */
+    description?: string;
+    /**
+     * [TSDoc tags](https://tsdoc.org/pages/spec/tag_kinds).
+     */
+    tags?: Tags;
+};
+type GeneratedFunction = {
+    signatures: {
+        /** Function parameters. */
+        params: TypeField[];
+        /** Function return. */
+        returns: TypeField[] | ReturnField;
+    }[];
+};
+type TypeField = {
+    /** Field name. */
+    name: string;
+    /** Field type. */
+    type: string;
+    /** Field description. */
+    description?: string;
+    /** Is field optional. */
+    optional?: boolean;
+    /** Field tags. */
+    tags?: Tags;
+};
+type BaseArgs = {
+    /** TypeScript source code to be processed. */
+    code: string;
+    /**
+     * The name of the exported declaration.
+     * @default "default"
+     */
+    exportName?: string;
+    /**
+     * Whether to flatten nested objects.
+     * E.g. `{ foo: { bar: string } }` will be represented as: `{ foo.bar: string }`
+     * @default false
+     */
+    flattened?: boolean;
+};
+
+export type { BaseArgs, GeneratedDefinition, GeneratedFunction, GeneratedType, ReturnField, Tags, TypeField };

package/dist/server/tsdoc/zod-to-ts.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+declare function generateTsFromZod(schema: z.ZodType, indent?: number): string;
+
+export { generateTsFromZod };

package/dist/server/tsdoc/zod-to-ts.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+function generateTsFromZod(schema, indent = 2) {
+  const isZodObject = schema instanceof z.ZodObject;
+  if (!isZodObject) {
+    return generateTsFromZodType(schema, indent);
+  }
+  const objectFields = Object.entries(schema.shape).map(([key, _value]) => {
+    const value = _value;
+    const tsType = generateTsFromZodType(value, indent + 2);
+    const docComment = getDocComment(value, indent);
+    const isOptional = value instanceof z.ZodOptional || getDefaultValue(value) !== void 0;
+    return [
+      docComment,
+      " ".repeat(indent),
+      key,
+      isOptional ? "?" : "",
+      `: ${tsType}
+`
+    ].join("");
+  }).join("\n");
+  return ["{\n", objectFields, " ".repeat(indent - 2), "}"].join("");
+}
+function generateTsFromZodType(schema, indent) {
+  const { name } = schema.constructor;
+  const typeName = schema.meta()?.type;
+  if (typeName) return typeName;
+  if (schema instanceof z.ZodCustom) {
+    const fnName = schema.def.fn.name;
+    return fnName.startsWith("check") ? "React." + fnName.slice(5) : '"@TODO TO IMPLEMENT"';
+  }
+  switch (name) {
+    case "ZodString":
+      return "string";
+    case "ZodNumber":
+      return "number";
+    case "ZodBoolean":
+      return "boolean";
+  }
+  if (schema instanceof z.ZodPipe) {
+    return generateTsFromZodType(schema.in, indent);
+  }
+  if (schema instanceof z.ZodLiteral) {
+    return `"${[...schema.values]}"`;
+  }
+  if (schema instanceof z.ZodOptional || schema instanceof z.ZodDefault) {
+    return generateTsFromZodType(schema.def.innerType, indent);
+  }
+  if (schema instanceof z.ZodNullable) {
+    return `${generateTsFromZodType(schema.def.innerType, indent)} | null`;
+  }
+  if (schema instanceof z.ZodArray) {
+    return `${generateTsFromZodType(schema.def.element, indent)}[]`;
+  }
+  if (schema instanceof z.ZodUnion) {
+    return schema.def.options.map((opt) => {
+      const r = generateTsFromZodType(opt, indent);
+      return opt instanceof z.ZodArray ? `(${r.replace("[", ")[")}` : r;
+    }).join(" | ");
+  }
+  if (schema instanceof z.ZodObject) {
+    return generateTsFromZod(schema, indent);
+  }
+  if (schema instanceof z.ZodEnum) {
+    return schema.options.map((v) => `"${v}"`).join(" | ");
+  }
+  throw new Error(`Unknown schema type '${name}'`);
+}
+function getDefaultValue(schema) {
+  if (schema instanceof z.ZodDefault) {
+    return schema.def.defaultValue;
+  }
+  if (schema instanceof z.ZodPipe) {
+    return schema.in.def.defaultValue;
+  }
+  return;
+}
+function getDocComment(schema, indent) {
+  const meta = schema.meta() ?? {};
+  const description = (
+    // @ts-expect-error -- fixme
+    meta.description || schema.def.innerType?.description
+  );
+  const defaultValue = getDefaultValue(schema);
+  const def = meta.default ?? (defaultValue === void 0 ? void 0 : JSON.stringify(defaultValue, null, 2));
+  const comments = [];
+  if (description) {
+    comments.push(description);
+  }
+  if (def !== void 0) {
+    comments.push(`@default ${def}`);
+  }
+  if (!comments.length) {
+    return "";
+  }
+  const comment = [
+    //
+    "/**",
+    ...comments.flatMap(
+      (comment2) => comment2.split("\n").map((line) => ` * ${line}`)
+    ),
+    " */"
+  ].map((line) => `${" ".repeat(indent)}${line}`).join("\n");
+  return comment + "\n";
+}
+export {
+  generateTsFromZod
+};

package/dist/server/twoslash.d.ts

@@ -0,0 +1,6 @@
+import * as _shikijs_twoslash from '@shikijs/twoslash';
+import { RendererRichOptions } from '@shikijs/twoslash';
+
+declare function twoslashRenderer(options?: RendererRichOptions): _shikijs_twoslash.TwoslashRenderer;
+
+export { twoslashRenderer };

package/dist/server/twoslash.js

@@ -0,0 +1,60 @@
+import { rendererRich } from "@shikijs/twoslash";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+import { defaultHandlers, toHast } from "mdast-util-to-hast";
+function renderMarkdown(md) {
+  const mdast = fromMarkdown(
+    md.replaceAll(/{@link (?<link>[^}]*)}/g, "$1"),
+    // replace jsdoc links
+    { mdastExtensions: [gfmFromMarkdown()] }
+  );
+  return toHast(mdast, {
+    handlers: {
+      code: (state, node) => {
+        if (node.lang) {
+          return this.codeToHast(node.value, {
+            ...this.options,
+            transformers: [],
+            meta: {
+              __raw: node.meta ?? void 0
+            },
+            lang: node.lang
+          }).children[0];
+        }
+        return defaultHandlers.code(state, node);
+      }
+    }
+  }).children;
+}
+function renderMarkdownInline(md, context) {
+  const text = context === "tag:param" ? md.replace(/^(?<link>[\w$-]+)/, "`$1` ") : md;
+  const children = renderMarkdown.call(this, text);
+  const [firstChild] = children;
+  if (children.length === 1 && firstChild?.type === "element" && firstChild.tagName === "p")
+    return firstChild.children;
+  return children;
+}
+function twoslashRenderer(options) {
+  return rendererRich({
+    ...options,
+    renderMarkdown,
+    renderMarkdownInline,
+    hast: {
+      hoverToken: { tagName: "Popup" },
+      hoverPopup: { tagName: "PopupPanel" },
+      hoverCompose: ({ popup, token }) => [
+        popup,
+        {
+          type: "element",
+          tagName: "PopupButton",
+          properties: {},
+          children: [token]
+        }
+      ],
+      ...options?.hast
+    }
+  });
+}
+export {
+  twoslashRenderer
+};

package/dist/server/utils.d.ts

@@ -0,0 +1,12 @@
+import { ArrayExpression, ObjectExpression, Expression, ExportNamedDeclaration } from 'estree';
+
+declare const logger: {
+    info: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+};
+declare function pageTitleFromFilename(fileName: string): string;
+declare function createAstExportConst(name: string, value: ArrayExpression | ObjectExpression | Expression): ExportNamedDeclaration;
+declare function createAstObject(obj: Record<string, string | number | boolean | null | Expression>): ObjectExpression;
+
+export { createAstExportConst, createAstObject, logger, pageTitleFromFilename };

package/dist/server/utils.js

@@ -0,0 +1,45 @@
+import title from "title";
+import { DEFAULT_PROPERTY_PROPS } from "./constants.js";
+const logger = {
+  info: console.log.bind(null, "-", "\x1B[36minfo\x1B[0m", "[nextra]"),
+  warn: console.log.bind(null, "-", "\x1B[33mwarn\x1B[0m", "[nextra]"),
+  error: console.log.bind(null, "-", "\x1B[31merror\x1B[0m", "[nextra]")
+};
+function pageTitleFromFilename(fileName) {
+  return title(fileName.replaceAll(/[-_]/g, " "), {
+    special: ["SSR", "CORS", "ESLint"]
+  });
+}
+function createAstExportConst(name, value) {
+  return {
+    type: "ExportNamedDeclaration",
+    specifiers: [],
+    declaration: {
+      type: "VariableDeclaration",
+      kind: "const",
+      declarations: [
+        {
+          type: "VariableDeclarator",
+          id: { type: "Identifier", name },
+          init: value
+        }
+      ]
+    }
+  };
+}
+function createAstObject(obj) {
+  return {
+    type: "ObjectExpression",
+    properties: Object.entries(obj).map(([key, value]) => ({
+      ...DEFAULT_PROPERTY_PROPS,
+      key: { type: "Identifier", name: key },
+      value: value && typeof value === "object" ? value : { type: "Literal", value }
+    }))
+  };
+}
+export {
+  createAstExportConst,
+  createAstObject,
+  logger,
+  pageTitleFromFilename
+};

package/dist/types.d.ts

@@ -0,0 +1,128 @@
+import { Heading as Heading$1 } from 'mdast';
+import { Metadata } from 'next';
+import { ReactElement, FC, ReactNode } from 'react';
+import { z } from 'zod';
+import { NextraConfigSchema, MathJaxOptionsSchema, metaSchema, separatorItemSchema, menuSchema } from './server/schemas.js';
+export { NextraConfig } from './types.generated.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';
+
+type NextraConfigFromZod = z.infer<typeof NextraConfigSchema>;
+interface LoaderOptions extends NextraConfigFromZod {
+    isPageImport?: boolean;
+    locales: string[];
+    contentDir?: string;
+    shouldAddLocaleToLinks?: boolean;
+}
+type TPageItem = {
+    name: string;
+    route: string;
+    __pagePath: string;
+};
+type TMetaItem = {
+    __metaPath: string;
+};
+interface TFolder<T = TItem> {
+    name: string;
+    route: string;
+    children: T[];
+}
+type TItem = TPageItem | TMetaItem | TFolder;
+interface Folder<FileType = PageMapItem> {
+    name: string;
+    route: string;
+    children: FileType[];
+}
+type Import = {
+    importName: string;
+    filePath: string;
+};
+type MetaJsonFile = {
+    data: {
+        [fileName: string]: Meta;
+    };
+};
+type DynamicFolder = {
+    items: DynamicMeta;
+    title?: string;
+};
+type DynamicMetaItem = Meta | DynamicFolder;
+type DynamicMeta = Record<string, DynamicMetaItem>;
+type FrontMatter = Record<string, any>;
+type Meta = string | Record<string, any>;
+type MdxFile<FrontMatterType = FrontMatter> = {
+    name: string;
+    route: string;
+    frontMatter?: FrontMatterType;
+};
+type PageMapItem = Folder | MdxFile | MetaJsonFile;
+type Page = (MdxFile | Folder<Page>) & {
+    meta?: Exclude<Meta, string>;
+};
+type Heading = {
+    depth: Exclude<Heading$1['depth'], 1>;
+    value: string | ReactElement;
+    id: string;
+};
+type $NextraMetadata = Omit<Metadata, 'title'> & {
+    title: string;
+    filePath: string;
+    timestamp?: number;
+    readingTime?: ReadingTime;
+};
+type ReadingTime = {
+    text: string;
+    minutes: number;
+    time: number;
+    words: number;
+};
+type MathJaxOptions = z.infer<typeof MathJaxOptionsSchema>;
+type MDXWrapper = FC<{
+    children: ReactNode;
+    bottomContent?: ReactNode;
+} & Omit<EvaluateResult, 'default'>>;
+type MetaRecord = Record<string, z.infer<typeof metaSchema>>;
+type SeparatorItem = z.infer<typeof separatorItemSchema>;
+type MenuItem = z.infer<typeof menuSchema>;
+/**
+ * Options that can be passed to `pagefind.search()`.
+ * @remarks Copied from https://github.com/CloudCannon/pagefind/blob/2a0aa90cfb78bb8551645ac9127a1cd49cf54add/pagefind_web_js/types/index.d.ts#L72-L82
+ */
+type PagefindSearchOptions = {
+    /**
+     * If set, this call will load all assets but return before searching. Prefer using `pagefind.preload()` instead.
+     */
+    preload?: boolean;
+    /**
+     * Add more verbose console logging for this search query.
+     */
+    verbose?: boolean;
+    /**
+     * The set of filters to execute with this search. Input type is extremely flexible, see the filtering docs for details.
+     */
+    filters?: object;
+    /**
+     * The set of sorts to use for this search, instead of relevancy.
+     */
+    sort?: object;
+};
+type NextraMetadata = Metadata & {
+    asIndexPage?: boolean;
+    sidebarTitle?: string;
+};
+type EvaluateResult = {
+    /** The MDX component to render. */
+    default: FC<any>;
+    /** Table of contents list. */
+    toc: Heading[];
+    /** Page's front matter or `metadata` object including `title`, `description`, etc. */
+    metadata: $NextraMetadata;
+    /** Raw MDX source code */
+    sourceCode: string;
+};
+
+export type { $NextraMetadata, DynamicFolder, DynamicMeta, DynamicMetaItem, EvaluateResult, Folder, FrontMatter, Heading, Import, LoaderOptions, MDXWrapper, MathJaxOptions, MdxFile, MenuItem, Meta, MetaJsonFile, MetaRecord, NextraMetadata, Page, PageMapItem, PagefindSearchOptions, ReadingTime, SeparatorItem, TItem };

package/dist/types.generated.d.ts

@@ -0,0 +1,203 @@
+import * as rehype_pretty_code from 'rehype-pretty-code';
+import * as _mdx_js_mdx from '@mdx-js/mdx';
+import * as rehype_katex from 'rehype-katex';
+import * as better_react_mathjax from 'better-react-mathjax';
+
+interface NextraConfig {
+    /**
+     * Enable the copy button for all code blocks by default, without needing to set `copy=true` attribute in the code block metadata.
+     * > [!TIP]
+     * >
+     * > You could still disable the button for specific blocks using `copy=false` attribute.
+     */
+    defaultShowCopyCode?: boolean;
+    /**
+     * Option to enable search functionality. When enabled, it sets the `data-pagefind-body` attribute on the `<main>` element.
+     * > [!TIP]
+     * >
+     * > When set to `codeblocks: false`, it adds the `data-pagefind-ignore="all"` attribute to all code blocks (`<pre>` elements).
+     * @default {
+     *   "codeblocks": false
+     * }
+     */
+    search?: boolean | {
+        /**
+         * Whether to index code blocks.
+         */
+        codeblocks: boolean;
+    };
+    /**
+     * Option to automatically optimizing your static image imports with the Markdown syntax.
+     * > [!TIP]
+     * >
+     * > Example: `![Hello](/demo.png)`.
+     * @default true
+     */
+    staticImage?: boolean;
+    /**
+     * Adds estimated reading time of `.md` and `.mdx` files using [readingTime](https://npmjs.com/package/reading-time) package.
+     * > [!TIP]
+     * >
+     * > The reading time is added to the front matter under the `readingTime` key.
+     */
+    readingTime?: boolean;
+    /**
+     * Enable LaTeX either with [KaTeX](https://katex.org) to pre-render LaTeX expressions directly in MDX or [MathJax](https://mathjax.org) to dynamically render math in the browser.
+     */
+    latex?: boolean | {
+        renderer: "mathjax";
+        options?: {
+            /**
+             * URL for MathJax.
+             * @default "https://cdnjs.cloudflare.com"
+             */
+            src?: string;
+            /**
+             * MathJax config. See [configuring MathJax](https://docs.mathjax.org/en/latest/options/index.html).
+             */
+            config?: better_react_mathjax.MathJax3Config;
+        };
+    } | {
+        renderer: "katex";
+        /**
+         * KaTeX options. See https://katex.org/docs/options.html.
+         */
+        options: rehype_katex.Options;
+    };
+    /**
+     * Enable or disable syntax highlighting.
+     * @default true
+     */
+    codeHighlight?: boolean;
+    /**
+     * Options specific to MDX compiling.
+     * @remarks `MdxOptions`
+     * @default {
+     *   "format": "detect",
+     *   "rehypePrettyCodeOptions": {}
+     * }
+     */
+    mdxOptions?: {
+        /**
+         * List of rehype plugins.
+         */
+        rehypePlugins?: _mdx_js_mdx.ProcessorOptions["rehypePlugins"];
+        /**
+         * List of remark plugins.
+         */
+        remarkPlugins?: _mdx_js_mdx.ProcessorOptions["remarkPlugins"];
+        /**
+         * List of recma plugins. This is a new ecosystem, currently in beta, to transform esast trees (JavaScript).
+         */
+        recmaPlugins?: _mdx_js_mdx.ProcessorOptions["recmaPlugins"];
+        /**
+         * Format of the file.
+         * - `'md'` means treat as markdown
+         * - `'mdx'` means treat as MDX
+         * - `'detect'` means try to detect the format based on file path.
+         * @default "detect"
+         */
+        format?: "detect" | "mdx" | "md";
+        /**
+         * Configuration options for [Rehype Pretty Code](https://github.com/rehype-pretty/rehype-pretty-code).
+         * @remarks `RehypePrettyCodeOptions`
+         * @default {}
+         */
+        rehypePrettyCodeOptions?: rehype_pretty_code.Options;
+    };
+    /**
+     * Allows you to whitelist HTML elements to be replaced with components defined in the `mdx-components.js` file.
+     * > [!TIP]
+     * >
+     * > By default, Nextra only replaces `<details>` and `<summary>` elements.
+     */
+    whiteListTagsStyling?: string[];
+    /**
+     * Option to serve your `.md` and `.mdx` files from the `content` directory at a custom path instead of the root (`/`).
+     * @default "/"
+     */
+    contentDirBasePath?: string;
+    /**
+     * Prefixes locale to all links in the page map information. Useful for i18n when you don't want to use Nextra's `middleware` function.
+     * @default false
+     */
+    unstable_shouldAddLocaleToLinks?: boolean;
+}
+interface HeadProps {
+    /**
+     * @default {
+     *   "hue": {
+     *     "dark": 204,
+     *     "light": 212
+     *   },
+     *   "saturation": {
+     *     "dark": 100,
+     *     "light": 100
+     *   },
+     *   "lightness": {
+     *     "dark": 55,
+     *     "light": 45
+     *   }
+     * }
+     */
+    color?: {
+        /**
+         * The hue of the primary theme color.<br/>Range: `0 - 360`
+         * @default {
+         *   "dark": 204,
+         *   "light": 212
+         * }
+         */
+        hue?: number | {
+            dark: number;
+            light: number;
+        };
+        /**
+         * The saturation of the primary theme color.<br/>Range: `0 - 100`
+         * @default 100
+         */
+        saturation?: number | {
+            dark: number;
+            light: number;
+        };
+        /**
+         * The lightness of the primary theme color.<br/>Range: `0 - 100`
+         * @default {
+         *   "dark": 55,
+         *   "light": 45
+         * }
+         */
+        lightness?: number | {
+            dark: number;
+            light: number;
+        };
+    };
+    /**
+     * The glyph to use as the favicon.
+     */
+    faviconGlyph?: string;
+    /**
+     * @default {
+     *   "dark": "17,17,17",
+     *   "light": "250,250,250"
+     * }
+     */
+    backgroundColor?: {
+        /**
+         * Background color for dark theme.<br/>Format: `"rgb(RRR,GGG,BBB)" | "#RRGGBB"`
+         * @default "rgb(17,17,17)"
+         */
+        dark?: string;
+        /**
+         * Background color for light theme.<br/>Format: `"rgb(RRR,GGG,BBB)" | "#RRGGBB"`
+         * @default "rgb(250,250,250)"
+         */
+        light?: string;
+    };
+    /**
+     * Content of `<head>`.
+     */
+    children?: React.ReactNode;
+}
+
+export type { HeadProps, NextraConfig };

package/loader.cjs

@@ -0,0 +1,24 @@
+/* eslint-env node */
+// https://github.com/mdx-js/mdx/blob/061cdbf440bd8193867fcef3f5a131c08e4fe469/packages/loader/index.cjs
+
+/**
+ * Webpack loader
+ *
+ * @todo once webpack supports ESM loaders, remove this wrapper.
+ *
+ * @this {import('webpack').LoaderContext}
+ * @param {string} code
+ * @return {Promise<void>}
+ */
+module.exports = async function loader(code) {
+  const callback = this.async()
+
+  try {
+    // Note that `import()` caches, so this should be fast enough.
+    const { loader } = await import('./dist/server/loader.js')
+    const result = await loader.call(this, code)
+    callback(null, result)
+  } catch (error) {
+    callback(error)
+  }
+}