@depup/nextra 4.6.1-depup.0

package/dist/client/mdx-components/table.d.ts

@@ -0,0 +1,57 @@
+import { FC, HTMLAttributes } from 'react';
+
+/**
+ * A collection of built-in components designed to create styled, non-markdown
+ * (i.e., literal) HTML tables.
+ *
+ * @example
+ * <Table className="mt-6">
+ *   <thead>
+ *     <Table.Tr>
+ *       <Table.Th>Country</Table.Th>
+ *       <Table.Th>Flag</Table.Th>
+ *     </Table.Tr>
+ *   </thead>
+ *   <tbody>
+ *     <Table.Tr>
+ *       <Table.Td>France</Table.Td>
+ *       <Table.Td>🇫🇷</Table.Td>
+ *     </Table.Tr>
+ *     <Table.Tr>
+ *       <Table.Td>Ukraine</Table.Td>
+ *       <Table.Td>🇺🇦</Table.Td>
+ *     </Table.Tr>
+ *   </tbody>
+ * </Table>
+ *
+ * @usage
+ * ```mdx
+ * import { Table } from 'nextra/components'
+ *
+ * <Table>
+ *   <thead>
+ *     <Table.Tr>
+ *       <Table.Th>Country</Table.Th>
+ *       <Table.Th>Flag</Table.Th>
+ *     </Table.Tr>
+ *   </thead>
+ *   <tbody>
+ *     <Table.Tr>
+ *       <Table.Td>France</Table.Td>
+ *       <Table.Td>🇫🇷</Table.Td>
+ *     </Table.Tr>
+ *     <Table.Tr>
+ *       <Table.Td>Ukraine</Table.Td>
+ *       <Table.Td>🇺🇦</Table.Td>
+ *     </Table.Tr>
+ *   </tbody>
+ * </Table>
+ * ```
+ */
+declare const Table: FC<HTMLAttributes<HTMLTableElement>> & {
+    Th: FC<HTMLAttributes<HTMLTableCellElement>>;
+    Tr: FC<HTMLAttributes<HTMLTableRowElement>>;
+    Td: FC<HTMLAttributes<HTMLTableCellElement>>;
+};
+
+export { Table };

package/dist/client/mdx-components/table.js

@@ -0,0 +1,95 @@
+import { jsx } from "react/jsx-runtime";
+import { c as _c } from "react-compiler-runtime";
+import cn from "clsx";
+const Table_ = (props) => {
+  const $ = _c(5);
+  let t0;
+  if ($[0] !== props.className) {
+    t0 = cn("x:block x:overflow-x-auto", props.className);
+    $[0] = props.className;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  let t1;
+  if ($[2] !== props || $[3] !== t0) {
+    t1 = /* @__PURE__ */ jsx("table", { ...props, className: t0 });
+    $[2] = props;
+    $[3] = t0;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  return t1;
+};
+const Th = (props) => {
+  const $ = _c(5);
+  let t0;
+  if ($[0] !== props.className) {
+    t0 = cn("x:m-0 x:border x:border-gray-300 x:px-4 x:py-2 x:font-semibold x:dark:border-gray-600", props.className);
+    $[0] = props.className;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  let t1;
+  if ($[2] !== props || $[3] !== t0) {
+    t1 = /* @__PURE__ */ jsx("th", { ...props, className: t0 });
+    $[2] = props;
+    $[3] = t0;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  return t1;
+};
+const Tr = (props) => {
+  const $ = _c(5);
+  let t0;
+  if ($[0] !== props.className) {
+    t0 = cn("x:m-0 x:border-t x:border-gray-300 x:p-0 x:dark:border-gray-600", "x:even:bg-gray-100 x:even:dark:bg-gray-600/20", props.className);
+    $[0] = props.className;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  let t1;
+  if ($[2] !== props || $[3] !== t0) {
+    t1 = /* @__PURE__ */ jsx("tr", { ...props, className: t0 });
+    $[2] = props;
+    $[3] = t0;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  return t1;
+};
+const Td = (props) => {
+  const $ = _c(5);
+  let t0;
+  if ($[0] !== props.className) {
+    t0 = cn("x:m-0 x:border x:border-gray-300 x:px-4 x:py-2 x:dark:border-gray-600", props.className);
+    $[0] = props.className;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  let t1;
+  if ($[2] !== props || $[3] !== t0) {
+    t1 = /* @__PURE__ */ jsx("td", { ...props, className: t0 });
+    $[2] = props;
+    $[3] = t0;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  return t1;
+};
+const Table = Object.assign(Table_, {
+  Th,
+  Tr,
+  Td
+});
+export {
+  Table
+};

package/dist/client/mdx-components.d.ts

@@ -0,0 +1,89 @@
+import * as url from 'url';
+import * as next_link_js from 'next/link.js';
+import * as react from 'react';
+import { FC, JSX, ComponentPropsWithoutRef } from 'react';
+import * as next_image_js from 'next/image.js';
+import { MDXWrapper } from '../types.js';
+import { ImageZoom } from './components/image-zoom.js';
+import { Anchor } from './mdx-components/anchor.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';
+import 'next/image';
+import 'next/link';
+
+/**
+ * A valid JSX string component.
+ */
+type StringComponent = Exclude<keyof JSX.IntrinsicElements, 'img' | 'a'>;
+/**
+ * Any allowed JSX component.
+ */
+type Component<Props> = FC<Props> | StringComponent;
+interface NestedMDXComponents {
+    [key: string]: NestedMDXComponents | Component<any>;
+}
+/**
+ * MDX components may be passed as the `components`.
+ *
+ * The key is the name of the element to override. The value is the component to render instead.
+ */
+type MDXComponents = NestedMDXComponents & {
+    [Key in StringComponent]?: FC<ComponentPropsWithoutRef<Key>>;
+} & {
+    /**
+     * If a wrapper component is defined, the MDX content will be wrapped inside it.
+     */
+    wrapper?: MDXWrapper;
+} & DefaultMdxComponents;
+type DefaultMdxComponents = {
+    /**
+     * Nextra's `<ImageZoom />` component with zoom functionality.
+     * Uses `<NextImage>` for static images and falls back to a standard `<img>` element for others.
+     */
+    img?: typeof ImageZoom;
+    /**
+     * Nextra's `<Anchor />` component for rendering links.
+     * Uses `<NextLink>` for internal navigation and falls back to a regular `<a>` element for
+     * external links.
+     */
+    a?: typeof Anchor;
+};
+declare const DEFAULT_COMPONENTS: {
+    img: FC<next_image_js.ImageProps>;
+    a: FC<Omit<Omit<Omit<react.AnchorHTMLAttributes<HTMLAnchorElement>, keyof next_link_js.LinkProps<any>> & next_link_js.LinkProps<any> & {
+        children?: React.ReactNode | undefined;
+    } & react.RefAttributes<HTMLAnchorElement>, "ref">, "href"> & {
+        href?: (string | url.UrlObject) | undefined;
+    }>;
+};
+/**
+ * Get current MDX components.
+ * @returns The current set of MDX components.
+ */
+type UseMDXComponents<
+/**
+ * Default MDX components
+ */
+DefaultMDXComponents extends MDXComponents> = {
+    <components extends MDXComponents>(
+    /**
+     * An object where:
+     * - The key is the name of the HTML element to override.
+     * - The value is the component to render instead.
+     * @remarks `MDXComponents`
+     */
+    components: components): DefaultMDXComponents & components;
+    (): DefaultMDXComponents;
+};
+declare const useMDXComponents: UseMDXComponents<typeof DEFAULT_COMPONENTS>;
+
+export { type MDXComponents, type NestedMDXComponents, type UseMDXComponents, useMDXComponents };

package/dist/client/mdx-components.js

@@ -0,0 +1,15 @@
+import { ImageZoom } from "./components/image-zoom.js";
+import { Anchor } from "./mdx-components/anchor.js";
+const DEFAULT_COMPONENTS = {
+  img: ImageZoom,
+  a: Anchor
+};
+const useMDXComponents = (components) => {
+  return {
+    ...DEFAULT_COMPONENTS,
+    ...components
+  };
+};
+export {
+  useMDXComponents
+};

package/dist/client/mdx-remote.d.ts

@@ -0,0 +1,62 @@
+import { FC } from 'react';
+import { Scope } from './evaluate.js';
+import { MDXComponents } from './mdx-components.js';
+import '../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';
+import 'url';
+import 'next/link.js';
+import 'next/image.js';
+import './components/image-zoom.js';
+import 'next/image';
+import './mdx-components/anchor.js';
+import 'next/link';
+
+type MDXRemoteProps = Readonly<{
+    /**
+     * An object mapping names to React components.
+     * The key used will be the name accessible to MDX.
+     *
+     * @example
+     * `{ ComponentName: Component }` will be accessible in the MDX as `<ComponentName>`.
+     */
+    components?: MDXComponents;
+    /**
+     * Pass-through variables for use in the MDX content.
+     * These variables will be available in the MDX scope.
+     */
+    scope?: Scope;
+    /**
+     * Raw JavaScript compiled MDX source code, a result of Nextra's
+     * [`compileMdx` function](https://nextra.site/api/compilemdx).
+     */
+    compiledSource: string;
+}>;
+/**
+ * A React component that renders compiled MDX content.
+ *
+ * @returns A rendered React element that renders the MDX content.
+ * @example
+ * ```mdx filename="example.mdx"
+ * import { compileMdx } from 'nextra/compile'
+ * import { MDXRemote } from 'nextra/mdx-remote'
+ *
+ * <MDXRemote
+ *   compiledSource={await compileMdx('# Hello {myVariable} <MyComponent />')}
+ *   components={{ MyComponent: () => <div>My Component</div> }}
+ *   scope={{ myVariable: 'World' }}
+ * />
+ * ```
+ */
+declare const MDXRemote: FC<MDXRemoteProps>;
+
+export { MDXRemote, type MDXRemoteProps };

package/dist/client/mdx-remote.js

@@ -0,0 +1,36 @@
+import { jsx } from "react/jsx-runtime";
+import { c as _c } from "react-compiler-runtime";
+import { useMDXComponents } from "next-mdx-import-source-file";
+import { evaluate } from "./evaluate.js";
+const MDXRemote = (t0) => {
+  const $ = _c(6);
+  const {
+    scope,
+    components,
+    compiledSource
+  } = t0;
+  const t1 = useMDXComponents(components);
+  let t2;
+  if ($[0] !== compiledSource || $[1] !== scope || $[2] !== t1) {
+    t2 = evaluate(compiledSource, t1, scope);
+    $[0] = compiledSource;
+    $[1] = scope;
+    $[2] = t1;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const MDXContent = t2.default;
+  let t3;
+  if ($[4] !== MDXContent) {
+    t3 = /* @__PURE__ */ jsx(MDXContent, {});
+    $[4] = MDXContent;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  return t3;
+};
+export {
+  MDXRemote
+};

package/dist/client/normalize-pages.d.ts

@@ -0,0 +1,84 @@
+import { ReactNode } from 'react';
+import { z } from 'zod';
+import { itemSchema, menuSchema } from '../server/schemas.js';
+import { MdxFile, Folder, FrontMatter, PageMapItem } from '../types.js';
+import './lib/index.js';
+import 'rehype-katex/lib/index.js';
+import 'better-react-mathjax';
+import 'rehype-pretty-code';
+import 'mdast';
+import 'next';
+import '../types.generated.js';
+import '@mdx-js/mdx';
+import 'rehype-katex';
+
+type PageTheme = NonNullable<z.infer<typeof itemSchema>['theme']>;
+type Display = z.infer<typeof itemSchema>['display'];
+type IMenuItem = z.infer<typeof menuSchema>;
+type FolderWithoutChildren = Omit<Folder, 'children'>;
+type Item = (MdxFile | FolderWithoutChildren) & {
+    title: ReactNode;
+    type: string;
+    children: Item[];
+    display?: Display;
+    theme?: PageTheme;
+    frontMatter: FrontMatter;
+    isUnderCurrentDocsTree?: boolean;
+};
+type PageItem = (MdxFile | FolderWithoutChildren) & {
+    title: ReactNode;
+    type: string;
+    href?: string;
+    children?: PageItem[];
+    firstChildRoute?: string;
+    display?: Display;
+    isUnderCurrentDocsTree?: boolean;
+};
+type MenuItem = (MdxFile | FolderWithoutChildren) & IMenuItem & {
+    children?: PageItem[];
+};
+type DocsItem = (MdxFile | FolderWithoutChildren) & {
+    title: ReactNode;
+    type: string;
+    children: DocsItem[];
+    firstChildRoute?: string;
+    isUnderCurrentDocsTree?: boolean;
+};
+type NormalizedResult = {
+    /** Active type for current page, used to determine layout in theme. */
+    activeType?: 'doc' | 'page' | 'menu';
+    /**
+     * Active index for current page, used for pagination in combination with `flatDocsDirectories`
+     * items.
+     */
+    activeIndex: number;
+    activeThemeContext: PageTheme;
+    /**
+     * Parsed [front matter](https://jekyllrb.com/docs/front-matter) or exported
+     * [Metadata](https://nextjs.org/docs/app/building-your-application/optimizing/metadata) from page.
+     */
+    activeMetadata?: FrontMatter;
+    /** Active path for current page, used for breadcrumb navigation. */
+    activePath: Item[];
+    /** All directories in the tree structure. */
+    directories: Item[];
+    /** Directories with `type: 'doc'` in `_meta` file. */
+    docsDirectories: DocsItem[];
+    /** Flattened directories with `type: 'doc'` in `_meta` file. */
+    flatDocsDirectories: DocsItem[];
+    /** Navbar items, items which have `type: 'page'` in `_meta` file. */
+    topLevelNavbarItems: (PageItem | MenuItem)[];
+};
+declare function normalizePages({ list, route, 
+/** @default '' */
+docsRoot, 
+/** @default DEFAULT_PAGE_THEME */
+pageThemeContext }: {
+    list: PageMapItem[];
+    route: string;
+    docsRoot?: string;
+    underCurrentDocsRoot?: boolean;
+    pageThemeContext?: PageTheme;
+}): NormalizedResult;
+
+export { type Item, type MenuItem, type PageItem, normalizePages };

package/dist/client/normalize-pages.js

@@ -0,0 +1,232 @@
+"use no memo";
+const DEFAULT_PAGE_THEME = {
+  breadcrumb: true,
+  collapsed: void 0,
+  copyPage: true,
+  footer: true,
+  layout: "default",
+  navbar: true,
+  pagination: true,
+  sidebar: true,
+  timestamp: true,
+  toc: true,
+  typesetting: "default"
+};
+function extendMeta(_meta = {}, fallback, metadata = {}) {
+  const theme = {
+    ...fallback.theme,
+    ..._meta.theme,
+    ...metadata.theme
+  };
+  return {
+    ...fallback,
+    ..._meta,
+    display: metadata.display || _meta.display || fallback.display,
+    theme
+  };
+}
+function findFirstRoute(items) {
+  for (const item of items) {
+    if (item.route) return item.route;
+    if (item.children) {
+      const route = findFirstRoute(item.children);
+      if (route) return route;
+    }
+  }
+}
+function normalizePages({
+  list,
+  route,
+  /** @default '' */
+  docsRoot = "",
+  /** @default DEFAULT_PAGE_THEME */
+  pageThemeContext = DEFAULT_PAGE_THEME
+}) {
+  const underCurrentDocsRoot = route.startsWith(docsRoot);
+  const directories = [];
+  const docsDirectories = [];
+  const flatDocsDirectories = [];
+  const topLevelNavbarItems = [];
+  const firstItem = list[0];
+  const meta = "data" in firstItem ? firstItem.data : {};
+  const items = "data" in firstItem ? list.slice(1) : list;
+  const fallbackMeta = meta["*"] || {};
+  let activeType = fallbackMeta.type;
+  let activeIndex = 0;
+  let activeThemeContext = {
+    ...pageThemeContext,
+    ...fallbackMeta.theme
+  };
+  let activePath = [];
+  for (const currentItem of items) {
+    const extendedMeta = extendMeta(meta[currentItem.name], fallbackMeta, currentItem.frontMatter);
+    const {
+      display,
+      type = "doc"
+    } = extendedMeta;
+    const extendedPageThemeContext = {
+      ...pageThemeContext,
+      ...extendedMeta.theme
+    };
+    const normalizedChildren = "children" in currentItem && normalizePages({
+      list: currentItem.children,
+      route,
+      docsRoot: type === "page" || type === "menu" ? currentItem.route : docsRoot,
+      underCurrentDocsRoot,
+      pageThemeContext: extendedPageThemeContext
+    });
+    const getItem = () => ({
+      ...currentItem,
+      type,
+      ..."title" in currentItem && {
+        title: currentItem.title
+      },
+      ...display && {
+        display
+      },
+      ...normalizedChildren && {
+        children: []
+      }
+    });
+    const item = getItem();
+    const docsItem = getItem();
+    if ("children" in docsItem) {
+      const {
+        collapsed
+      } = extendedMeta.theme;
+      if (typeof collapsed === "boolean") {
+        docsItem.theme = {
+          collapsed
+        };
+      }
+    }
+    const pageItem = getItem();
+    docsItem.isUnderCurrentDocsTree = underCurrentDocsRoot;
+    if (type === "separator") {
+      item.isUnderCurrentDocsTree = underCurrentDocsRoot;
+    }
+    if (currentItem.route === route) {
+      activePath = [item];
+      activeType = type;
+      activeThemeContext = {
+        ...activeThemeContext,
+        ...extendedPageThemeContext
+      };
+      switch (type) {
+        case "page":
+        case "menu":
+          activeIndex = topLevelNavbarItems.length;
+          break;
+        case "doc":
+          activeIndex = flatDocsDirectories.length;
+      }
+    }
+    const isHidden = display === "hidden";
+    if (normalizedChildren) {
+      if (
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- fixme
+        normalizedChildren.activeIndex !== void 0 && normalizedChildren.activeType !== void 0
+      ) {
+        activeThemeContext = normalizedChildren.activeThemeContext;
+        activeType = normalizedChildren.activeType;
+        if (isHidden) {
+          continue;
+        }
+        activePath = [
+          item,
+          // Do not include folder which shows only his children
+          ...normalizedChildren.activePath.filter((item2) => item2.display !== "children")
+        ];
+        switch (activeType) {
+          case "page":
+          case "menu":
+            activeIndex = topLevelNavbarItems.length + normalizedChildren.activeIndex;
+            break;
+          case "doc":
+            activeIndex = flatDocsDirectories.length + normalizedChildren.activeIndex;
+            break;
+        }
+        if ("frontMatter" in currentItem && type === "doc") {
+          activeIndex++;
+        }
+      }
+      switch (type) {
+        case "page":
+        case "menu":
+          pageItem.children.push(...normalizedChildren.directories);
+          docsDirectories.push(...normalizedChildren.docsDirectories);
+          if (normalizedChildren.flatDocsDirectories.length) {
+            const route2 = findFirstRoute(normalizedChildren.flatDocsDirectories);
+            if (route2) pageItem.firstChildRoute = route2;
+            topLevelNavbarItems.push(pageItem);
+          } else if ("frontMatter" in pageItem) {
+            topLevelNavbarItems.push(pageItem);
+          }
+          break;
+        case "doc":
+          docsItem.children.push(...normalizedChildren.docsDirectories);
+          if ("frontMatter" in item && display !== "children") {
+            flatDocsDirectories.push(docsItem);
+          }
+      }
+      flatDocsDirectories.push(...normalizedChildren.flatDocsDirectories);
+      item.children.push(...normalizedChildren.directories);
+    } else {
+      if (isHidden) {
+        continue;
+      }
+      switch (type) {
+        case "page":
+        case "menu":
+          topLevelNavbarItems.push(pageItem);
+          break;
+        case "doc": {
+          const withHrefProp = "href" in item;
+          if (!withHrefProp) {
+            flatDocsDirectories.push(docsItem);
+          }
+        }
+      }
+    }
+    if (isHidden) {
+      continue;
+    }
+    if (type === "doc" && display === "children") {
+      if (docsItem.children) {
+        directories.push(...docsItem.children);
+        docsDirectories.push(...docsItem.children);
+      }
+    } else {
+      directories.push(item);
+    }
+    switch (type) {
+      case "page":
+      case "menu":
+        docsDirectories.push(pageItem);
+        break;
+      case "doc":
+        if (display !== "children") {
+          docsDirectories.push(docsItem);
+        }
+        break;
+      case "separator":
+        docsDirectories.push(item);
+    }
+  }
+  const activeMetadata = activePath.at(-1)?.frontMatter;
+  const result = {
+    activeType,
+    activeIndex,
+    activeThemeContext,
+    activeMetadata,
+    activePath,
+    directories,
+    docsDirectories: docsDirectories.filter((item) => item.isUnderCurrentDocsTree),
+    flatDocsDirectories,
+    topLevelNavbarItems
+  };
+  return result;
+}
+export {
+  normalizePages
+};

package/dist/client/package.json

@@ -0,0 +1 @@
+{"sideEffects":false}