@vx-oss/docs-satteri 1.0.3

package/dist/rehype-katex.js

@@ -0,0 +1,52 @@
+import { defineHastPlugin, htmlToHast } from "satteri";
+//#region src/rehype-katex.ts
+let katexPromise;
+function loadKatex() {
+	katexPromise ??= import("katex").then((katex) => katex.default.renderToString);
+	return katexPromise;
+}
+function classList(node) {
+	const raw = node.properties?.className;
+	if (Array.isArray(raw)) return raw.map(String);
+	if (typeof raw === "string") return raw.split(/\s+/);
+	return [];
+}
+function replace(target, nodes, ctx) {
+	if (nodes.length === 0) {
+		ctx.removeNode(target);
+		return;
+	}
+	ctx.replaceNode(target, nodes[0]);
+	if (nodes.length > 1) ctx.insertAfter(target, nodes.slice(1));
+}
+/**
+* Render `$…$`, `$$…$$`, and ```` ```math ```` blocks to KaTeX markup — the
+* Satteri counterpart of `rehype-katex`. Satteri's `math` feature parses the
+* syntax into `<code class="language-math …">` elements (raw TeX); this renders
+* them.
+*
+* The preset adds this to the hast pipeline when `math` is enabled.
+*/
+function rehypeKatex(options = {}) {
+	return () => defineHastPlugin({
+		name: "rehype-katex",
+		element: {
+			filter: ["code"],
+			async visit(node, ctx) {
+				const classes = classList(node);
+				if (!classes.includes("language-math")) return;
+				const displayMode = !classes.includes("math-inline");
+				const html = (await loadKatex())(ctx.textContent(node), {
+					...options,
+					displayMode,
+					throwOnError: false
+				});
+				const rendered = htmlToHast(html, { fragment: true }).children;
+				const parent = ctx.parent(node);
+				replace(displayMode && parent?.type === "element" && parent.tagName === "pre" ? parent : node, rendered, ctx);
+			}
+		}
+	});
+}
+//#endregion
+export { rehypeKatex };

package/dist/rehype-toc-wT8IcPFi.d.ts

@@ -0,0 +1,33 @@
+import { o as ExtraPluginHooks } from "./compile-SBpZsgmI.js";
+import { HastPluginInput } from "satteri";
+import { Element } from "hast";
+//#region src/rehype-toc.d.ts
+interface RehypeTocOptions {
+  exportToc?: boolean | {
+    as: 'data';
+  } | {
+    as: 'esm';
+    name: string;
+  };
+}
+interface RehypeTocItemType {
+  title: string;
+  url: string;
+  depth: number;
+  _step?: number;
+}
+interface RehypeTocESMItemType {
+  title: Element;
+  url: string;
+  depth: number;
+  _step?: number;
+}
+declare module 'satteri' {
+  interface DataMap {
+    /** serialized items, exported by `compileMdx` */
+    _rehypeTocItems?: string[];
+  }
+}
+declare function rehypeToc({ exportToc }?: RehypeTocOptions): HastPluginInput & ExtraPluginHooks;
+//#endregion
+export { rehypeToc as i, RehypeTocItemType as n, RehypeTocOptions as r, RehypeTocESMItemType as t };

package/dist/rehype-toc.d.ts

@@ -0,0 +1,2 @@
+import { i as rehypeToc, n as RehypeTocItemType, r as RehypeTocOptions, t as RehypeTocESMItemType } from "./rehype-toc-wT8IcPFi.js";
+export { RehypeTocESMItemType, RehypeTocItemType, RehypeTocOptions, rehypeToc };

package/dist/rehype-toc.js

@@ -0,0 +1,84 @@
+import { n as handleTag, r as jsxToSource } from "./utils-I3DkmAkd.js";
+import { defineHastPlugin } from "satteri";
+//#region src/rehype-toc.ts
+const TocOnlyTag = "[toc]";
+const NoTocTag = "[!toc]";
+const HeadingTags = [
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6"
+];
+function rehypeToc({ exportToc = true } = {}) {
+	if (exportToc === false) return defineHastPlugin({ name: "rehype-toc" });
+	const resolved = exportToc === true ? {
+		as: "esm",
+		name: "toc"
+	} : exportToc;
+	const plugin = () => {
+		return {
+			name: "rehype-toc",
+			before(_root, ctx) {
+				if (resolved.as === "data") ctx.data.rehypeToc ??= [];
+			},
+			element: {
+				filter: HeadingTags,
+				visit(node, ctx) {
+					const element = node;
+					if (element.children.length === 0) return;
+					const id = element.properties.id;
+					if (typeof id !== "string") return;
+					let isTocOnly = false;
+					let title = ctx.textContent(element);
+					let titleChildren = element.children;
+					const last = element.children[element.children.length - 1];
+					if (last?.type === "text") {
+						const noToc = handleTag(last.value, NoTocTag);
+						if (noToc !== false) {
+							ctx.setProperty(last, "value", noToc);
+							return;
+						}
+						const tocOnly = handleTag(last.value, TocOnlyTag);
+						if (tocOnly !== false) {
+							isTocOnly = true;
+							title = title.slice(0, title.length - last.value.length) + tocOnly;
+							titleChildren = [...element.children.slice(0, -1), {
+								...last,
+								value: tocOnly
+							}];
+						}
+					}
+					if (isTocOnly) ctx.removeNode(element);
+					const step = typeof element.properties["data-fd-step"] === "number" ? element.properties["data-fd-step"] : void 0;
+					if (resolved.as === "esm") {
+						let obj = "{";
+						obj += `title: ${jsxToSource({
+							type: "root",
+							children: titleChildren
+						})},`;
+						obj += `url: ${JSON.stringify(`#${id}`)},`;
+						obj += `depth: ${JSON.stringify(Number(element.tagName[1]))},`;
+						if (step !== void 0) obj += `_step: ${JSON.stringify(step)},`;
+						obj += "}";
+						(ctx.data._rehypeTocItems ??= []).push(obj);
+						return;
+					}
+					(ctx.data.rehypeToc ??= []).push({
+						title,
+						depth: Number(element.tagName[1]),
+						url: `#${id}`,
+						_step: step
+					});
+				}
+			}
+		};
+	};
+	plugin.collectExports = ({ data, addExport }) => {
+		if (resolved.as === "esm") addExport(resolved.name, `[${(data._rehypeTocItems ?? []).join(",")}]`);
+	};
+	return plugin;
+}
+//#endregion
+export { rehypeToc };

package/dist/remark-admonition.d.ts

@@ -0,0 +1,13 @@
+import { MdastVisitorContext } from "satteri";
+//#region src/remark-admonition.d.ts
+interface RemarkAdmonitionOptions {
+  tag?: string;
+  typeMap?: Record<string, string>;
+}
+declare function remarkAdmonition(options?: RemarkAdmonitionOptions): () => {
+  name: string;
+  paragraph(node: Readonly<import("mdast").Paragraph>, ctx: MdastVisitorContext): undefined;
+  after(_root: Readonly<import("mdast").Root>, ctx: MdastVisitorContext): void;
+};
+//#endregion
+export { RemarkAdmonitionOptions, remarkAdmonition };

package/dist/remark-admonition.js

@@ -0,0 +1,79 @@
+import { defineMdastPlugin } from "satteri";
+//#region src/remark-admonition.ts
+function remarkAdmonition(options = {}) {
+	const tag = options.tag ?? ":::";
+	const typeMap = options.typeMap ?? {
+		info: "info",
+		warn: "warn",
+		note: "info",
+		tip: "info",
+		warning: "warn",
+		danger: "error"
+	};
+	const typeKeys = Object.keys(typeMap).sort((a, b) => b.length - a.length);
+	function replaceNodes(nodes, ctx) {
+		let found = false;
+		let open = -1;
+		let attributes = [];
+		let hasIntercept = false;
+		for (let i = 0; i < nodes.length; i++) {
+			const node = nodes[i];
+			if (node.type !== "paragraph") continue;
+			const text = ctx.textContent(node, { includeImageAlt: false });
+			const typeName = typeKeys.find((type) => text.startsWith(`${tag}${type}`));
+			if (typeName) {
+				if (open !== -1) {
+					hasIntercept = true;
+					continue;
+				}
+				open = i;
+				attributes.push({
+					type: "mdxJsxAttribute",
+					name: "type",
+					value: typeMap[typeName]
+				});
+				const meta = text.slice(`${tag}${typeName}`.length);
+				if (meta.startsWith("[") && meta.endsWith("]")) attributes.push({
+					type: "mdxJsxAttribute",
+					name: "title",
+					value: meta.slice(1, -1)
+				});
+			}
+			if (open !== -1 && text === tag) {
+				const children = nodes.slice(open + 1, i);
+				if (hasIntercept) replaceNodes(children, ctx);
+				nodes.splice(open, i - open + 1, {
+					type: "mdxJsxFlowElement",
+					name: "Callout",
+					attributes,
+					children
+				});
+				found = true;
+				i = open;
+				open = -1;
+				hasIntercept = false;
+				attributes = [];
+			}
+		}
+		return found;
+	}
+	return () => {
+		const parents = /* @__PURE__ */ new Set();
+		return defineMdastPlugin({
+			name: "remark-admonition",
+			paragraph(node, ctx) {
+				if (!ctx.textContent(node, { includeImageAlt: false }).startsWith(tag)) return;
+				const parent = ctx.parent(node);
+				if (parent && "children" in parent) parents.add(parent);
+			},
+			after(_root, ctx) {
+				for (const parent of parents) {
+					const copy = [...parent.children];
+					if (replaceNodes(copy, ctx)) ctx.setProperty(parent, "children", copy);
+				}
+			}
+		});
+	};
+}
+//#endregion
+export { remarkAdmonition };

package/dist/remark-auto-type-table.d.ts

@@ -0,0 +1,9 @@
+import { MdxJsxFlowElement } from "satteri";
+import { RemarkAutoTypeTableOptions, RemarkAutoTypeTableOptions as RemarkAutoTypeTableOptions$1 } from "@vx-oss/docs-typescript";
+//#region src/remark-auto-type-table.d.ts
+declare function remarkAutoTypeTable(config?: RemarkAutoTypeTableOptions$1): {
+  name: string;
+  mdxJsxFlowElement(node: Readonly<MdxJsxFlowElement>, ctx: import("satteri").MdastVisitorContext): Promise<undefined>;
+};
+//#endregion
+export { type RemarkAutoTypeTableOptions, remarkAutoTypeTable };

package/dist/remark-auto-type-table.js

@@ -0,0 +1,189 @@
+import { i as replaceSource, n as formatTable } from "./stringifier-COIWcXys.js";
+import { r as jsxToSource } from "./utils-I3DkmAkd.js";
+import { defineMdastPlugin, markdownToHast } from "satteri";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { highlightHast } from "@vx-oss/docs-core/highlight";
+import { createGenerator } from "@vx-oss/docs-typescript";
+//#region src/remark-auto-type-table.ts
+function sanitizeHast(node) {
+	if (node.type === "raw") return {
+		type: "text",
+		value: node.value
+	};
+	if ("children" in node && Array.isArray(node.children)) return {
+		...node,
+		children: node.children.map((child) => sanitizeHast(child))
+	};
+	return node;
+}
+function parseTags(tags) {
+	const typed = {};
+	for (const { name: key, text } of tags) {
+		if (key === "default" || key === "defaultValue") {
+			typed.default = text;
+			continue;
+		}
+		if (key === "param") {
+			const sepIdx = text.indexOf("-");
+			typed.params ??= [];
+			typed.params.push({
+				name: sepIdx === -1 ? text.trim() : text.slice(0, sepIdx).trim(),
+				description: sepIdx === -1 ? "" : text.slice(sepIdx + 1).trim()
+			});
+			continue;
+		}
+		if (key === "returns") typed.returns = text;
+	}
+	return typed;
+}
+async function buildTypeProp(entries, renderType, renderMarkdown) {
+	async function onItem(entry) {
+		let node = "{";
+		const tags = parseTags(entry.tags);
+		node += `type: ${jsxToSource(await renderType(entry.simplifiedType))},`;
+		node += `typeDescription: ${jsxToSource(await renderType(entry.type))},`;
+		node += `required: ${JSON.stringify(entry.required)},`;
+		if (entry.typeHref) node += `typeDescriptionLink: ${JSON.stringify(entry.typeHref)},`;
+		if (tags.default) node += `default: ${jsxToSource(await renderType(tags.default))},`;
+		if (tags.returns) node += `returns: ${jsxToSource(await renderMarkdown(tags.returns))},`;
+		if (tags.params) {
+			const params = await Promise.all(tags.params.map(async ({ name, description }) => {
+				let param = "{";
+				param += `name: ${JSON.stringify(name)},`;
+				if (description) param += `description: ${jsxToSource(await renderMarkdown(description))},`;
+				param += "}";
+				return param;
+			}));
+			node += `parameters: [${params.join(", ")}],`;
+		}
+		if (entry.description) node += `description: ${jsxToSource(await renderMarkdown(entry.description))},`;
+		if (entry.deprecated) node += `deprecated: true,`;
+		node += "}";
+		return node;
+	}
+	let prop = "{";
+	for (const entry of entries) prop += `${JSON.stringify(entry.name)}: ${await onItem(entry)},`;
+	prop += "}";
+	return prop;
+}
+/** the generated type table as a Markdown table, for source-based Markdown output */
+function docToMarkdown(doc) {
+	const rows = [[
+		"Prop",
+		"Type",
+		"Description"
+	]];
+	for (const entry of doc.entries) {
+		const tags = parseTags(entry.tags);
+		let description = entry.description.replace(/{@link (?<link>[^}]*)}/g, "$1").trim();
+		if (tags.default) description += `${description ? " " : ""}Default: \`${tags.default}\``;
+		if (entry.deprecated) description = `**Deprecated.** ${description}`;
+		rows.push([
+			`\`${entry.name}${entry.required ? "" : "?"}\``,
+			`\`${entry.simplifiedType}\``,
+			description
+		]);
+	}
+	let out = `### ${doc.name}\n\n`;
+	if (doc.description) out += `${doc.description.trim()}\n\n`;
+	return out + formatTable(rows);
+}
+function remarkAutoTypeTable(config = {}) {
+	const { name = "auto-type-table", outputName = "TypeTable", options: generateOptions = {}, generator = createGenerator(), renderMarkdown: renderMarkdownOption, renderType: renderTypeOption, shiki } = config;
+	const renderType = renderTypeOption ?? (async (type) => {
+		return {
+			type: "element",
+			tagName: "span",
+			properties: { class: "shiki" },
+			children: [{
+				type: "element",
+				tagName: "code",
+				properties: {},
+				children: (await highlightHast(type, {
+					lang: "ts",
+					structure: "inline",
+					defaultColor: false,
+					...shiki
+				})).children
+			}]
+		};
+	});
+	const renderMarkdown = renderMarkdownOption ?? ((md) => {
+		md = md.replace(/{@link (?<link>[^}]*)}/g, "$1");
+		return sanitizeHast(markdownToHast(md, { features: { gfm: true } }));
+	});
+	return defineMdastPlugin({
+		name: "remark-auto-type-table",
+		async mdxJsxFlowElement(node, ctx) {
+			if (node.name !== name) return;
+			const props = {};
+			const attributes = [];
+			for (const attr of node.attributes) {
+				if (attr.type !== "mdxJsxAttribute") {
+					attributes.push(attr);
+					continue;
+				}
+				switch (attr.name) {
+					case "cwd":
+						props.cwd = true;
+						break;
+					case "path":
+					case "name":
+					case "type":
+						if (typeof attr.value === "string") props[attr.name] = attr.value;
+						break;
+					default: attributes.push(attr);
+				}
+			}
+			const filePath = ctx.fileURL ? fileURLToPath(ctx.fileURL) : void 0;
+			let basePath = props.cwd ? ctx.data._cwd : generateOptions.basePath;
+			if (filePath) basePath ??= path.dirname(filePath);
+			const output = await generator.generateTypeTable(props, {
+				...generateOptions,
+				basePath
+			});
+			const children = [];
+			for (const doc of output) children.push({
+				type: "mdxJsxFlowElement",
+				name: outputName,
+				attributes: [
+					{
+						type: "mdxJsxAttribute",
+						name: "id",
+						value: `type-table-${doc.id}`
+					},
+					{
+						type: "mdxJsxAttribute",
+						name: "type",
+						value: {
+							type: "mdxJsxAttributeValueExpression",
+							value: await buildTypeProp(doc.entries, renderType, renderMarkdown)
+						}
+					},
+					...attributes
+				],
+				children: []
+			});
+			const parent = ctx.parent(node);
+			const index = ctx.indexOf(node);
+			if (!parent || index === void 0) return;
+			replaceSource(ctx, node, () => {
+				let markdown = "";
+				for (const doc of output) {
+					if (markdown) markdown += "\n";
+					markdown += docToMarkdown(doc);
+				}
+				return markdown;
+			});
+			if (children.length === 0) ctx.removeNode(node);
+			else if (children.length === 1) ctx.replaceNode(node, children[0]);
+			else {
+				ctx.replaceNode(node, children[0]);
+				ctx.insertChildAt(parent, index + 1, children.slice(1));
+			}
+		}
+	});
+}
+//#endregion
+export { remarkAutoTypeTable };

package/dist/remark-block-id.d.ts

@@ -0,0 +1,18 @@
+import { MdastNode, MdastVisitorContext } from "satteri";
+//#region src/remark-block-id.d.ts
+interface RemarkBlockIdOptions {
+  generateId?: (ctx: {
+    node: MdastNode;
+    text: string;
+  }) => string;
+  shouldGenerate?: (node: MdastNode) => boolean | 'skip';
+  addDataAttribute?: string | null;
+}
+declare function remarkBlockId({ generateId, addDataAttribute, shouldGenerate }?: RemarkBlockIdOptions): () => {
+  name: string;
+  paragraph: (node: MdastNode, ctx: MdastVisitorContext) => void;
+  image: (node: MdastNode, ctx: MdastVisitorContext) => void;
+  listItem: (node: MdastNode, ctx: MdastVisitorContext) => void;
+};
+//#endregion
+export { RemarkBlockIdOptions, remarkBlockId };

package/dist/remark-block-id.js

@@ -0,0 +1,46 @@
+import Slugger from "github-slugger";
+import { defineMdastPlugin } from "satteri";
+import { createHash } from "node:crypto";
+//#region src/remark-block-id.ts
+function remarkBlockId({ generateId, addDataAttribute = "default", shouldGenerate = (node) => {
+	switch (node.type) {
+		case "mdxJsxFlowElement": return "skip";
+		case "paragraph":
+		case "image":
+		case "listItem": return true;
+		default: return false;
+	}
+} } = {}) {
+	return () => {
+		const slugger = new Slugger();
+		function visit(node, ctx) {
+			const existing = node.data;
+			if (existing?.hProperties?.id) return;
+			const resolved = shouldGenerate(node);
+			if (resolved === false || resolved === "skip") return;
+			const text = ctx.textContent(node, { includeImageAlt: false }).trim();
+			if (text.length === 0) return;
+			const id = generateId ? slugger.slug(generateId({
+				node,
+				text
+			})) : slugger.slug(createHash("sha256").update(text).digest("base64url"));
+			const hProperties = {
+				...existing?.hProperties,
+				id
+			};
+			if (addDataAttribute) hProperties["data-block"] = addDataAttribute;
+			ctx.setProperty(node, "data", {
+				...existing,
+				hProperties
+			});
+		}
+		return defineMdastPlugin({
+			name: "remark-block-id",
+			paragraph: visit,
+			image: visit,
+			listItem: visit
+		});
+	};
+}
+//#endregion
+export { remarkBlockId };

package/dist/remark-code-tab-BYruQJUs.d.ts

@@ -0,0 +1,15 @@
+import { MdastVisitorContext } from "satteri";
+import { Code, Root } from "mdast";
+//#region src/remark-code-tab.d.ts
+type TabType = 'CodeBlockTabs' | 'Tabs';
+interface RemarkCodeTabOptions {
+  Tabs?: TabType;
+  parseMdx?: boolean;
+}
+declare function remarkCodeTab({ parseMdx, Tabs }?: RemarkCodeTabOptions): () => {
+  name: string;
+  code(node: Readonly<Code>, ctx: MdastVisitorContext): undefined;
+  after(_root: Readonly<Root>, ctx: MdastVisitorContext): void;
+};
+//#endregion
+export { remarkCodeTab as n, RemarkCodeTabOptions as t };

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

@@ -0,0 +1,2 @@
+import { n as remarkCodeTab, t as RemarkCodeTabOptions } from "./remark-code-tab-BYruQJUs.js";
+export { RemarkCodeTabOptions, remarkCodeTab };