@depup/nextra 4.6.1-depup.0

package/dist/client/components/index.js

@@ -0,0 +1,42 @@
+import { Mermaid } from "@theguild/remark-mermaid/mermaid";
+import { MathJax, MathJaxContext } from "better-react-mathjax";
+import { Banner } from "./banner/index.js";
+import { FileTree } from "./file-tree/index.js";
+import { SkipNavContent, SkipNavLink } from "./skip-nav/index.js";
+import { Popup } from "./popup/index.js";
+import { Tabs } from "./tabs/index.js";
+import { Bleed } from "./bleed.js";
+import { Button } from "./button.js";
+import { Callout } from "./callout.js";
+import { Cards } from "./cards.js";
+import { Collapse } from "./collapse.js";
+import { Head } from "./head.js";
+import { ImageZoom } from "./image-zoom.js";
+import { Playground } from "./playground.js";
+import { Search } from "./search.js";
+import { Select } from "./select.js";
+import { Steps } from "./steps.js";
+export * from "../hocs/index.js";
+export * from "../mdx-components/index.js";
+export {
+  Banner,
+  Bleed,
+  Button,
+  Callout,
+  Cards,
+  Collapse,
+  FileTree,
+  Head,
+  ImageZoom,
+  MathJax,
+  MathJaxContext,
+  Mermaid,
+  Playground,
+  Popup,
+  Search,
+  Select,
+  SkipNavContent,
+  SkipNavLink,
+  Steps,
+  Tabs
+};

package/dist/client/components/playground.d.ts

@@ -0,0 +1,90 @@
+import { FC, ReactElement } from 'react';
+import { MDXRemoteProps } from '../mdx-remote.js';
+import '../evaluate.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 '../mdx-components.js';
+import 'url';
+import 'next/link.js';
+import 'next/image.js';
+import './image-zoom.js';
+import 'next/image';
+import '../mdx-components/anchor.js';
+import 'next/link';
+
+type PlaygroundProps = {
+    /**
+     * String with source MDX.
+     * @example '# hello world <br /> nice to see you'
+     */
+    source: string;
+    /**
+     * Fallback component for loading.
+     * @default null
+     */
+    fallback?: ReactElement | null;
+} & Pick<MDXRemoteProps, 'components' | 'scope'>;
+/**
+ * A built-in component lets you write Nextra-compatible MDX that renders only on the client.
+ * @example
+ * <PlaygroundDemo />
+ *
+ * @usage
+ * ```mdx filename="Basic Usage"
+ * import { Playground } from 'nextra/components'
+ *
+ * # Playground
+ *
+ * Below is a playground component. It mixes into the rest of your MDX perfectly.
+ *
+ * <Playground
+ *   source="## Hello world"
+ *   components={{ h2: props => <h2 {...props} className="myClass" /> }}
+ * />
+ * ```
+ *
+ * You may also specify a fallback component like so:
+ *
+ * ```mdx filename="Usage with Fallback"
+ * import { Playground } from 'nextra/components'
+ *
+ * <Playground
+ *   source="## Hello world"
+ *   components={{ h2: props => <h2 {...props} className="myClass" /> }}
+ *   fallback={<div>Loading playground...</div>}
+ * />
+ * ```
+ *
+ * ### Avoiding unstyled outputs
+ *
+ * To prevent unstyled elements, import `useMDXComponents` from your
+ * `mdx-components` file. Call this function and pass the returned components to
+ * the `components` prop. You can also include your custom components as the first
+ * argument:
+ *
+ * ```mdx {1,6-8}
+ * import { Playground } from 'nextra/components'
+ * import { useMDXComponents } from '../path/to/my/mdx-components'
+ *
+ * <Playground
+ *   source="## Hello world"
+ *   components={useMDXComponents({
+ *     h2: props => <h2 {...props} className="myClass" />
+ *   })}
+ *   fallback={<div>Loading playground...</div>}
+ * />
+ * ```
+ */
+declare const Playground: FC<PlaygroundProps>;
+
+export { Playground };

package/dist/client/components/playground.js

@@ -0,0 +1,103 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { c as _c } from "react-compiler-runtime";
+import { useEffect, useState } from "react";
+import { evaluate } from "../evaluate.js";
+import { Callout } from "./callout.js";
+const Playground = (t0) => {
+  const $ = _c(13);
+  const {
+    source,
+    fallback: t1,
+    components,
+    scope
+  } = t0;
+  const fallback = t1 === void 0 ? null : t1;
+  const [compiledSource, setCompiledSource] = useState("");
+  const [error, setError] = useState();
+  let t2;
+  let t3;
+  if ($[0] !== source) {
+    t2 = () => {
+      const doCompile = async function doCompile2() {
+        const {
+          compileMdx
+        } = await importCompile();
+        ;
+        try {
+          const rawJs = await compileMdx(source);
+          setCompiledSource(rawJs);
+          setError(null);
+        } catch (t4) {
+          const error_0 = t4;
+          setError(error_0);
+        }
+      };
+      doCompile();
+    };
+    t3 = [source];
+    $[0] = source;
+    $[1] = t2;
+    $[2] = t3;
+  } else {
+    t2 = $[1];
+    t3 = $[2];
+  }
+  useEffect(t2, t3);
+  if (error) {
+    let t4;
+    let t5;
+    if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+      t4 = /* @__PURE__ */ jsx("b", { children: "Could not compile code" });
+      t5 = /* @__PURE__ */ jsx("br", {});
+      $[3] = t4;
+      $[4] = t5;
+    } else {
+      t4 = $[3];
+      t5 = $[4];
+    }
+    const t6 = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+    let t7;
+    if ($[5] !== t6) {
+      t7 = /* @__PURE__ */ jsxs(Callout, { type: "error", children: [
+        t4,
+        t5,
+        t6
+      ] });
+      $[5] = t6;
+      $[6] = t7;
+    } else {
+      t7 = $[6];
+    }
+    return t7;
+  }
+  if (compiledSource) {
+    let t4;
+    if ($[7] !== compiledSource || $[8] !== components || $[9] !== scope) {
+      t4 = evaluate(compiledSource, components, scope);
+      $[7] = compiledSource;
+      $[8] = components;
+      $[9] = scope;
+      $[10] = t4;
+    } else {
+      t4 = $[10];
+    }
+    const MDXContent = t4.default;
+    let t5;
+    if ($[11] !== MDXContent) {
+      t5 = /* @__PURE__ */ jsx(MDXContent, {});
+      $[11] = MDXContent;
+      $[12] = t5;
+    } else {
+      t5 = $[12];
+    }
+    return t5;
+  }
+  return fallback;
+};
+function importCompile() {
+  return import("../../server/compile.js");
+}
+export {
+  Playground
+};

package/dist/client/components/popup/index.client.d.ts

@@ -0,0 +1,7 @@
+import { PopoverProps, PopoverPanelProps } from '@headlessui/react';
+import { FC } from 'react';
+
+declare const Popup: FC<PopoverProps>;
+declare const PopupPanel: FC<PopoverPanelProps>;
+
+export { Popup, PopupPanel };

package/dist/client/components/popup/index.client.js

@@ -0,0 +1,83 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { c as _c } from "react-compiler-runtime";
+import { Popover, PopoverPanel } from "@headlessui/react";
+import cn from "clsx";
+import { createContext, useContext, useState } from "react";
+const PopupContext = createContext(null);
+function usePopup() {
+  const ctx = useContext(PopupContext);
+  if (typeof ctx !== "boolean") {
+    throw new Error("`usePopup` must be used within a `<Popup>` component");
+  }
+  return ctx;
+}
+const Popup = (props) => {
+  const $ = _c(6);
+  const [isOpen, setIsOpen] = useState(false);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = (event) => {
+      setIsOpen(event.type === "mouseenter");
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const handleMouse = t0;
+  let t1;
+  if ($[1] !== props) {
+    t1 = /* @__PURE__ */ jsx(Popover, { as: "span", onMouseEnter: handleMouse, onMouseLeave: handleMouse, ...props });
+    $[1] = props;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  let t2;
+  if ($[3] !== isOpen || $[4] !== t1) {
+    t2 = /* @__PURE__ */ jsx(PopupContext.Provider, { value: isOpen, children: t1 });
+    $[3] = isOpen;
+    $[4] = t1;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  return t2;
+};
+const PopupPanel = (props) => {
+  const $ = _c(7);
+  const isOpen = usePopup();
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = {
+      to: "bottom start",
+      gap: -24
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  let t1;
+  if ($[1] !== props.className) {
+    t1 = cn("x:max-w-2xl!", props.className);
+    $[1] = props.className;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  let t2;
+  if ($[3] !== isOpen || $[4] !== props || $[5] !== t1) {
+    t2 = /* @__PURE__ */ jsx(PopoverPanel, { static: isOpen, anchor: t0, ...props, className: t1 });
+    $[3] = isOpen;
+    $[4] = props;
+    $[5] = t1;
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  return t2;
+};
+export {
+  Popup,
+  PopupPanel
+};

package/dist/client/components/popup/index.d.ts

@@ -0,0 +1,12 @@
+import * as react from 'react';
+import { ComponentProps } from 'react';
+import * as _headlessui_react from '@headlessui/react';
+import * as react_jsx_runtime_js from 'react/jsx-runtime.js';
+import { Popup as Popup$1 } from './index.client.js';
+
+declare const Popup: ((props: ComponentProps<typeof Popup$1>) => react_jsx_runtime_js.JSX.Element) & {
+    Button: _headlessui_react._internal_ComponentPopoverButton;
+    Panel: react.FC<_headlessui_react.PopoverPanelProps>;
+};
+
+export { Popup };

package/dist/client/components/popup/index.js

@@ -0,0 +1,11 @@
+"use no memo";
+import { jsx } from "react/jsx-runtime";
+import { PopoverButton } from "@headlessui/react";
+import { Popup as _Popup, PopupPanel } from "./index.client.js";
+const Popup = Object.assign((props) => /* @__PURE__ */ jsx(_Popup, { ...props }), {
+  Button: PopoverButton,
+  Panel: PopupPanel
+});
+export {
+  Popup
+};

package/dist/client/components/search.d.ts

@@ -0,0 +1,88 @@
+import { ComboboxInputProps } from '@headlessui/react';
+import { FC, ReactNode } from 'react';
+import { PagefindSearchOptions } 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';
+
+declare function importPagefind(): Promise<void>;
+type InputProps = Omit<ComboboxInputProps, 'className' | 'onChange' | 'onFocus' | 'onBlur' | 'value' | 'placeholder'>;
+interface SearchProps extends InputProps {
+    /**
+     * Not found text.
+     * @default 'No results found.'
+     */
+    emptyResult?: ReactNode;
+    /**
+     * Error text.
+     * @default 'Failed to load search index.'
+     * */
+    errorText?: ReactNode;
+    /**
+     * Loading text.
+     * @default 'Loading…'
+     */
+    loading?: ReactNode;
+    /**
+     * Placeholder text.
+     * @default 'Search documentation…'
+     */
+    placeholder?: string;
+    /** Input container CSS class name. */
+    className?: string;
+    searchOptions?: PagefindSearchOptions;
+    /**
+     * Callback function that triggers whenever the search input changes.
+     *
+     * This prop is **not serializable** and cannot be used directly in a server-side layout.
+     *
+     * To use this prop, wrap the component in a **client-side** wrapper. Example:
+     *
+     * ```tsx filename="search-with-callback.jsx"
+     * 'use client'
+     *
+     * import { Search } from 'nextra/components'
+     *
+     * export function SearchWithCallback() {
+     *   return (
+     *     <Search
+     *       onSearch={query => {
+     *         console.log('Search query:', query)
+     *       }}
+     *     />
+     *   )
+     * }
+     * ```
+     *
+     * Then pass the wrapper to the layout:
+     *
+     * ```tsx filename="app/layout.jsx"
+     * import { SearchWithCallback } from '../path/to/your/search-with-callback'
+     * // ...
+     * <Layout search={<SearchWithCallback />} {...rest} />
+     * ```
+     *
+     * @param query - The current search input string.
+     */
+    onSearch?: (query: string) => void;
+}
+/**
+ * A built-in search component provides a seamless and fast search
+ * experience out of the box. Under the hood, it leverages the
+ * [Pagefind package](https://pagefind.app) — a fully client-side search engine optimized for static
+ * sites. Pagefind indexes your content at build time and enables highly performant,
+ * zero-JavaScript-dependency searches at runtime.
+ *
+ * @see [Nextra search setup guide](https://nextra.site/docs/guide/search)
+ */
+declare const Search: FC<SearchProps>;
+
+export { Search, importPagefind };