@ubean/markdown 0.1.13 → 0.2.0

package/dist/src-B81snjFd.js

@@ -0,0 +1,388 @@
+import { createMarkdownExit } from "markdown-exit";
+//#region src/mdx.ts
+/**
+* P9-20: MDX real compilation.
+*
+* Compiles MDX (Markdown + JSX) files to Vue components using `@mdx-js/mdx`
+* as an optional peer dependency. The compiled output uses ubean's Vue JSX
+* runtime (`@ubean/markdown/jsx-runtime`) which maps JSX calls to Vue's `h()`.
+*
+* Features:
+* - Frontmatter extraction (YAML)
+* - JSX component support in Markdown
+* - Vue component imports
+* - Code highlighting via remark/rehype plugins
+* - Graceful fallback to plain Markdown when `@mdx-js/mdx` is not installed
+*
+* Usage:
+* ```typescript
+* import { compileMdx } from '@ubean/markdown/mdx';
+*
+* const result = await compileMdx(mdxSource, {
+*   filePath: 'post.mdx',
+*   remarkPlugins: [remarkGfm],
+* });
+* // result.code → JavaScript module string (Vue component)
+* // result.frontmatter → parsed frontmatter
+* ```
+*/
+let _mdxCompiler;
+/**
+* Dynamically load `@mdx-js/mdx` (optional peer dependency).
+* Returns null if not installed.
+*/
+async function getMdxCompiler() {
+	if (_mdxCompiler !== void 0) return _mdxCompiler;
+	try {
+		const mod = await import("@mdx-js/mdx");
+		_mdxCompiler = mod.compile || mod.default || null;
+	} catch {
+		_mdxCompiler = null;
+	}
+	return _mdxCompiler;
+}
+/**
+* Check if `@mdx-js/mdx` is available for real MDX compilation.
+*/
+async function isMdxAvailable() {
+	return await getMdxCompiler() !== null;
+}
+/**
+* Compile MDX source to a Vue component JavaScript module.
+*
+* Uses `@mdx-js/mdx` to compile the MDX body to a JS module that imports
+* from `@ubean/markdown/jsx-runtime` (which maps to Vue's `h()` function).
+*
+* If `@mdx-js/mdx` is not installed, falls back to plain markdown rendering
+* using `markdown-exit`, wrapping the HTML output in a Vue component.
+*
+* @param source Raw MDX source string (with optional frontmatter)
+* @param options Compilation options
+* @returns Compilation result with code, frontmatter, and compiled flag
+*/
+async function compileMdx(source, options = {}) {
+	const { data: frontmatter, content } = parseFrontmatter(source);
+	const compiler = await getMdxCompiler();
+	if (compiler) {
+		const compiled = await compiler(options.filePath ? {
+			path: options.filePath,
+			value: content
+		} : content, {
+			format: "mdx",
+			jsxImportSource: "@ubean/markdown",
+			development: options.development ?? false,
+			remarkPlugins: options.remarkPlugins || [],
+			rehypePlugins: options.rehypePlugins || []
+		});
+		return {
+			code: String(compiled),
+			frontmatter,
+			compiled: true
+		};
+	}
+	const { markdownToHtml } = await import("./index.js");
+	const html = markdownToHtml(content);
+	return {
+		code: generateFallbackComponent(JSON.stringify(html), frontmatter),
+		frontmatter,
+		compiled: false
+	};
+}
+/**
+* Generate a fallback Vue component when `@mdx-js/mdx` is not available.
+* Renders the markdown HTML using `v-html`.
+*/
+function generateFallbackComponent(htmlJson, frontmatter) {
+	return `// Auto-generated by @ubean/markdown (fallback mode — @mdx-js/mdx not installed)
+import { defineComponent, h } from 'vue';
+${Object.keys(frontmatter).length > 0 ? `export const frontmatter = ${JSON.stringify(frontmatter)};` : "export const frontmatter = {};"}
+export default defineComponent({
+  name: 'MdxPage',
+  setup() {
+    return () => h('div', { class: 'ubean-mdx-content', innerHTML: ${htmlJson} });
+  }
+});
+`;
+}
+/**
+* Synchronously check if MDX compilation is available (without dynamic import).
+* Uses the cached result from a previous `compileMdx()` or `isMdxAvailable()` call.
+*/
+function isMdxAvailableSync() {
+	return _mdxCompiler !== void 0 && _mdxCompiler !== null;
+}
+//#endregion
+//#region src/vite-plugin.ts
+const DEFAULT_INCLUDE = /\.mdx$/;
+function ubeanMdxPlugin(options = {}) {
+	const include = options.include || DEFAULT_INCLUDE;
+	return {
+		name: "ubean:mdx",
+		enforce: "pre",
+		async transform(code, id) {
+			if (!include.test(id)) return null;
+			if (options.exclude && options.exclude.test(id)) return null;
+			try {
+				return {
+					code: (await compileMdx(code, {
+						filePath: id,
+						remarkPlugins: options.remarkPlugins,
+						rehypePlugins: options.rehypePlugins
+					})).code,
+					map: {
+						mappings: "",
+						version: 3,
+						sources: [],
+						names: [],
+						file: id
+					}
+				};
+			} catch (err) {
+				this.error(`[ubean:mdx] Failed to compile ${id}: ${err.message}`);
+				return null;
+			}
+		},
+		handleHotUpdate(ctx) {
+			if (!include.test(ctx.file)) return;
+			ctx.server.ws.send({ type: "full-reload" });
+			return [];
+		}
+	};
+}
+//#endregion
+//#region src/index.ts
+const FRONTMATTER_REGEX = /^---\s*\n([\s\S]*?)\n---\s*\n?/;
+function parseFrontmatter(source) {
+	const match = source.match(FRONTMATTER_REGEX);
+	if (!match) return {
+		data: {},
+		content: source
+	};
+	const raw = match[1];
+	const content = source.slice(match[0].length);
+	return {
+		data: parseYamlSimple(raw),
+		content
+	};
+}
+function tokenizeYaml(yaml) {
+	const lines = [];
+	for (const raw of yaml.split("\n")) {
+		const trimmed = raw.trimEnd();
+		if (!trimmed.trim() || trimmed.trimStart().startsWith("#")) continue;
+		let indent = 0;
+		while (indent < trimmed.length && trimmed[indent] === " ") indent++;
+		lines.push({
+			indent,
+			content: trimmed.trim()
+		});
+	}
+	return lines;
+}
+function parseYamlScalar(raw) {
+	if (raw === "true" || raw === "false") return raw === "true";
+	if (raw === "null" || raw === "~") return null;
+	if (raw !== "" && !isNaN(Number(raw))) {
+		const num = Number(raw);
+		if (isFinite(num)) return num;
+	}
+	if (raw.startsWith("\"") && raw.endsWith("\"") || raw.startsWith("'") && raw.endsWith("'")) return raw.slice(1, -1);
+	if (raw.startsWith("[") && raw.endsWith("]")) return raw.slice(1, -1).split(",").map((v) => v.trim()).filter((v) => v !== "").map((v) => {
+		if (v === "true") return true;
+		if (v === "false") return false;
+		if (v === "null") return null;
+		if (!isNaN(Number(v))) return Number(v);
+		return v.replace(/^["']|["']$/g, "");
+	});
+	return raw;
+}
+function isSequenceItem(content) {
+	return content === "-" || content.startsWith("- ");
+}
+/** `- key: value` starts an inline map item (continuation keys align after the dash). */
+function isInlineMapStart(rest) {
+	const colonIdx = rest.indexOf(":");
+	return colonIdx > 0 && (rest.length === colonIdx + 1 || rest[colonIdx + 1] === " ");
+}
+function assignYamlKey(map, key, value) {
+	const nestedKeys = key.split(".");
+	let current = map;
+	for (let i = 0; i < nestedKeys.length - 1; i++) {
+		const k = nestedKeys[i];
+		if (typeof current[k] !== "object" || current[k] === null) current[k] = {};
+		current = current[k];
+	}
+	current[nestedKeys[nestedKeys.length - 1]] = value;
+}
+function parseYamlBlock(lines, start, indent) {
+	const first = lines[start];
+	if (isSequenceItem(first.content)) {
+		const items = [];
+		let i = start;
+		while (i < lines.length && lines[i].indent === indent && isSequenceItem(lines[i].content)) {
+			const rest = lines[i].content === "-" ? "" : lines[i].content.slice(2).trim();
+			if (rest === "") {
+				if (i + 1 < lines.length && lines[i + 1].indent > indent) {
+					const res = parseYamlBlock(lines, i + 1, lines[i + 1].indent);
+					items.push(res.value);
+					i = res.next;
+				} else {
+					items.push(null);
+					i += 1;
+				}
+			} else if (isInlineMapStart(rest)) {
+				const synthesized = [{
+					indent: indent + 2,
+					content: rest
+				}];
+				let j = i + 1;
+				while (j < lines.length && lines[j].indent > indent) {
+					synthesized.push(lines[j]);
+					j += 1;
+				}
+				const res = parseYamlBlock(synthesized, 0, indent + 2);
+				items.push(res.value);
+				i = j;
+			} else {
+				items.push(parseYamlScalar(rest));
+				i += 1;
+			}
+		}
+		return {
+			value: items,
+			next: i
+		};
+	}
+	const map = {};
+	let i = start;
+	while (i < lines.length && lines[i].indent === indent && !isSequenceItem(lines[i].content)) {
+		const colonIdx = lines[i].content.indexOf(":");
+		if (colonIdx === -1) {
+			i += 1;
+			continue;
+		}
+		const key = lines[i].content.slice(0, colonIdx).trim();
+		const rawValue = lines[i].content.slice(colonIdx + 1).trim();
+		if (!key) {
+			i += 1;
+			continue;
+		}
+		if (rawValue === "") {
+			if (i + 1 < lines.length && lines[i + 1].indent > indent) {
+				const res = parseYamlBlock(lines, i + 1, lines[i + 1].indent);
+				assignYamlKey(map, key, res.value);
+				i = res.next;
+			} else {
+				assignYamlKey(map, key, true);
+				i += 1;
+			}
+		} else {
+			assignYamlKey(map, key, parseYamlScalar(rawValue));
+			i += 1;
+		}
+	}
+	return {
+		value: map,
+		next: i
+	};
+}
+function parseYamlSimple(yaml) {
+	const lines = tokenizeYaml(yaml);
+	if (lines.length === 0) return {};
+	const { value } = parseYamlBlock(lines, 0, lines[0].indent);
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+	return value;
+}
+function slugify(text) {
+	return text.toLowerCase().replace(/<[^>]*>/g, "").replace(/[^\w\s\u4e00-\u9fa5-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function applyHeadingIds(md) {
+	const headingOpenRule = md.renderer.rules.heading_open;
+	md.renderer.rules.heading_open = (tokens, idx, options, env, self) => {
+		const token = tokens[idx];
+		const nextToken = tokens[idx + 1];
+		if (nextToken && nextToken.type === "inline") {
+			const text = nextToken.children?.filter((t) => t.type === "text" || t.type === "code_inline").map((t) => t.content).join("") || "";
+			token.attrSet("id", slugify(text));
+		}
+		if (headingOpenRule) return headingOpenRule(tokens, idx, options, env, self);
+		return self.renderToken(tokens, idx, options);
+	};
+}
+function createInstance(options) {
+	const md = createMarkdownExit({
+		html: options.html ?? false,
+		linkify: options.linkify ?? true,
+		breaks: options.breaks ?? false,
+		typographer: options.typographer ?? false,
+		highlight: options.highlighter ? (str, lang) => {
+			const result = options.highlighter(str.trimEnd(), lang);
+			if (result.startsWith("<pre")) return result;
+			return `<pre><code class="language-${lang}">${result}</code></pre>`;
+		} : void 0
+	});
+	if (options.headingIds !== false) applyHeadingIds(md);
+	return md;
+}
+function markdownToHtml(markdown, options = {}) {
+	return createInstance(options).render(markdown).trim();
+}
+function extractHeadings(markdown) {
+	const headings = [];
+	const tokens = createMarkdownExit({ html: false }).parse(markdown, {});
+	function walkTokenList(tokenList) {
+		for (let i = 0; i < tokenList.length; i++) {
+			const token = tokenList[i];
+			if (token.type === "heading_open") {
+				const level = parseInt(token.tag.slice(1), 10);
+				const inlineToken = tokenList[i + 1];
+				if (inlineToken && inlineToken.type === "inline") {
+					const text = extractTextFromTokens(inlineToken.children || []);
+					headings.push({
+						level,
+						text,
+						id: slugify(text)
+					});
+				}
+			}
+			if (token.children) walkTokenList(token.children);
+		}
+	}
+	walkTokenList(tokens);
+	return headings;
+}
+function extractTextFromTokens(tokens) {
+	let text = "";
+	for (const token of tokens) if (token.type === "text" || token.type === "code_inline") text += token.content;
+	else if (token.children) text += extractTextFromTokens(token.children);
+	return text;
+}
+function extractExcerpt(markdown, separator = "<!-- more -->") {
+	const idx = markdown.indexOf(separator);
+	if (idx !== -1) return markdown.slice(0, idx).trim();
+	const paragraphs = markdown.split("\n\n").filter((p) => p.trim() !== "");
+	for (const para of paragraphs) {
+		const trimmed = para.trim();
+		if (trimmed.startsWith("#")) continue;
+		if (trimmed.startsWith("```")) continue;
+		if (trimmed.startsWith(">")) continue;
+		if (trimmed.startsWith("- ") || trimmed.startsWith("* ") || /^\d+\.\s/.test(trimmed)) continue;
+		if (trimmed.length < 500) return trimmed;
+	}
+}
+function parseMarkdown(source, options = {}) {
+	const { data: frontmatter, content } = parseFrontmatter(source);
+	const headings = extractHeadings(content);
+	return {
+		frontmatter,
+		content,
+		excerpt: options.excerpt !== false ? extractExcerpt(content, options.excerptSeparator) : void 0,
+		headings,
+		html: markdownToHtml(content, options)
+	};
+}
+function defineMarkdownPage(frontmatter) {
+	return frontmatter;
+}
+//#endregion
+export { parseFrontmatter as a, compileMdx as c, markdownToHtml as i, isMdxAvailable as l, extractExcerpt as n, parseMarkdown as o, extractHeadings as r, ubeanMdxPlugin as s, defineMarkdownPage as t, isMdxAvailableSync as u };