@ubean/markdown 0.1.1 → 0.1.3

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+//#region src/index.d.ts
+interface MarkdownFrontmatter {
+  title?: string;
+  description?: string;
+  date?: string;
+  layout?: string | false;
+  path?: string;
+  seo?: Record<string, unknown>;
+  meta?: Record<string, unknown>;
+  head?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+interface ParsedMarkdown {
+  frontmatter: MarkdownFrontmatter;
+  content: string;
+  excerpt?: string;
+  headings: MarkdownHeading[];
+  html?: string;
+}
+interface MarkdownHeading {
+  level: number;
+  text: string;
+  id: string;
+}
+interface MarkdownOptions {
+  html?: boolean;
+  linkify?: boolean;
+  breaks?: boolean;
+  typographer?: boolean;
+  excerpt?: boolean;
+  excerptSeparator?: string;
+  headingIds?: boolean;
+  highlighter?: (code: string, lang: string) => string;
+}
+declare function parseFrontmatter(source: string): {
+  data: MarkdownFrontmatter;
+  content: string;
+};
+declare function markdownToHtml(markdown: string, options?: MarkdownOptions): string;
+declare function extractHeadings(markdown: string): MarkdownHeading[];
+declare function extractExcerpt(markdown: string, separator?: string): string | undefined;
+declare function parseMarkdown(source: string, options?: MarkdownOptions): ParsedMarkdown;
+declare function defineMarkdownPage(frontmatter: MarkdownFrontmatter & Record<string, unknown>): MarkdownFrontmatter & Record<string, unknown>;
+//#endregion
+export { MarkdownFrontmatter, MarkdownHeading, MarkdownOptions, ParsedMarkdown, defineMarkdownPage, extractExcerpt, extractHeadings, markdownToHtml, parseFrontmatter, parseMarkdown };

package/dist/index.js

@@ -0,0 +1,145 @@
+import { createMarkdownExit } from "markdown-exit";
+//#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 parseYamlSimple(yaml) {
+	const result = {};
+	const lines = yaml.split("\n");
+	for (const line of lines) {
+		const trimmed = line.trimEnd();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const colonIdx = trimmed.indexOf(":");
+		if (colonIdx === -1) continue;
+		const key = trimmed.slice(0, colonIdx).trim();
+		let value = trimmed.slice(colonIdx + 1).trim();
+		if (!key) continue;
+		if (value === "") value = true;
+		else if (value === "true" || value === "false") value = value === "true";
+		else if (value === "null" || value === "~") value = null;
+		else if (!isNaN(Number(value)) && value !== "") {
+			const num = Number(value);
+			if (isFinite(num)) value = num;
+		} else if (typeof value === "string" && (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'"))) value = value.slice(1, -1);
+		else if (typeof value === "string" && value.startsWith("[") && value.endsWith("]")) value = value.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, "");
+		});
+		const nestedKeys = key.split(".");
+		let current = result;
+		for (let i = 0; i < nestedKeys.length - 1; i++) {
+			const k = nestedKeys[i];
+			if (!(k in current) || typeof current[k] !== "object") current[k] = {};
+			current = current[k];
+		}
+		current[nestedKeys[nestedKeys.length - 1]] = value;
+	}
+	return result;
+}
+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 { defineMarkdownPage, extractExcerpt, extractHeadings, markdownToHtml, parseFrontmatter, parseMarkdown };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ubean/markdown",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Markdown parsing for ubean (frontmatter, headings, excerpt)",
   "files": [
     "dist"