@vx-oss/docs-satteri 1.0.3

package/dist/remark-steps.d.ts

@@ -0,0 +1,14 @@
+import { MdastVisitorContext } from "satteri";
+import { Heading } from "mdast";
+//#region src/remark-steps.d.ts
+interface RemarkStepsOptions {
+  steps?: string;
+  step?: string;
+}
+declare function remarkSteps({ steps, step }?: RemarkStepsOptions): () => {
+  name: string;
+  heading(node: Readonly<Heading>, ctx: MdastVisitorContext): undefined;
+  after(_root: Readonly<import("mdast").Root>, ctx: MdastVisitorContext): void;
+};
+//#endregion
+export { RemarkStepsOptions, remarkSteps };

package/dist/remark-steps.js

@@ -0,0 +1,127 @@
+import { n as handleTag } from "./utils-I3DkmAkd.js";
+import { defineMdastPlugin } from "satteri";
+//#region src/remark-steps.ts
+const StepRegex = /^(\d+)\.\s(.+)$/;
+const StepTag = "[step]";
+function remarkSteps({ steps = "fd-steps", step = "fd-step" } = {}) {
+	function convertToSteps(nodes) {
+		const depth = nodes[0].depth;
+		const children = [];
+		for (const node of nodes) if (node.type === "heading" && node.depth === depth) children.push({
+			type: "mdxJsxFlowElement",
+			name: "div",
+			attributes: [{
+				type: "mdxJsxAttribute",
+				name: "className",
+				value: step
+			}],
+			children: [node]
+		});
+		else children[children.length - 1].children.push(node);
+		return {
+			type: "mdxJsxFlowElement",
+			name: "div",
+			attributes: [{
+				type: "mdxJsxAttribute",
+				name: "className",
+				value: steps
+			}],
+			children
+		};
+	}
+	function handleHeadingStep(node) {
+		const head = node.children[0];
+		if (head?.type === "text") {
+			const match = StepRegex.exec(head.value);
+			if (match) {
+				const newChildren = [...node.children];
+				newChildren[0] = {
+					...head,
+					value: match[2]
+				};
+				return {
+					...node,
+					children: newChildren
+				};
+			}
+		}
+		const tail = node.children[node.children.length - 1];
+		if (tail?.type === "text") {
+			const stepValue = handleTag(tail.value, StepTag);
+			if (stepValue !== false) {
+				const newChildren = [...node.children];
+				newChildren[newChildren.length - 1] = {
+					...tail,
+					value: stepValue
+				};
+				return {
+					...node,
+					children: newChildren
+				};
+			}
+		}
+		return false;
+	}
+	function processChildren(parent, ctx) {
+		const output = [...parent.children];
+		let startIdx = -1;
+		let i = 0;
+		let currentStep = 1;
+		let changed = false;
+		const onEnd = () => {
+			if (startIdx === -1) return;
+			const nodes = output.splice(startIdx, i - startIdx);
+			output.splice(startIdx, 0, convertToSteps(nodes));
+			changed = true;
+			i = startIdx + 1;
+			startIdx = -1;
+			currentStep = 1;
+		};
+		for (; i < output.length; i++) {
+			const node = output[i];
+			if (node.type !== "heading") continue;
+			if ((node.data ?? {}).hProperties?.["data-fd-step"] !== void 0) continue;
+			if (startIdx !== -1) {
+				const startDepth = output[startIdx].depth;
+				if (node.depth !== startDepth) {
+					if (node.depth < startDepth) onEnd();
+					continue;
+				}
+			}
+			const stepped = handleHeadingStep(node);
+			if (!stepped) {
+				onEnd();
+				continue;
+			}
+			const steppedData = stepped.data ?? {};
+			output[i] = {
+				...stepped,
+				data: {
+					...steppedData,
+					hProperties: {
+						...steppedData.hProperties,
+						"data-fd-step": currentStep++
+					}
+				}
+			};
+			if (startIdx === -1) startIdx = i;
+		}
+		onEnd();
+		if (changed) ctx.setProperty(parent, "children", output);
+	}
+	return () => {
+		const parents = /* @__PURE__ */ new Set();
+		return defineMdastPlugin({
+			name: "remark-steps",
+			heading(node, ctx) {
+				const parent = ctx.parent(node);
+				if (parent && "children" in parent) parents.add(parent);
+			},
+			after(_root, ctx) {
+				for (const parent of parents) processChildren(parent, ctx);
+			}
+		});
+	};
+}
+//#endregion
+export { remarkSteps };

package/dist/remark-structure.d.ts

@@ -0,0 +1,29 @@
+import { o as ExtraPluginHooks } from "./compile-SBpZsgmI.js";
+import { MdastPluginDefinition } from "satteri";
+import { StructuredData } from "@vx-oss/docs-core/mdx-plugins/remark-structure";
+import { Nodes } from "mdast";
+//#region src/remark-structure.d.ts
+interface StructureOptions {
+  types?: string[] | ((node: Nodes) => boolean);
+  mdxTypes?: (node: Nodes) => boolean;
+  /**
+   * Include Markdown syntax in content records, sliced from the authored source.
+   *
+   * Links and JSX elements are flattened into their plain text, return `true` from
+   * `filterElement` to keep an element's syntax instead.
+   */
+  stringify?: boolean | {
+    filterElement?: (node: Nodes & {
+      name?: string | null;
+    }) => boolean;
+  };
+  /**
+   * export as `structuredData` (if true) or specified variable name.
+   *
+   * @default true
+   */
+  exportAs?: string | boolean;
+}
+declare function remarkStructure({ types, mdxTypes, stringify, exportAs }?: StructureOptions): ExtraPluginHooks & (() => MdastPluginDefinition);
+//#endregion
+export { StructureOptions, type StructuredData, remarkStructure };

package/dist/remark-structure.js

@@ -0,0 +1,94 @@
+import { t as createStringifier } from "./stringifier-COIWcXys.js";
+//#region src/remark-structure.ts
+const STRUCTURE_VISITORS = [
+	"heading",
+	"paragraph",
+	"blockquote",
+	"tableCell",
+	"mdxJsxFlowElement"
+];
+function remarkStructure({ types = [
+	"heading",
+	"paragraph",
+	"blockquote",
+	"tableCell",
+	"mdxJsxFlowElement"
+], mdxTypes = (node) => !("children" in node) || node.children.length === 0, stringify = false, exportAs = true } = {}) {
+	const matchType = typeof types === "function" ? types : (node) => types.includes(node.type);
+	const filterElement = typeof stringify === "object" ? stringify.filterElement : void 0;
+	const plugin = () => {
+		const data = {
+			contents: [],
+			headings: []
+		};
+		const records = [];
+		let lastHeading;
+		let s;
+		function visit(node) {
+			if (stringify && (node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement")) {
+				if (!filterElement?.(node)) s.flatten(node);
+			}
+			if (!matchType(node)) return;
+			if ((node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") && !mdxTypes(node)) return;
+			if (node.type === "heading") {
+				const id = node.data?.hProperties?.id;
+				if (!id) return;
+				records.push({
+					node,
+					heading: void 0,
+					id
+				});
+				lastHeading = id;
+				return;
+			}
+			records.push({
+				node,
+				heading: lastHeading
+			});
+		}
+		const definition = {
+			name: "remark-structure",
+			options: stringify ? { position: true } : void 0,
+			before(_root, ctx) {
+				ctx.data.structuredData ??= data;
+				s = createStringifier(ctx);
+				const openapiData = ctx.data.frontmatter?._openapi?.structuredData;
+				if (openapiData) {
+					data.headings.push(...openapiData.headings);
+					data.contents.push(...openapiData.contents);
+				}
+			},
+			after(_root, ctx) {
+				for (const record of records) {
+					const content = (stringify && !record.id ? s.stringify(record.node) : ctx.textContent(record.node)).trim();
+					if (content.length === 0) continue;
+					if (record.id) data.headings.push({
+						id: record.id,
+						content
+					});
+					else data.contents.push({
+						heading: record.heading,
+						content
+					});
+				}
+			},
+			...Object.fromEntries(STRUCTURE_VISITORS.map((key) => [key, visit]))
+		};
+		if (stringify) Object.assign(definition, {
+			mdxJsxTextElement: visit,
+			link: (node) => s.flatten(node),
+			linkReference: (node) => s.flatten(node),
+			image: (node) => s.remove(node)
+		});
+		return definition;
+	};
+	plugin.collectExports = ({ data, addExport }) => {
+		if (exportAs) addExport(typeof exportAs === "string" ? exportAs : "structuredData", JSON.stringify(data.structuredData ?? {
+			headings: [],
+			contents: []
+		}));
+	};
+	return plugin;
+}
+//#endregion
+export { remarkStructure };

package/dist/remark-ts2js.d.ts

@@ -0,0 +1,25 @@
+//#region src/remark-ts2js.d.ts
+interface RemarkTs2jsOptions {
+  /**
+   * Persist Tab value (Fumadocs UI only)
+   *
+   * @defaultValue false
+   */
+  persist?: {
+    id: string;
+  } | false;
+  defaultValue?: 'js' | 'ts';
+  /**
+   * Transform all TypeScript codeblocks by default, without a trigger
+   */
+  disableTrigger?: boolean;
+}
+/**
+ * Transform TypeScript codeblocks into TS/JS tabs. Add `ts2js` to the code fence meta to enable.
+ */
+declare function remarkTs2js({ persist, defaultValue, disableTrigger }?: RemarkTs2jsOptions): {
+  name: string;
+  code(node: Readonly<import("mdast").Code>, ctx: import("satteri").MdastVisitorContext): Promise<undefined>;
+};
+//#endregion
+export { RemarkTs2jsOptions, remarkTs2js };

package/dist/remark-ts2js.js

@@ -0,0 +1,56 @@
+import { defineMdastPlugin } from "satteri";
+import { generateCodeBlockTabs, parseCodeBlockAttributes } from "@vx-oss/docs-core/mdx-plugins/codeblock-utils";
+//#region src/remark-ts2js.ts
+/**
+* Transform TypeScript codeblocks into TS/JS tabs. Add `ts2js` to the code fence meta to enable.
+*/
+function remarkTs2js({ persist = false, defaultValue = "ts", disableTrigger = false } = {}) {
+	return defineMdastPlugin({
+		name: "remark-typescript-to-javascript",
+		async code(node, ctx) {
+			const lang = node.lang;
+			if (lang !== "ts" && lang !== "tsx") return;
+			const meta = parseCodeBlockAttributes(node.meta ?? "", ["ts2js"]);
+			if (!disableTrigger && !("ts2js" in meta.attributes)) return;
+			const [{ parse }, { strip }] = await Promise.all([import("yuku-parser"), import("yuku-codegen")]);
+			const { program } = parse(node.value, { lang });
+			const result = strip(program);
+			ctx.replaceNode(node, generateCodeBlockTabs({
+				persist,
+				defaultValue,
+				triggers: [{
+					value: "ts",
+					children: [{
+						type: "text",
+						value: "TypeScript"
+					}]
+				}, {
+					value: "js",
+					children: [{
+						type: "text",
+						value: "JavaScript"
+					}]
+				}],
+				tabs: [{
+					value: "ts",
+					children: [{
+						type: "code",
+						lang: node.lang,
+						meta: meta.rest,
+						value: node.value
+					}]
+				}, {
+					value: "js",
+					children: [{
+						type: "code",
+						lang: lang === "tsx" ? "jsx" : "js",
+						meta: typeof meta.attributes.ts2js === "string" ? meta.attributes.ts2js : meta.rest,
+						value: result.code
+					}]
+				}]
+			}));
+		}
+	});
+}
+//#endregion
+export { remarkTs2js };

package/dist/renderer-BtFWPZB8.js

@@ -0,0 +1,54 @@
+import { asMarkdown, jsxComponents } from "@vx-oss/docs-core/server";
+import * as JsxRuntime from "react/jsx-runtime";
+//#region src/local-md/renderer.ts
+const AsyncFunction = Object.getPrototypeOf(async function() {}).constructor;
+function fromJS(options) {
+	const { code, structuredData = {
+		headings: [],
+		contents: []
+	}, baseUrl } = options;
+	function createScope(context) {
+		const { opts, ...rest } = context ?? {};
+		return {
+			opts: {
+				...opts,
+				...JsxRuntime,
+				asMarkdown,
+				jsxComponents,
+				baseUrl
+			},
+			...rest
+		};
+	}
+	function toResult(out, components) {
+		return {
+			toc: out.toc ?? [],
+			body: JsxRuntime.jsx(out.default, { components }),
+			exports: out
+		};
+	}
+	return {
+		structuredData,
+		async render(components, context) {
+			const scope = createScope(context);
+			const hydrateFn = new AsyncFunction(...Object.keys(scope), code);
+			return toResult(await hydrateFn.apply(hydrateFn, Object.values(scope)), components);
+		},
+		renderSync(components, context) {
+			const scope = createScope(context);
+			const hydrateFn = new Function(...Object.keys(scope), code);
+			return toResult(hydrateFn.apply(hydrateFn, Object.values(scope)), components);
+		},
+		serialize() {
+			return {
+				type: "js",
+				...options
+			};
+		}
+	};
+}
+function fromSerialized(options) {
+	return fromJS(options);
+}
+//#endregion
+export { fromSerialized as n, fromJS as t };

package/dist/renderer-E5KzV19n.d.ts

@@ -0,0 +1,30 @@
+import { StructuredData } from "@vx-oss/docs-core/mdx-plugins/remark-structure";
+import { TOCItemType } from "@vx-oss/docs-core/toc";
+import { ReactNode } from "react";
+import { MDXComponents } from "mdx/types";
+//#region src/local-md/renderer.d.ts
+interface MarkdownRenderer<M = Record<string, unknown>> {
+  structuredData: StructuredData;
+  render: (components?: MDXComponents, context?: Record<string, unknown>) => Promise<MarkdownRendererResult<M>>;
+  renderSync: (components?: MDXComponents, context?: Record<string, unknown>) => MarkdownRendererResult<M>;
+  /** JSON-serializable, rebuild it on the client with {@link fromSerialized} */
+  serialize: () => MarkdownRendererSerializedOptions;
+}
+interface MarkdownRendererResult<M = Record<string, unknown>> {
+  exports: M;
+  toc: TOCItemType[];
+  body: ReactNode;
+}
+type MarkdownRendererSerializedOptions = {
+  type: 'js';
+} & MarkdownRendererJSOptions;
+interface MarkdownRendererJSOptions {
+  /** compiled `function-body` JavaScript. */
+  code: string;
+  filePath: string;
+  baseUrl?: string;
+  structuredData?: StructuredData;
+}
+declare function fromSerialized<M>(options: MarkdownRendererSerializedOptions): MarkdownRenderer<M>;
+//#endregion
+export { fromSerialized as i, MarkdownRendererResult as n, MarkdownRendererSerializedOptions as r, MarkdownRenderer as t };

package/dist/stringifier-COIWcXys.js

@@ -0,0 +1,130 @@
+//#region src/stringifier.ts
+function offsets(node) {
+	const pos = node.position;
+	if (pos?.start.offset !== void 0 && pos.end.offset !== void 0) return {
+		start: pos.start.offset,
+		end: pos.end.offset
+	};
+}
+/**
+* Record the Markdown form of generated content over an authored node's source range,
+* for plugins that replace nodes (e.g. includes, generated type tables). Source-based
+* Markdown output cannot see the replacement, it shows this text instead.
+*
+* `markdown` is only called when source positions are tracked, i.e. when a consumer
+* of the recorded edits is present.
+*/
+function replaceSource(ctx, node, markdown) {
+	const pos = offsets(node);
+	if (pos) (ctx.data._sourceEdits ??= []).push({
+		start: pos.start,
+		end: pos.end,
+		text: markdown()
+	});
+}
+/**
+* Rows as an aligned Markdown table, the first row being the header.
+* Newlines in cells are collapsed and `|` is escaped.
+*/
+function formatTable(rows) {
+	const cells = [];
+	const widths = [];
+	for (const row of rows) {
+		const escaped = [];
+		for (let i = 0; i < row.length; i++) {
+			const text = row[i].replace(/\s*\n\s*/g, " ").replaceAll("|", "\\|");
+			widths[i] = Math.max(widths[i] ?? 0, text.length);
+			escaped.push(text);
+		}
+		cells.push(escaped);
+	}
+	let out = "";
+	for (let r = 0; r < cells.length; r++) {
+		let line = "|";
+		for (let i = 0; i < widths.length; i++) line += ` ${(cells[r][i] ?? "").padEnd(widths[i])} |`;
+		out += `${line}\n`;
+		if (r === 0) {
+			line = "|";
+			for (const width of widths) line += ` ${"-".repeat(width)} |`;
+			out += `${line}\n`;
+		}
+	}
+	return out;
+}
+function createStringifier(ctx) {
+	const source = ctx.source;
+	const own = [];
+	let sorted;
+	function edits() {
+		if (!sorted) {
+			sorted = ctx.data._sourceEdits ? [...ctx.data._sourceEdits, ...own] : [...own];
+			sorted.sort((a, b) => a.start - b.start);
+		}
+		return sorted;
+	}
+	return {
+		source,
+		get edits() {
+			return edits();
+		},
+		edit(start, end, text) {
+			own.push({
+				start,
+				end,
+				text
+			});
+			sorted = void 0;
+		},
+		remove(node) {
+			const pos = offsets(node);
+			if (pos) this.edit(pos.start, pos.end, "");
+		},
+		flatten(node) {
+			const pos = offsets(node);
+			if (pos) this.edit(pos.start, pos.end, ctx.textContent(node));
+		},
+		slice(start, end) {
+			return splice(source, start, end, edits());
+		},
+		stringify(node) {
+			const pos = offsets(node);
+			if (pos) return splice(source, pos.start, pos.end, edits());
+			const { type } = node;
+			if (type === "mdxJsxFlowElement" || type === "mdxJsxTextElement") return syntheticElement(node, ctx);
+			return ctx.textContent(node);
+		}
+	};
+}
+function splice(source, start, end, edits) {
+	let lo = 0;
+	let hi = edits.length;
+	while (lo < hi) {
+		const mid = lo + hi >> 1;
+		if (edits[mid].start < start) lo = mid + 1;
+		else hi = mid;
+	}
+	let out = "";
+	let cursor = start;
+	for (let i = lo; i < edits.length && edits[i].start < end; i++) {
+		const edit = edits[i];
+		if (edit.end > end) continue;
+		out += source.slice(cursor, edit.start) + edit.text;
+		cursor = edit.end;
+		if (edit.text === "") while (source[cursor] === "\n" && (out === "" || out.endsWith("\n\n"))) cursor++;
+	}
+	return out + source.slice(cursor, end);
+}
+/** the tag of a plugin-inserted JSX element, reconstructed from its fields */
+function syntheticElement(node, ctx) {
+	let attrs = "";
+	for (const attr of node.attributes) if (attr.type === "mdxJsxExpressionAttribute") {
+		if (attr.value) attrs += ` {${attr.value}}`;
+	} else if (attr.value == null) attrs += ` ${attr.name}`;
+	else if (typeof attr.value === "string") attrs += ` ${attr.name}="${attr.value}"`;
+	else if (attr.value.value) attrs += ` ${attr.name}={${attr.value.value}}`;
+	const children = ctx.textContent(node);
+	if (!children) return `<${node.name}${attrs} />`;
+	return `<${node.name}${attrs}>${children}</${node.name}>`;
+}
+//#endregion
+export { replaceSource as i, formatTable as n, offsets as r, createStringifier as t };

package/dist/utils-I3DkmAkd.js

@@ -0,0 +1,27 @@
+import { jsx, toJs } from "estree-util-to-js";
+import { toEstree } from "hast-util-to-estree";
+//#region src/utils.ts
+/**
+* Flatten a node's text content by walking it in JavaScript.
+*
+* Prefer `ctx.textContent(node, { includeImageAlt: false })` for nodes of the
+* visited document — it walks the tree in Rust without materializing the
+* subtree. This util is for detached trees (e.g. `mdxToMdast()` output), which
+* have no handle behind them and can't use the visitor context.
+*/
+function flattenNode(node) {
+	if ("children" in node && Array.isArray(node.children)) return node.children.map((child) => flattenNode(child)).join("");
+	if ("value" in node && typeof node.value === "string") return node.value;
+	return "";
+}
+function handleTag(value, tag) {
+	const idx = value.indexOf(tag);
+	if (idx !== -1) return value.slice(0, idx).trimEnd() + value.slice(idx + tag.length);
+	return false;
+}
+function jsxToSource(hast) {
+	const source = toJs(toEstree(hast, { elementAttributeNameCase: "react" }), { handlers: jsx }).value.trim();
+	return source.endsWith(";") ? source.slice(0, -1) : source;
+}
+//#endregion
+export { handleTag as n, jsxToSource as r, flattenNode as t };