@hanzo/docs-core 16.5.0 → 16.5.3

package/dist/mdx-plugins/rehype-code.core.js

@@ -0,0 +1,104 @@
+import { parseCodeBlockAttributes } from "./codeblock-utils.js";
+import { t as transformerIcon } from "../transformer-icon-BYedaeE8.js";
+import rehypeShikiFromHighlighter from "@shikijs/rehype/core";
+import { transformerNotationDiff, transformerNotationFocus, transformerNotationHighlight, transformerNotationWordHighlight } from "@shikijs/transformers";
+
+//#region src/mdx-plugins/rehype-code.core.ts
+function rehypeCodeDefaultOptions(config) {
+	return {
+		lazy: true,
+		...config.defaultThemes,
+		defaultColor: false,
+		defaultLanguage: "plaintext",
+		transformers: [
+			transformerNotationHighlight({ matchAlgorithm: "v3" }),
+			transformerNotationWordHighlight({ matchAlgorithm: "v3" }),
+			transformerNotationDiff({ matchAlgorithm: "v3" }),
+			transformerNotationFocus({ matchAlgorithm: "v3" })
+		],
+		parseMetaString(meta) {
+			const parsed = parseCodeBlockAttributes(meta, ["title", "tab"]);
+			const data = parsed.attributes;
+			parsed.rest = parseLineNumber(parsed.rest, data);
+			data.__parsed_raw = parsed.rest;
+			return data;
+		}
+	};
+}
+function parseLineNumber(str, data) {
+	return str.replace(/lineNumbers=(\d+)|lineNumbers/, (_, ...args) => {
+		data["data-line-numbers"] = true;
+		if (args[0] !== void 0) data["data-line-numbers-start"] = Number(args[0]);
+		return "";
+	});
+}
+function createRehypeCode(configFactory) {
+	return function rehypeCode(_options) {
+		const { config, options } = typeof configFactory === "function" ? configFactory(_options) : {
+			config: configFactory,
+			options: {
+				...rehypeCodeDefaultOptions(configFactory),
+				..._options
+			}
+		};
+		const transformers = options.transformers ? [...options.transformers] : [];
+		transformers.unshift({
+			name: "rehype-code:pre-process",
+			preprocess(code, { meta }) {
+				if (meta && "__parsed_raw" in meta) {
+					meta.__raw = meta.__parsed_raw;
+					delete meta.__parsed_raw;
+				}
+				if (meta && options.filterMetaString) meta.__raw = options.filterMetaString(meta.__raw ?? "");
+				return code.replace(/\n$/, "");
+			}
+		});
+		if (options.icon !== false) transformers.push(transformerIcon(options.icon));
+		if (options.tab !== false) transformers.push(transformerTab());
+		const transformer = Promise.resolve(config.createHighlighter()).then(async (highlighter) => {
+			if ("themes" in options) await highlighter.loadTheme(...Object.values(options.themes).filter(Boolean));
+			else await highlighter.loadTheme(options.theme);
+			const langs = options.langs ?? (options.lazy ? [
+				"js",
+				"jsx",
+				"ts",
+				"tsx"
+			] : Object.keys(highlighter.getBundledLanguages()));
+			await highlighter.loadLanguage(...langs);
+			return rehypeShikiFromHighlighter(highlighter, {
+				...options,
+				transformers
+			});
+		});
+		return async (tree, file) => {
+			await (await transformer)(tree, file, () => {});
+		};
+	};
+}
+function transformerTab() {
+	return {
+		name: "rehype-code:tab",
+		root(root) {
+			const value = this.options.meta?.tab;
+			if (typeof value !== "string") return root;
+			console.warn("[Hanzo Docs] For `tab=\"value\" in codeblocks, please use `remarkCodeTab` plugin instead.");
+			return {
+				type: "root",
+				children: [{
+					type: "mdxJsxFlowElement",
+					name: "Tab",
+					data: { _codeblock: true },
+					attributes: [{
+						type: "mdxJsxAttribute",
+						name: "value",
+						value
+					}],
+					children: root.children
+				}]
+			};
+		}
+	};
+}
+
+//#endregion
+export { createRehypeCode, rehypeCodeDefaultOptions, transformerIcon, transformerTab };

package/dist/mdx-plugins/rehype-code.d.ts

@@ -1,2 +1,18 @@
-import { a as CodeBlockIcon, i as transformerTab, n as rehypeCode, o as transformerIcon, r as rehypeCodeDefaultOptions, t as RehypeCodeOptions } from "../rehype-code-vVWG4-ej.js";
-export { CodeBlockIcon, RehypeCodeOptions, rehypeCode, rehypeCodeDefaultOptions, transformerIcon, transformerTab };
+import { r as transformerIcon, t as CodeBlockIcon } from "../transformer-icon-D7-6aFzt.js";
+import { RehypeCodeOptionsCommon, transformerTab } from "./rehype-code.core.js";
+import * as unified from "unified";
+import * as hast from "hast";
+
+//#region src/mdx-plugins/rehype-code.d.ts
+type RehypeCodeOptions = RehypeCodeOptionsCommon & {
+  /**
+   * The regex engine to use.
+   *
+   * @defaultValue 'js'
+   */
+  engine?: 'js' | 'oniguruma';
+};
+declare const rehypeCodeDefaultOptions: RehypeCodeOptions;
+declare const rehypeCode: (this: unified.Processor, _options: Partial<RehypeCodeOptions> | undefined) => unified.Transformer<hast.Root, hast.Root>;
+//#endregion
+export { type CodeBlockIcon, RehypeCodeOptions, rehypeCode, rehypeCodeDefaultOptions, transformerIcon, transformerTab };

package/dist/mdx-plugins/rehype-code.js

@@ -1,5 +1,26 @@
-import "../shiki-B5wNmyIZ.js";
-import "./codeblock-utils.js";
-import { i as transformerIcon, n as rehypeCodeDefaultOptions, r as transformerTab, t as rehypeCode } from "../rehype-code-sM9Tq-r7.js";
+import { configDefault, configWASM } from "../highlight/index.js";
+import { t as transformerIcon } from "../transformer-icon-BYedaeE8.js";
+import { createRehypeCode, rehypeCodeDefaultOptions as rehypeCodeDefaultOptions$1, transformerTab } from "./rehype-code.core.js";
 
+//#region src/mdx-plugins/rehype-code.ts
+const rehypeCodeDefaultOptions = {
+	engine: "js",
+	...rehypeCodeDefaultOptions$1(configDefault)
+};
+const rehypeCode = createRehypeCode((_options) => {
+	const options = {
+		...rehypeCodeDefaultOptions,
+		..._options
+	};
+	if (options.engine === "oniguruma") return {
+		config: configWASM,
+		options
+	};
+	return {
+		config: configDefault,
+		options
+	};
+});
+
+//#endregion
 export { rehypeCode, rehypeCodeDefaultOptions, transformerIcon, transformerTab };

package/dist/mdx-plugins/rehype-toc.d.ts

@@ -1,2 +1,17 @@
-import { n as rehypeToc, t as RehypeTocOptions } from "../rehype-toc-DJvSyE0o.js";
+import { Processor, Transformer } from "unified";
+import { Root } from "hast";
+
+//#region src/mdx-plugins/rehype-toc.d.ts
+interface RehypeTocOptions {
+  /**
+   * Export generated toc as a variable
+   *
+   * @defaultValue true
+   */
+  exportToc?: boolean;
+}
+declare function rehypeToc(this: Processor, {
+  exportToc
+}?: RehypeTocOptions): Transformer<Root, Root>;
+//#endregion
 export { RehypeTocOptions, rehypeToc };

package/dist/mdx-plugins/rehype-toc.js

@@ -1,3 +1,129 @@
-import { t as rehypeToc } from "../rehype-toc-DVwJcwvA.js";
+import { t as visit } from "../hast-utils-BmGqqmvo.js";
+import { toEstree } from "hast-util-to-estree";
 
+//#region src/mdx-plugins/rehype-toc.ts
+const TocOnlyTag = "[toc]";
+const NoTocTag = "[!toc]";
+function rehypeToc({ exportToc = true } = {}) {
+	return (tree) => {
+		const output = [];
+		visit(tree, [
+			"h1",
+			"h2",
+			"h3",
+			"h4",
+			"h5",
+			"h6"
+		], (element) => {
+			const id = element.properties.id;
+			if (typeof id !== "string") return "skip";
+			let isTocOnly = false;
+			const last = element.children.at(-1);
+			if (last?.type === "text" && last.value.endsWith(TocOnlyTag)) {
+				isTocOnly = true;
+				last.value = last.value.substring(0, last.value.length - 5).trimEnd();
+			} else if (last?.type === "text" && last.value.endsWith(NoTocTag)) {
+				last.value = last.value.substring(0, last.value.length - 6).trimEnd();
+				return "skip";
+			}
+			const estree = toEstree(element, {
+				elementAttributeNameCase: "react",
+				stylePropertyNameCase: "dom"
+			});
+			if (estree.body[0].type === "ExpressionStatement") output.push({
+				title: estree.body[0].expression,
+				depth: Number(element.tagName.slice(1)),
+				url: `#${id}`
+			});
+			if (isTocOnly) Object.assign(element, {
+				type: "comment",
+				value: ""
+			});
+			return "skip";
+		});
+		const declaration = {
+			type: "VariableDeclaration",
+			kind: "const",
+			declarations: [{
+				type: "VariableDeclarator",
+				id: {
+					type: "Identifier",
+					name: "toc"
+				},
+				init: {
+					type: "ArrayExpression",
+					elements: output.map((item) => ({
+						type: "ObjectExpression",
+						properties: [
+							{
+								type: "Property",
+								method: false,
+								shorthand: false,
+								computed: false,
+								key: {
+									type: "Identifier",
+									name: "depth"
+								},
+								value: {
+									type: "Literal",
+									value: item.depth
+								},
+								kind: "init"
+							},
+							{
+								type: "Property",
+								method: false,
+								shorthand: false,
+								computed: false,
+								key: {
+									type: "Identifier",
+									name: "url"
+								},
+								value: {
+									type: "Literal",
+									value: item.url
+								},
+								kind: "init"
+							},
+							{
+								type: "Property",
+								method: false,
+								shorthand: false,
+								computed: false,
+								key: {
+									type: "Identifier",
+									name: "title"
+								},
+								value: {
+									type: "JSXFragment",
+									openingFragment: { type: "JSXOpeningFragment" },
+									closingFragment: { type: "JSXClosingFragment" },
+									children: item.title.children
+								},
+								kind: "init"
+							}
+						]
+					}))
+				}
+			}]
+		};
+		tree.children.push({
+			type: "mdxjsEsm",
+			value: "",
+			data: { estree: {
+				type: "Program",
+				body: [exportToc ? {
+					type: "ExportNamedDeclaration",
+					declaration,
+					attributes: [],
+					specifiers: []
+				} : declaration],
+				sourceType: "module",
+				comments: []
+			} }
+		});
+	};
+}
+
+//#endregion
 export { rehypeToc };

package/dist/mdx-plugins/remark-admonition.d.ts

@@ -1,2 +1,21 @@
-import { n as remarkAdmonition, t as RemarkAdmonitionOptions } from "../remark-admonition-DOwBWzsH.js";
+import { Transformer } from "unified";
+import { Root } from "mdast";
+
+//#region src/mdx-plugins/remark-admonition.d.ts
+interface RemarkAdmonitionOptions {
+  tag?: string;
+  /**
+   * Map type to another type
+   */
+  typeMap?: Record<string, string>;
+}
+/**
+ * Remark Plugin to support Admonition syntax
+ *
+ * Useful when Migrating from Docusaurus
+ *
+ * @deprecated Use `remarkDirectiveAdmonition` with `remark-directive` configured instead.
+ */
+declare function remarkAdmonition(options?: RemarkAdmonitionOptions): Transformer<Root, Root>;
+//#endregion
 export { RemarkAdmonitionOptions, remarkAdmonition };

package/dist/mdx-plugins/remark-admonition.js

@@ -1,4 +1,4 @@
-import { t as flattenNode } from "../mdast-utils-mc9-X-PK.js";
+import { t as flattenNode } from "../mdast-utils-gJMY143g.js";
 import { visit } from "unist-util-visit";
 
 //#region src/mdx-plugins/remark-admonition.ts
@@ -70,5 +70,4 @@ function remarkAdmonition(options = {}) {
 }
 
 //#endregion
-export { remarkAdmonition };
-//# sourceMappingURL=remark-admonition.js.map
+export { remarkAdmonition };

package/dist/mdx-plugins/remark-code-tab.d.ts

@@ -1,2 +1,31 @@
-import { n as remarkCodeTab, t as RemarkCodeTabOptions } from "../remark-code-tab-CXsYlims.js";
+import { Processor, Transformer } from "unified";
+import { Code, Root } from "mdast";
+import { MdxJsxFlowElement } from "mdast-util-mdx-jsx";
+
+//#region src/mdx-plugins/remark-code-tab.d.ts
+type TabType = keyof typeof Types;
+interface RemarkCodeTabOptions {
+  Tabs?: TabType;
+  /**
+   * Parse MDX in tab values
+   *
+   * @defaultValue false
+   */
+  parseMdx?: boolean;
+}
+declare module 'mdast' {
+  interface CodeData {
+    tab?: string;
+  }
+}
+declare const Types: {
+  CodeBlockTabs: {
+    convert(processor: Processor, nodes: Code[], withMdx?: boolean, withParent?: boolean): MdxJsxFlowElement;
+  };
+  Tabs: {
+    convert(processor: Processor, nodes: Code[], withMdx?: boolean, withParent?: boolean): MdxJsxFlowElement;
+  };
+};
+declare function remarkCodeTab(this: Processor, options?: RemarkCodeTabOptions): Transformer<Root, Root>;
+//#endregion
 export { RemarkCodeTabOptions, remarkCodeTab };

package/dist/mdx-plugins/remark-code-tab.js

@@ -25,7 +25,7 @@ const Types = {
 	Tabs: { convert(processor, nodes, withMdx = false, withParent = true) {
 		const tabs = Array.from(processTabValue(nodes).entries());
 		if (!withMdx) {
-			const children$1 = tabs.map(([name, codes]) => {
+			const children = tabs.map(([name, codes]) => {
 				return {
 					type: "mdxJsxFlowElement",
 					name: "Tab",
@@ -37,7 +37,7 @@ const Types = {
 					children: codes
 				};
 			});
-			if (!withParent) return createFragment(children$1);
+			if (!withParent) return createFragment(children);
 			return {
 				type: "mdxJsxFlowElement",
 				name: "Tabs",
@@ -64,7 +64,7 @@ const Types = {
 						} }
 					}
 				}],
-				children: children$1
+				children
 			};
 		}
 		const children = [{
@@ -180,5 +180,4 @@ function createFragment(children) {
 }
 
 //#endregion
-export { remarkCodeTab };
-//# sourceMappingURL=remark-code-tab.js.map
+export { remarkCodeTab };

package/dist/mdx-plugins/remark-directive-admonition.d.ts

@@ -1,2 +1,35 @@
-import { n as remarkDirectiveAdmonition, t as RemarkDirectiveAdmonitionOptions } from "../remark-directive-admonition-BCm_yiU9.js";
+import { Transformer } from "unified";
+import { Root } from "mdast";
+
+//#region src/mdx-plugins/remark-directive-admonition.d.ts
+interface RemarkDirectiveAdmonitionOptions {
+  /**
+   * the tag names of Callout component.
+   */
+  tags?: {
+    CalloutContainer?: string;
+    CalloutTitle?: string;
+    CalloutDescription?: string;
+  };
+  /**
+   * All supported admonition types and their linked Callout type.
+   *
+   * When specified, all defaults will be cleared.
+   */
+  types?: Record<string, string>;
+}
+/**
+ * Remark Plugin to support Admonition syntax in Docusaurus, useful for migrating from Docusaurus.
+ *
+ * Requires [`remark-directive`](https://github.com/remarkjs/remark-directive) to be configured.
+ */
+declare function remarkDirectiveAdmonition({
+  tags: {
+    CalloutContainer,
+    CalloutTitle,
+    CalloutDescription
+  },
+  types
+}?: RemarkDirectiveAdmonitionOptions): Transformer<Root, Root>;
+//#endregion
 export { RemarkDirectiveAdmonitionOptions, remarkDirectiveAdmonition };

package/dist/mdx-plugins/remark-directive-admonition.js

@@ -56,5 +56,4 @@ function remarkDirectiveAdmonition({ tags: { CalloutContainer = "CalloutContaine
 }
 
 //#endregion
-export { remarkDirectiveAdmonition };
-//# sourceMappingURL=remark-directive-admonition.js.map
+export { remarkDirectiveAdmonition };

package/dist/mdx-plugins/remark-feedback-block.d.ts

@@ -0,0 +1,51 @@
+import { Transformer } from "unified";
+import { Root, RootContent } from "mdast";
+
+//#region src/mdx-plugins/remark-feedback-block.d.ts
+interface RemarkFeedbackBlockOptions {
+  /**
+   * generate block ID, default to using MD5.
+   */
+  generateHash?: (ctx: {
+    body: string;
+  }) => string;
+  /**
+   * @defaultValue FeedbackBlock
+   */
+  tagName?: string;
+  /**
+   * determine how the node should be resolved into a feedback block.
+   *
+   * scan paragraph, list, and image nodes by default.
+   *
+   * @returns
+   * - `true`: convert the node into a feedback block.
+   * - `false`: skip the current node and look into its children.
+   * - `skip`: skip the current node and its children.
+   */
+  resolve?: (node: RootContent) => boolean | 'skip';
+  /**
+   * generate & include the block body to `<FeedbackBlock body="..." />` as string
+   *
+   * @defaultValue true
+   */
+  generateBody?: boolean;
+}
+interface FeedbackBlockProps {
+  id: string;
+  /** the text body of block, only exists when `generateBody` is enabled. */
+  body?: string;
+}
+/**
+ * Generate MDX `<FeedbackBlock />` elements with an unique `id` for every block-like element.
+ *
+ * Note: the uniqueness is only guaranteed per MDX file/page.
+ */
+declare function remarkFeedbackBlock({
+  generateHash,
+  tagName,
+  resolve,
+  generateBody
+}?: RemarkFeedbackBlockOptions): Transformer<Root, Root>;
+//#endregion
+export { FeedbackBlockProps, RemarkFeedbackBlockOptions, remarkFeedbackBlock };

package/dist/mdx-plugins/remark-feedback-block.js

@@ -0,0 +1,47 @@
+import { t as flattenNode } from "../mdast-utils-gJMY143g.js";
+import { visit } from "unist-util-visit";
+import { createHash } from "node:crypto";
+
+//#region src/mdx-plugins/remark-feedback-block.ts
+/**
+* Generate MDX `<FeedbackBlock />` elements with an unique `id` for every block-like element.
+*
+* Note: the uniqueness is only guaranteed per MDX file/page.
+*/
+function remarkFeedbackBlock({ generateHash = ({ body }) => createHash("md5").update(body).digest("hex").substring(0, 16), tagName = "FeedbackBlock", resolve = (node) => node.type === "paragraph" || node.type === "image" || node.type === "list", generateBody = true } = {}) {
+	return (tree) => {
+		const counts = /* @__PURE__ */ new Map();
+		visit(tree, (node, index, parent) => {
+			if (node.type === "root") return;
+			const resolved = resolve(node);
+			if (resolved === false) return;
+			if (resolved === "skip") return "skip";
+			const text = flattenNode(node).trim();
+			if (text.length === 0 || !parent || typeof index !== "number") return;
+			let id = generateHash({ body: text });
+			const count = counts.get(id) ?? 0;
+			if (count > 0) id = `${id}-${count}`;
+			counts.set(id, count + 1);
+			const wrapper = {
+				type: "mdxJsxFlowElement",
+				name: tagName,
+				attributes: [{
+					type: "mdxJsxAttribute",
+					name: "id",
+					value: id
+				}],
+				children: [node]
+			};
+			if (generateBody) wrapper.attributes.push({
+				type: "mdxJsxAttribute",
+				name: "body",
+				value: text
+			});
+			parent.children[index] = wrapper;
+			return "skip";
+		});
+	};
+}
+
+//#endregion
+export { remarkFeedbackBlock };

package/dist/mdx-plugins/remark-gfm.d.ts

@@ -1,2 +1,2 @@
-import { n as remarkGfm, t as RemarkGfmOptions } from "../remark-gfm-CeWpMwyk.js";
-export { RemarkGfmOptions, remarkGfm };
+import remarkGfm, { Options as RemarkGfmOptions } from "remark-gfm";
+export { type RemarkGfmOptions, remarkGfm };

package/dist/mdx-plugins/remark-heading.d.ts

@@ -1,2 +1,36 @@
-import { n as remarkHeading, t as RemarkHeadingOptions } from "../remark-heading-CXvCY0go.js";
+import { Transformer } from "unified";
+import { Heading, Root } from "mdast";
+
+//#region src/mdx-plugins/remark-heading.d.ts
+declare module 'mdast' {
+  interface HeadingData extends Data {
+    hProperties?: {
+      id?: string;
+    };
+  }
+}
+interface RemarkHeadingOptions {
+  slug?: (root: Root, heading: Heading, text: string) => string;
+  /**
+   * Allow custom headings ids
+   *
+   * @defaultValue true
+   */
+  customId?: boolean;
+  /**
+   * Attach an array of `TOCItemType` to `file.data.toc`
+   *
+   * @defaultValue true
+   */
+  generateToc?: boolean;
+}
+/**
+ * Add heading ids and extract TOC
+ */
+declare function remarkHeading({
+  slug: defaultSlug,
+  customId,
+  generateToc
+}?: RemarkHeadingOptions): Transformer<Root, Root>;
+//#endregion
 export { RemarkHeadingOptions, remarkHeading };

package/dist/mdx-plugins/remark-heading.js

@@ -1,4 +1,4 @@
-import { t as flattenNode } from "../mdast-utils-mc9-X-PK.js";
+import { t as flattenNode } from "../mdast-utils-gJMY143g.js";
 import Slugger from "github-slugger";
 import { visit } from "unist-util-visit";
 
@@ -41,5 +41,4 @@ function remarkHeading({ slug: defaultSlug, customId = true, generateToc = true
 }
 
 //#endregion
-export { remarkHeading };
-//# sourceMappingURL=remark-heading.js.map
+export { remarkHeading };

package/dist/mdx-plugins/remark-image.d.ts

@@ -1,2 +1,64 @@
-import { n as remarkImage, t as RemarkImageOptions } from "../remark-image-CvUis4R1.js";
+import { Transformer } from "unified";
+import { Root } from "mdast";
+
+//#region src/mdx-plugins/remark-image.d.ts
+type ExternalImageOptions = {
+  /**
+   * timeout for fetching remote images (in milliseconds)
+   */
+  timeout?: number;
+} | boolean;
+interface RemarkImageOptions {
+  /**
+   * Directory or base URL to resolve absolute image paths
+   */
+  publicDir?: string;
+  /**
+   * Preferred placeholder type, only available with `useImport` + local images.
+   *
+   * @defaultValue 'blur'
+   */
+  placeholder?: 'blur' | 'none';
+  /**
+   * Define how to handle errors when fetching image size.
+   *
+   * - `error` (default): throw an error.
+   * - `ignore`: do absolutely nothing (Next.js Image component may complain).
+   * - `hide`: remove that image element.
+   *
+   * @defaultValue 'error'
+   */
+  onError?: 'error' | 'hide' | 'ignore' | ((error: Error) => void);
+  /**
+   * Import images in the file, and let bundlers handle it.
+   *
+   * ```tsx
+   * import MyImage from "./public/img.png";
+   *
+   * <img src={MyImage} />
+   * ```
+   *
+   * When disabled, `placeholder` will be ignored.
+   *
+   * @defaultValue true
+   */
+  useImport?: boolean;
+  /**
+   * Fetch image size of external URLs
+   *
+   * @defaultValue true
+   */
+  external?: ExternalImageOptions;
+}
+/**
+ * Turn images into Next.js Image compatible usage.
+ */
+declare function remarkImage({
+  placeholder,
+  external,
+  useImport,
+  onError,
+  publicDir
+}?: RemarkImageOptions): Transformer<Root, Root>;
+//#endregion
 export { RemarkImageOptions, remarkImage };

package/dist/mdx-plugins/remark-image.js

@@ -188,5 +188,4 @@ async function getImageSize(src, onExternal) {
 }
 
 //#endregion
-export { remarkImage };
-//# sourceMappingURL=remark-image.js.map
+export { remarkImage };