From cdaab85213610bc158c1c0079477fb46a4e2c5df Mon Sep 17 00:00:00 2001 From: Fuyeor Date: Wed, 14 Oct 2026 04:51:59 +0800 Subject: [PATCH 1/9] refactor: add plugin capability and restructure directory --- fixture/ffm.json | 19 -- package/benchmark/memory.ts | 6 +- package/benchmark/speed.ts | 24 +- package/editor/core/src/parse/bridge.ts | 6 +- package/formatter/src/print/inline.ts | 2 +- package/parser/package.json | 3 +- package/parser/src/core/parser.ts | 38 ++- package/parser/src/core/plain-text.ts | 2 +- package/parser/src/core/render.ts | 136 ++++----- package/parser/src/default.ts | 27 +- package/parser/src/index.spec.ts | 44 +-- package/parser/src/index.ts | 35 +-- package/parser/src/plugin/abc/index.ts | 41 +++ package/parser/src/plugin/abc/type.ts | 22 ++ package/parser/src/plugin/ast.ts | 26 +- package/parser/src/plugin/async-blocks.ts | 89 ------ package/parser/src/plugin/extensions.ts | 32 --- package/parser/src/plugin/highlight.ts | 41 --- package/parser/src/plugin/highlight/index.ts | 59 ++++ package/parser/src/plugin/highlight/type.ts | 27 ++ package/parser/src/plugin/highlight/util.ts | 64 +++++ package/parser/src/plugin/hydrate.ts | 60 ++++ package/parser/src/plugin/index.ts | 26 ++ .../src/plugin/{latex.ts => latex/index.ts} | 28 +- package/parser/src/plugin/latex/type.ts | 21 ++ package/parser/src/plugin/loader.ts | 83 ++++++ package/parser/src/plugin/mermaid/index.ts | 41 +++ package/parser/src/plugin/mermaid/type.ts | 20 ++ package/parser/src/plugin/smiles/index.ts | 81 ++++++ .../plugin/{twemoji.ts => twemoji/index.ts} | 9 +- package/parser/src/rule/inline.ts | 4 +- package/parser/src/test/index.spec.ts | 22 +- package/parser/src/type.ts | 53 +++- package/parser/tsconfig.json | 4 +- package/renderer/lit/src/render.ts | 16 +- package/renderer/vue/src/render.ts | 262 +++++++++++------- playground/src/document/component/preview.vue | 60 +++- 37 files changed, 1034 insertions(+), 499 deletions(-) create mode 100644 package/parser/src/plugin/abc/index.ts create mode 100644 package/parser/src/plugin/abc/type.ts delete mode 100644 package/parser/src/plugin/async-blocks.ts delete mode 100644 package/parser/src/plugin/extensions.ts delete mode 100644 package/parser/src/plugin/highlight.ts create mode 100644 package/parser/src/plugin/highlight/index.ts create mode 100644 package/parser/src/plugin/highlight/type.ts create mode 100644 package/parser/src/plugin/highlight/util.ts create mode 100644 package/parser/src/plugin/hydrate.ts create mode 100644 package/parser/src/plugin/index.ts rename package/parser/src/plugin/{latex.ts => latex/index.ts} (78%) create mode 100644 package/parser/src/plugin/latex/type.ts create mode 100644 package/parser/src/plugin/loader.ts create mode 100644 package/parser/src/plugin/mermaid/index.ts create mode 100644 package/parser/src/plugin/mermaid/type.ts create mode 100644 package/parser/src/plugin/smiles/index.ts rename package/parser/src/plugin/{twemoji.ts => twemoji/index.ts} (89%) diff --git a/fixture/ffm.json b/fixture/ffm.json index 60a544e..2671456 100644 --- a/fixture/ffm.json +++ b/fixture/ffm.json @@ -62,25 +62,6 @@ "html": "

[x](file:///etc/passwd)

", "plain_text": "[x](file:///etc/passwd)" }, - { - "input": "Visit fuyeor.xn--p1ai", - "html": "

Visit fuyeor.рф

", - "assert": [ - { - "path": "/0/content/1/type", - "value": "link" - }, - { - "path": "/0/content/1/url", - "value": "https://fuyeor.рф" - }, - { - "path": "/0/content/1/content/0/value", - "value": "fuyeor.рф" - } - ], - "plain_text": "Visit fuyeor.рф" - }, { "input": "1. example\n - example", "assert": [ diff --git a/package/benchmark/memory.ts b/package/benchmark/memory.ts index 5b131bb..e899b36 100644 --- a/package/benchmark/memory.ts +++ b/package/benchmark/memory.ts @@ -1,15 +1,15 @@ // @ffm/benchmark/memory.ts // pnpm -F @ffm/benchmark bench:memory // @ts-nocheck -import { createFuyeorMarkdownParser, render } from '@ffm/parser'; +import { createMarkdownParser, render } from '@ffm/parser'; import MarkdownIt from 'markdown-it'; import { marked } from 'marked'; import { social, article } from './samples'; // Polyfill for window if needed by some specific logic -if (typeof window === 'undefined') global.window = globalThis; +global.window = globalThis; -const ffm = createFuyeorMarkdownParser(); +const ffm = createMarkdownParser(); const mdIt = new MarkdownIt({ linkify: true }); const ffmIt = (content: string) => { diff --git a/package/benchmark/speed.ts b/package/benchmark/speed.ts index c143668..333c41d 100644 --- a/package/benchmark/speed.ts +++ b/package/benchmark/speed.ts @@ -2,12 +2,13 @@ // pnpm -F @ffm/benchmark bench:speed // @ts-nocheck import { run, bench, group } from 'mitata'; -import { createFuyeorMarkdownParser, render } from '@ffm/parser'; +import { createMarkdownParser, createCommonParser, render } from '@ffm/parser'; import MarkdownIt from 'markdown-it'; import { marked } from 'marked'; -import { social, article } from './samples'; +import { social, article } from './sample'; -const ffm = createFuyeorMarkdownParser(); +const ffm = createMarkdownParser(); +const ffm2 = createCommonParser(); const mdIt = new MarkdownIt({ linkify: true }); const ffmIt = (content: string) => { @@ -15,18 +16,27 @@ const ffmIt = (content: string) => { return render(ast); }; +const ffmIt2 = (content: string) => { + const ast = ffm2(content); + return render(ast); +}; + // Benchmarking Social scenario group('50 Social Post (Small/Frequent)', () => { - bench('@ffm/parser (AST)', () => ffm(social)); - bench('@ffm/parser (HTML)', () => ffmIt(social)); + bench('@ffm/parser (AST, Full)', () => ffm(social)); + bench('@ffm/parser (AST, No Extension)', () => ffm2(social)); + bench('@ffm/parser (HTML, Full)', () => ffmIt(social)); + bench('@ffm/parser (HTML, No Extension)', () => ffmIt2(social)); bench('markdown-it (HTML)', () => mdIt.render(social)); bench('marked (HTML)', () => marked.parse(social)); }); // Benchmarking Blog scenario group('20 Blog Post (Structured/Nested)', () => { - bench('@ffm/parser (AST)', () => ffm(article)); - bench('@ffm/parser (HTML)', () => ffmIt(article)); + bench('@ffm/parser (AST, No Extension)', () => ffm2(article)); + bench('@ffm/parser (AST, Full)', () => ffm(article)); + bench('@ffm/parser (HTML, No Extension)', () => ffmIt2(article)); + bench('@ffm/parser (HTML, Full)', () => ffmIt(article)); bench('markdown-it (HTML)', () => mdIt.render(article)); bench('marked (HTML)', () => marked.parse(article)); }); diff --git a/package/editor/core/src/parse/bridge.ts b/package/editor/core/src/parse/bridge.ts index c1e1830..25e18c7 100644 --- a/package/editor/core/src/parse/bridge.ts +++ b/package/editor/core/src/parse/bridge.ts @@ -1,5 +1,5 @@ // @ffm/editor/src/parse/bridge.ts -import { createFuyeorMarkdownParser } from '@ffm/parser'; +import { createMarkdownParser } from '@ffm/parser'; import type { ASTNode } from '@ffm/parser'; import { nextBlockId } from '#/state/id'; import type { @@ -11,7 +11,7 @@ import type { FormatType, } from '#/state/document'; -const parse = createFuyeorMarkdownParser(); +const parse = createMarkdownParser(); type BlockContext = { listDepth: number; @@ -273,7 +273,7 @@ function formatTypeFor(nodeType: string): FormatType | undefined { return 'strike'; case 'link': return 'link'; - case 'inline_code': + case 'code_inline': return 'code'; case 'math_inline': return 'code'; diff --git a/package/formatter/src/print/inline.ts b/package/formatter/src/print/inline.ts index b8feea7..2bdb81a 100644 --- a/package/formatter/src/print/inline.ts +++ b/package/formatter/src/print/inline.ts @@ -50,7 +50,7 @@ export function printInlineNode( return `--${printInlineNodes(node.content, option, context)}--`; } - if (type === 'code_inline' || type === 'inline_code') { + if (type === 'code_inline' || type === 'code_inline') { const value = node.value ?? ''; const fence = '`'.repeat(Math.max(1, longestBacktickRun(value) + 1)); return `${fence}${value}${fence}`; diff --git a/package/parser/package.json b/package/parser/package.json index 50c1ce9..af41587 100644 --- a/package/parser/package.json +++ b/package/parser/package.json @@ -17,7 +17,8 @@ "#/*": "./src/*" }, "exports": { - ".": "./src/index.ts" + ".": "./src/index.ts", + "./plugin": "./src/plugin/index.ts" }, "dependencies": { "@ffm/linkify": "workspace:*" diff --git a/package/parser/src/core/parser.ts b/package/parser/src/core/parser.ts index e7d416b..f0fbabe 100644 --- a/package/parser/src/core/parser.ts +++ b/package/parser/src/core/parser.ts @@ -1,6 +1,7 @@ // @ffm/parser/src/core/parser.ts import { linkify } from '@ffm/linkify'; import { BlockState, InlineState } from './state'; +import { isSafeLinkUrl } from '#/core/url'; import type { ASTNode, ASTTransform, @@ -10,33 +11,35 @@ import type { MarkdownPlugin, MarkdownParserOption, ParserContext, + AsyncCapability, } from '#/type'; -import { isSafeLinkUrl } from '#/core/url'; -const LINKIFY_CANDIDATE_REGEX = /(?:https?:\/\/|[A-Za-z0-9-]+\.)/u; +const linkRegex = /(?:https?:\/\/|[A-Za-z0-9-]+\.)/u; /** Skip linkify scans for text without a possible URL candidate. */ function linkifyWithCandidateCheck(text: string): ReturnType { - if (!LINKIFY_CANDIDATE_REGEX.test(text)) return []; + if (!linkRegex.test(text)) return []; return linkify(text); } export class MarkdownParser { - #blockRuleMap = new Map(); - #inlineRuleMap = new Map(); + readonly #maxNestingDepth: number; + readonly #linkifier: Linkifier; + #astTransforms: ASTTransform[] = []; #idSequence = 0; #isPreflight = false; - readonly #maxNestingDepth: number; - readonly #linkifier: Linkifier; + #blockRuleMap = new Map(); + #inlineRuleMap = new Map(); + #capability = new Set(); - constructor(options: MarkdownParserOption = {}) { - const maxNestingDepth = options.maxNestingDepth ?? 64; + constructor(option: MarkdownParserOption = {}) { + const maxNestingDepth = option.maxNestingDepth ?? 64; if (!Number.isInteger(maxNestingDepth) || maxNestingDepth < 1) throw new RangeError('maxNestingDepth must be a positive integer'); this.#maxNestingDepth = maxNestingDepth; - this.#linkifier = options.linkifier ?? linkifyWithCandidateCheck; + this.#linkifier = option.linkifier ?? linkifyWithCandidateCheck; } // construct a context for recursive rule calls @@ -79,17 +82,28 @@ export class MarkdownParser { return this; } - use(plugin: MarkdownPlugin): this { - plugin(this); + // Declare an external capability consumed by this parser's HTML output. + requireCapability(capability: AsyncCapability): this { + this.#capability.add(capability); return this; } + // Expose declared capabilities so hosts can drive preload / hydration. + getRequiredCapability(): ReadonlySet { + return this.#capability; + } + // Register a post-parse AST transform for extensions such as Twemoji. addAstTransform(transform: ASTTransform): this { this.#astTransforms.push(transform); return this; } + use(plugin: MarkdownPlugin): this { + plugin(this); + return this; + } + build(): (content: string) => ASTNode[] { return (content: string) => { this.#idSequence = 0; diff --git a/package/parser/src/core/plain-text.ts b/package/parser/src/core/plain-text.ts index 231fc1d..e448caf 100644 --- a/package/parser/src/core/plain-text.ts +++ b/package/parser/src/core/plain-text.ts @@ -10,7 +10,7 @@ export function toPlainText(node: readonly ASTNode[]): string { function blockText(node: ASTNode): string { switch (node.type) { case 'text': - case 'inline_code': + case 'code_inline': case 'color_code': return node.value ?? ''; case 'code_block': diff --git a/package/parser/src/core/render.ts b/package/parser/src/core/render.ts index ebce92e..56d1ead 100644 --- a/package/parser/src/core/render.ts +++ b/package/parser/src/core/render.ts @@ -1,19 +1,24 @@ // @ffm/parser/src/core/render.ts -import type { ASTNode } from '#/type'; import { isSafeColorValue } from '#/core/color'; import { isSafeLinkUrl } from '#/core/url'; +import type { + ASTNode, + NodeRenderer, + RenderContext, + RenderOption, +} from '#/type'; -const escapeHtml = (str: string) => - str.replace( +export const escapeHtml = (value: string): string => + value.replace( /[&<>"']/g, - (m) => + (char) => ({ '&': '&', '<': '<', '>': '>', '"': '"', "'": ''', - })[m]!, + })[char]!, ); // Keep dynamic HTML tag names and CSS values within their supported grammar. @@ -26,51 +31,46 @@ const getHeadingLevel = (level: unknown) => : null; // Keep table alignment attributes within the supported HTML grammar. -const getTableAlignment = (align: unknown) => +const getTableAlign = (align: unknown) => align === 'left' || align === 'center' || align === 'right' ? ` align="${align}"` : ''; -const displayLanguageNames: Record = { - javascript: 'JavaScript', - typescript: 'TypeScript', - cpp: 'C++', - csharp: 'C#', - xml: 'XML', - json: 'JSON', - yaml: 'YAML', - ffm: 'Fuyeor Flavored Markdown', - fon: 'FON', - fer: 'Fer', -}; +// Render AST into HTML; custom renderers override built-in branches per node type. +export function render(nodeArray?: ASTNode[], option?: RenderOption): string { + return renderNodes(nodeArray, option?.nodeRenderer); +} -// Render a stable fenced-code contract for asynchronous highlight.js processing. -const getCodeLanguage = (lang: unknown): string => { - if (typeof lang !== 'string') return ''; - return lang.trim().split(/\s+/u)[0] ?? ''; -}; +function renderNodes( + nodeArray: ASTNode[] | undefined, + custom: Record | undefined, +): string { + if (!nodeArray || nodeArray.length === 0) return ''; -const getDisplayLanguageName = (language: string): string => - displayLanguageNames[language] ?? - (language ? language.charAt(0).toUpperCase() + language.slice(1) : 'Text'); + const ctx: RenderContext = { + escapeHtml, + render: (children) => renderNodes(children, custom), + }; -export function render(nodes?: ASTNode[]): string { let html = ''; + for (const node of nodeArray) { + const renderer = custom?.[node.type]; + if (renderer) { + html += renderer(node, ctx); + continue; + } - if (!nodes || nodes.length === 0) return ''; - - for (const node of nodes) { switch (node.type) { case 'heading': { const level = getHeadingLevel(node.level); html += level === null - ? `${render(node.content)}` - : `${render(node.content)}\n`; + ? `${ctx.render(node.content)}` + : `${ctx.render(node.content)}\n`; break; } case 'paragraph': - html += `

${render(node.content)}

\n`; + html += `

${ctx.render(node.content)}

\n`; break; case 'text': html += node.value ? escapeHtml(node.value) : ''; @@ -83,24 +83,24 @@ export function render(nodes?: ASTNode[]): string { break; } case 'math_inline': - html += `${escapeHtml(String(node.value ?? ''))}`; + html += `${escapeHtml(String(node.value ?? ''))}`; break; case 'math_block': - html += `
${escapeHtml(String(node.value ?? ''))}
\n`; + html += `
${escapeHtml(String(node.value ?? ''))}
\n`; break; case 'bold': - html += `${render(node.content)}`; + html += `${ctx.render(node.content)}`; break; case 'italic': - html += `${render(node.content)}`; + html += `${ctx.render(node.content)}`; break; case 'underline': - html += `${render(node.content)}`; + html += `${ctx.render(node.content)}`; break; case 'strike': - html += `${render(node.content)}`; + html += `${ctx.render(node.content)}`; break; - case 'inline_code': + case 'code_inline': html += `${node.value ? escapeHtml(node.value) : ''}`; break; case 'color_code': { @@ -115,21 +115,22 @@ export function render(nodes?: ASTNode[]): string { case 'link': { const url = String(node.url ?? '').trim(); html += isSafeLinkUrl(url) - ? `${render(node.content)}` - : render(node.content); + ? `${ctx.render(node.content)}` + : ctx.render(node.content); break; } case 'code_block': { - const language = getCodeLanguage(node.lang); - const displayLanguage = getDisplayLanguageName(language); - const preAttributes = language - ? `class="hljs language-${escapeHtml(language)}" data-language="${escapeHtml(language)}"` - : 'class="hljs language-plaintext"'; - html += `
`; + const language = node.lang; + const escapedValue = escapeHtml(String(node.value ?? '')); + html += '
'; if (language) { - html += `
${escapeHtml(displayLanguage)}
`; + const escapedLanguage = escapeHtml(language); + html += `
${escapeHtml(language)}
`; + html += `
${escapedValue}\n
`; + } else { + html += `
${escapedValue}\n
`; } - html += `
${escapeHtml(String(node.value ?? ''))}\n
\n`; + html += '
\n'; break; } case 'list': { @@ -138,20 +139,20 @@ export function render(nodes?: ASTNode[]): string { node.ordered && node.start && node.start !== 1 ? ` start="${node.start}"` : ''; - html += `<${tag}${start}>\n${render(node.content)}\n`; + html += `<${tag}${start}>\n${ctx.render(node.content)}\n`; break; } case 'list_item': - html += `
  • ${render(node.content)}
  • \n`; + html += `
  • ${ctx.render(node.content)}
  • \n`; break; case 'mermaid': - html += `
    ${escapeHtml(String(node.value ?? ''))}
    \n`; + html += `
    ${escapeHtml(String(node.value ?? ''))}
    \n`; break; case 'abc': - html += `
    ${escapeHtml(String(node.value ?? ''))}
    \n`; + html += `
    ${escapeHtml(String(node.value ?? ''))}
    \n`; break; case 'smiles_inline': - html += ``; + html += ``; break; case 'smiles_block': { const blocks = String(node.value ?? '') @@ -159,7 +160,7 @@ export function render(nodes?: ASTNode[]): string { .filter((line) => line.trim().length > 0) .map( (line) => - `
    `, + `
    `, ); html += blocks.length > 0 ? `${blocks.join('\n')}\n` : ''; break; @@ -169,7 +170,7 @@ export function render(nodes?: ASTNode[]): string { if (node.header) { html += '\n\n'; node.header.forEach((cell) => { - html += `${render(cell.content)}\n`; + html += `${ctx.render(cell.content)}\n`; }); html += '\n\n'; } @@ -178,7 +179,7 @@ export function render(nodes?: ASTNode[]): string { node.content.forEach((row) => { html += '\n'; row.content?.forEach((cell) => { - html += `${render(cell.content)}\n`; + html += `${ctx.render(cell.content)}\n`; }); html += '\n'; }); @@ -191,16 +192,16 @@ export function render(nodes?: ASTNode[]): string { html += '
    \n'; break; case 'blockquote': - html += `
    \n${render(node.content)}
    \n`; + html += `
    \n${ctx.render(node.content)}
    \n`; break; case 'accordion': - html += `
    ${render(node.content)}
    `; + html += `
    ${ctx.render(node.content)}
    `; break; case 'accordion_item': - html += `
    ${render(node.title)}
    ${render(node.content)}
    `; + html += `
    ${ctx.render(node.title)}
    ${ctx.render(node.content)}
    `; break; case 'chain': - html += `
    ${render(node.content)}
    `; + html += `
    ${ctx.render(node.content)}
    `; break; case 'chain_item': { const statusClass = node.hasCheckbox @@ -210,25 +211,24 @@ export function render(nodes?: ASTNode[]): string { : ''; const title = node.title && node.title.length > 0 - ? `
    ${render(node.title)}
    ` + ? `
    ${ctx.render(node.title)}
    ` : ''; - html += `
    ${title}
    ${render(node.content)}
    `; + html += `
    ${title}
    ${ctx.render(node.content)}
    `; break; } case 'slide': - html += `
    ${render(node.content)}
    `; + html += `
    ${ctx.render(node.content)}
    `; break; case 'slide_item': - html += `
    ${render(node.content)}
    `; + html += `
    ${ctx.render(node.content)}
    `; break; case 'hardbreak': html += '
    \n'; break; default: - html += `${render(node.content)}`; + html += `${ctx.render(node.content)}`; break; } } - return html; } diff --git a/package/parser/src/default.ts b/package/parser/src/default.ts index f258866..27ef1cd 100644 --- a/package/parser/src/default.ts +++ b/package/parser/src/default.ts @@ -1,6 +1,5 @@ // @ffm/parser/src/default.ts import { MarkdownParser } from './core/parser'; -import type { MarkdownParserOption } from './type'; import { headingRule, tableRule, @@ -19,20 +18,26 @@ import { strikeRule, } from './rule/inline'; import { ffmBlockRule } from './rule/ffm'; +import type { MarkdownParserOption } from './type'; + +import { twemojiPlugin } from './plugin/twemoji'; +import { highlightPlugin } from './plugin/highlight'; import { latexPlugin } from './plugin/latex'; -import { extensionsPlugin } from './plugin/extensions'; +import { mermaidPlugin } from './plugin/mermaid'; +import { smilesPlugin } from './plugin/smiles'; +import { abcPlugin } from './plugin/abc'; export function createMarkdownParser(option: MarkdownParserOption = {}) { return ( new MarkdownParser(option) // block order: Code block -> List -> Title -> Table -> Delete line -> Quote + .addBlockRule(ffmBlockRule) .addBlockRule(codeBlockRule) .addBlockRule(listRule) .addBlockRule(headingRule) .addBlockRule(tableRule) .addBlockRule(hrRule) .addBlockRule(blockquoteRule) - // inline order: Inline code -> Links -> Bold/Underline/Strikethrough .addInlineRule(hardBreakRule) .addInlineRule(inlineCodeRule) @@ -41,24 +46,30 @@ export function createMarkdownParser(option: MarkdownParserOption = {}) { .addInlineRule(underlineRule) .addInlineRule(italicRule) .addInlineRule(strikeRule) - + // plugin + .use(twemojiPlugin) + .use(latexPlugin) + .use(mermaidPlugin) + .use(smilesPlugin) + .use(abcPlugin) + // NOTE: Must be last. It capitalizes lang + // breaking plugins that match lowercase names + .use(highlightPlugin) + // generate AST node .build() ); } -export function createFuyeorMarkdownParser(option: MarkdownParserOption = {}) { +export function createCommonParser(option: MarkdownParserOption = {}) { return ( new MarkdownParser(option) // block order: Code block -> List -> Title -> Table -> Delete line -> Quote - .addBlockRule(ffmBlockRule) .addBlockRule(codeBlockRule) .addBlockRule(listRule) .addBlockRule(headingRule) .addBlockRule(tableRule) .addBlockRule(hrRule) .addBlockRule(blockquoteRule) - .use(latexPlugin) - .use(extensionsPlugin) // inline order: Inline code -> Links -> Bold/Underline/Strikethrough .addInlineRule(hardBreakRule) diff --git a/package/parser/src/index.spec.ts b/package/parser/src/index.spec.ts index 0d72632..77ac834 100644 --- a/package/parser/src/index.spec.ts +++ b/package/parser/src/index.spec.ts @@ -1,13 +1,16 @@ // @ffm/parser/src/index.spec.ts -import { readFileSync } from 'node:fs'; -import { resolve } from 'node:path'; +// pnpm -F @ffm/parser test import { describe, expect, it } from 'vitest'; import { isSafeColorValue } from './core/color'; import { MarkdownParser } from './core/parser'; import { isSafeLinkUrl } from './core/url'; import { render } from './core/render'; import { toPlainText } from './core/plain-text'; -import { createFuyeorMarkdownParser, createMarkdownParser } from './default'; +import { createMarkdownParser, createCommonParser } from './default'; + +import ffm from '../../../fixture/ffm.json' with { type: 'json' }; +import common from '../../../fixture/markdown.json' with { type: 'json' }; +import safety from '../../../fixture/safety.json' with { type: 'json' }; type MarkdownAssertion = { path: string; @@ -31,26 +34,6 @@ type MarkdownFixtureFile = { cases: MarkdownCase[]; }; -type SafetyCase = { input: string; valid: boolean }; -type SafetyFixtureFile = { - schema_version: number; - description: string; - links: SafetyCase[]; - colors: SafetyCase[]; -}; - -const loadJson = (name: string): T => - JSON.parse( - readFileSync( - resolve(import.meta.dirname, `../../../fixture/${name}`), - 'utf8', - ), - ) as T; - -const cfmFixture = loadJson('markdown.json'); -const ffmFixture = loadJson('ffm.json'); -const safetyFixtures = loadJson('safety.json'); - // Read a portable JSON Pointer path from a TypeScript AST value. function readJsonPointer(root: unknown, pointer: string): unknown { let value = root; @@ -85,8 +68,8 @@ function executeMarkdownCase(fixture: MarkdownCase, ffm: boolean): void { } const parser = ffm - ? createFuyeorMarkdownParser(option) - : createMarkdownParser(option); + ? createMarkdownParser(option) + : createCommonParser(option); const ast = parser(fixture.input ?? ''); if (fixture.html !== undefined) expect(render(ast).trim()).toBe(fixture.html); if (fixture.plain_text !== undefined) @@ -120,8 +103,9 @@ function executeMarkdownSuite( }); } -executeMarkdownSuite('cfm fixture', cfmFixture, false); -executeMarkdownSuite('ffm fixture', ffmFixture, true); +executeMarkdownSuite('cfm fixture', common, false); +// @ts-ignore +executeMarkdownSuite('ffm fixture', ffm, true); // Verify the public AST shape uses the modern scalar and structural field names. describe('AST field names', () => { @@ -160,11 +144,11 @@ describe('AST field names', () => { }); describe('safety fixture', () => { - expect(safetyFixtures.schema_version).toBe(1); - for (const fixture of safetyFixtures.links) + expect(safety.schema_version).toBe(1); + for (const fixture of safety.links) it(`link: ${fixture.input}`, () => expect(isSafeLinkUrl(fixture.input)).toBe(fixture.valid)); - for (const fixture of safetyFixtures.colors) + for (const fixture of safety.colors) it(`color: ${fixture.input}`, () => expect(isSafeColorValue(fixture.input)).toBe(fixture.valid)); }); diff --git a/package/parser/src/index.ts b/package/parser/src/index.ts index dc0c346..eee8123 100644 --- a/package/parser/src/index.ts +++ b/package/parser/src/index.ts @@ -1,6 +1,6 @@ // @ffm/parser/src/index.ts export { MarkdownParser } from './core/parser'; -export { render } from './core/render'; +export { render, escapeHtml } from './core/render'; export { toPlainText } from './core/plain-text'; export { isSafeColorValue } from './core/color'; export { isSafeLinkUrl } from './core/url'; @@ -20,32 +20,7 @@ export { underlineRule, strikeRule, } from './rule/inline'; -export { latexPlugin, latexInlineRule, latexBlockRule } from './plugin/latex'; -export { - twemojiPlugin, - nativeEmojiPlugin, - twemojiTransform, - transformTwemojiNode, - getTwemojiUrl, -} from './plugin/twemoji'; -export { highlightPlugin, highlightTransform } from './plugin/highlight'; -export { - abcPlugin, - abcTransform, - mermaidPlugin, - mermaidTransform, - smilesBlockPlugin, - smilesBlockTransform, - smilesInlinePlugin, - smilesPlugin, - smilesInlineRule, - SPECIAL_BLOCK_LANGUAGES, - specialBlockPlugin, - specialBlockTransform, - transformSpecialBlockNode, -} from './plugin/async-blocks'; -export { extensionsPlugin, extensionsTransform } from './plugin/extensions'; -export { createMarkdownParser, createFuyeorMarkdownParser } from './default'; +export { createMarkdownParser, createCommonParser } from './default'; export type { NodeType, @@ -56,5 +31,11 @@ export type { InlineRule, Linkifier, MarkdownParserOption, + NodeRenderer, + RenderContext, + RenderOption, MarkdownPlugin, + AsyncCapability, + AsyncRenderer, + HydrateOption, } from './type'; diff --git a/package/parser/src/plugin/abc/index.ts b/package/parser/src/plugin/abc/index.ts new file mode 100644 index 0000000..c3ec3c1 --- /dev/null +++ b/package/parser/src/plugin/abc/index.ts @@ -0,0 +1,41 @@ +// @ffm/parser/src/async/abc.ts +import { loadScript } from '#/plugin/loader'; +import { createCodeBlockTransform } from '#/plugin/ast'; +import type { AsyncRenderer, MarkdownPlugin } from '#/type'; +import type { Abc, AbcSource } from './type'; + +// Extend the Window interface to include our highlight property +declare global { + interface Window { + // ABCJS 硬编码 `window.ABCJS` + ABCJS?: Abc; + } +} + +// Build an ABCJS renderer for fenced abc blocks. +export const createAbc = (source: AbcSource): AsyncRenderer => ({ + name: 'abc', + selector: '[data-async="abc"]', + style: source.style, + load: () => loadScript(source.script, 'ABCJS'), + render(element, abcjs) { + const code = element.textContent ?? ''; + if (!code.trim()) return; + element.textContent = ''; + abcjs.renderAbc(element, code, { + responsive: 'resize', + add_classes: true, + paddingbottom: 0, + paddingtop: 0, + paddingleft: 0, + paddingright: 0, + }); + }, +}); + +export const abcTransform = createCodeBlockTransform('abc'); + +export const abcPlugin: MarkdownPlugin = (parser) => { + parser.addAstTransform(abcTransform); + parser.requireCapability('abc'); +}; diff --git a/package/parser/src/plugin/abc/type.ts b/package/parser/src/plugin/abc/type.ts new file mode 100644 index 0000000..4e60a66 --- /dev/null +++ b/package/parser/src/plugin/abc/type.ts @@ -0,0 +1,22 @@ +// @ffm/parser/src/plugin/abc/type.ts + +// 定义 abcjs 的最小化接口类型 +export interface Abc { + renderAbc( + element: HTMLElement, + code: string, + option: { + responsive: string; + add_classes: boolean; + paddingbottom: number; + paddingtop: number; + paddingleft: number; + paddingright: number; + }, + ): void; +} + +export interface AbcSource { + script: string; + style?: readonly string[]; +} diff --git a/package/parser/src/plugin/ast.ts b/package/parser/src/plugin/ast.ts index 781dce1..2de857f 100644 --- a/package/parser/src/plugin/ast.ts +++ b/package/parser/src/plugin/ast.ts @@ -1,19 +1,19 @@ // @ffm/parser/src/plugin/ast.ts -import type { ASTNode } from '#/type'; +import type { ASTNode, ASTTransform } from '#/type'; type ASTNodeReplacement = ASTNode | readonly ASTNode[]; // Recursively transform only changed branches and preserve unchanged node arrays. -export const mapAstNodes = ( - nodes: ASTNode[], +export const mapAstNode = ( + nodeArray: ASTNode[], transformNode: (node: ASTNode) => ASTNodeReplacement, ): ASTNode[] => { let transformedNodes: ASTNode[] | undefined; - for (let index = 0; index < nodes.length; index++) { - const node = nodes[index]; + for (let index = 0; index < nodeArray.length; index++) { + const node = nodeArray[index]; const transformedChildren = node.content - ? mapAstNodes(node.content, transformNode) + ? mapAstNode(node.content, transformNode) : node.content; const transformedNode = transformedChildren && transformedChildren !== node.content @@ -28,10 +28,20 @@ export const mapAstNodes = ( !transformedNodes && (replacementNodes.length !== 1 || replacementNodes[0] !== node) ) { - transformedNodes = nodes.slice(0, index); + transformedNodes = nodeArray.slice(0, index); } transformedNodes?.push(...replacementNodes); } - return transformedNodes ?? nodes; + return transformedNodes ?? nodeArray; }; + +// 将指定语言的代码块,声明式映射为目标 AST 节点 +export const createCodeBlockTransform = + (language: string, targetType = language): ASTTransform => + (nodeArray) => + mapAstNode(nodeArray, (node) => + node.type === 'code_block' && node.lang === language + ? { type: targetType, value: String(node.value ?? '') } + : node, + ); diff --git a/package/parser/src/plugin/async-blocks.ts b/package/parser/src/plugin/async-blocks.ts deleted file mode 100644 index 6145159..0000000 --- a/package/parser/src/plugin/async-blocks.ts +++ /dev/null @@ -1,89 +0,0 @@ -// @ffm/parser/src/plugin/async-blocks.ts -import { InlineState } from '#/core/state'; -import type { ASTNode, ASTTransform, InlineRule, MarkdownPlugin } from '#/type'; -import { mapAstNodes } from './ast'; -import { normalizeHighlightLanguage } from './highlight'; - -const SMILES_INLINE_PATTERN = /^#\[smiles\s*=\s*`([^`]+)`\]/u; -export const SPECIAL_BLOCK_LANGUAGES = new Set(['mermaid', 'abc', 'smiles']); - -// Parse the FFM #[smiles = `...`] inline placeholder syntax. -export const smilesInlineRule: InlineRule = { - name: 'smiles_inline', - marker: ['#'], - parse(state: InlineState) { - if (state.currentChar !== '#') return null; - - const match = state.content.slice(state.pos).match(SMILES_INLINE_PATTERN); - if (!match) return null; - - return { - node: { type: 'smiles_inline', value: match[1].trim() }, - consumedChars: match[0].length, - }; - }, -}; - -// Convert one fenced code block into its asynchronous renderer placeholder. -export const transformSpecialBlockNode = ( - node: ASTNode, - languages: ReadonlySet, -): ASTNode => { - if (node.type !== 'code_block') return node; - - const language = normalizeHighlightLanguage(String(node.lang ?? '')); - if (!languages.has(language)) return node; - - return { - type: language === 'smiles' ? 'smiles_block' : language, - value: String(node.value ?? ''), - } satisfies ASTNode; -}; - -// Build a lazy transform for a selected set of special fenced languages. -const createSpecialBlockTransform = - (languages: ReadonlySet): ASTTransform => - (nodes) => - mapAstNodes(nodes, (node) => transformSpecialBlockNode(node, languages)); - -export const mermaidTransform = createSpecialBlockTransform( - new Set(['mermaid']), -); -export const abcTransform = createSpecialBlockTransform(new Set(['abc'])); -export const smilesBlockTransform = createSpecialBlockTransform( - new Set(['smiles']), -); -export const specialBlockTransform = createSpecialBlockTransform( - SPECIAL_BLOCK_LANGUAGES, -); - -// Register Mermaid, ABC, and fenced Smiles block placeholders together. -export const specialBlockPlugin: MarkdownPlugin = (parser) => { - parser.addAstTransform(specialBlockTransform); -}; - -// Register only Mermaid fenced blocks for consumers that opt in selectively. -export const mermaidPlugin: MarkdownPlugin = (parser) => { - parser.addAstTransform(mermaidTransform); -}; - -// Register only ABC fenced blocks for consumers that opt in selectively. -export const abcPlugin: MarkdownPlugin = (parser) => { - parser.addAstTransform(abcTransform); -}; - -// Register only fenced Smiles blocks for consumers that opt in selectively. -export const smilesBlockPlugin: MarkdownPlugin = (parser) => { - parser.addAstTransform(smilesBlockTransform); -}; - -// Register the FFM inline Smiles syntax. -export const smilesInlinePlugin: MarkdownPlugin = (parser) => { - parser.addInlineRule(smilesInlineRule); -}; - -// Register both inline and fenced Smiles syntax. -export const smilesPlugin: MarkdownPlugin = (parser) => { - smilesInlinePlugin(parser); - smilesBlockPlugin(parser); -}; diff --git a/package/parser/src/plugin/extensions.ts b/package/parser/src/plugin/extensions.ts deleted file mode 100644 index 400f131..0000000 --- a/package/parser/src/plugin/extensions.ts +++ /dev/null @@ -1,32 +0,0 @@ -// @ffm/parser/src/plugin/extensions.ts -import type { ASTNode, ASTTransform, MarkdownPlugin } from '#/type'; -import { mapAstNodes } from './ast'; -import { transformTwemojiNode } from './twemoji'; -import { - SPECIAL_BLOCK_LANGUAGES, - transformSpecialBlockNode, - smilesInlinePlugin, -} from './async-blocks'; -import { normalizeHighlightLanguage } from './highlight'; - -// Normalize code languages and special blocks in the same pass as Twemoji. -const transformExtensionNode = ( - node: ASTNode, -): ASTNode | readonly ASTNode[] => { - if (node.type === 'text') return transformTwemojiNode(node); - if (node.type !== 'code_block') return node; - - const language = normalizeHighlightLanguage(String(node.lang ?? '')); - const normalizedNode = - language && language !== node.lang ? { ...node, lang: language } : node; - return transformSpecialBlockNode(normalizedNode, SPECIAL_BLOCK_LANGUAGES); -}; - -export const extensionsTransform: ASTTransform = (nodes) => - mapAstNodes(nodes, transformExtensionNode); - -// Register all five asynchronous/frontend-compatible extensions together. -export const extensionsPlugin: MarkdownPlugin = (parser) => { - parser.addAstTransform(extensionsTransform); - smilesInlinePlugin(parser); -}; diff --git a/package/parser/src/plugin/highlight.ts b/package/parser/src/plugin/highlight.ts deleted file mode 100644 index 348d9ff..0000000 --- a/package/parser/src/plugin/highlight.ts +++ /dev/null @@ -1,41 +0,0 @@ -// @ffm/parser/src/plugin/highlight.ts -import type { ASTNode, ASTTransform, MarkdownPlugin } from '#/type'; -import { mapAstNodes } from './ast'; - -const languageAliases: Record = { - 'c++': 'cpp', - 'c#': 'csharp', - cs: 'csharp', - js: 'javascript', - ts: 'typescript', - sh: 'bash', - yml: 'yaml', - html: 'xml', - md: 'markdown', - rs: 'rust', - rb: 'ruby', - pl: 'perl', - ps1: 'powershell', - py: 'python', -}; - -// Normalize fenced-code aliases to the language names used by highlight.js. -export const normalizeHighlightLanguage = (rawLanguage: string): string => { - const language = rawLanguage.trim().split(/\s+/u)[0]?.toLowerCase() ?? ''; - return languageAliases[language] ?? language; -}; - -export const highlightTransform: ASTTransform = (nodes) => - mapAstNodes(nodes, (node) => { - if (node.type !== 'code_block') return node; - - const language = normalizeHighlightLanguage(String(node.lang ?? '')); - return language && language !== node.lang - ? { ...node, lang: language } - : node; - }); - -// Register language normalization for asynchronous highlight.js processing. -export const highlightPlugin: MarkdownPlugin = (parser) => { - parser.addAstTransform(highlightTransform); -}; diff --git a/package/parser/src/plugin/highlight/index.ts b/package/parser/src/plugin/highlight/index.ts new file mode 100644 index 0000000..c37ab52 --- /dev/null +++ b/package/parser/src/plugin/highlight/index.ts @@ -0,0 +1,59 @@ +// @ffm/parser/src/plugin/highlight/index.ts +import { mapAstNode } from '#/plugin/ast'; +import { loadModule } from '#/plugin/loader'; +import { getDisplayLanguageName } from './util'; +import type { ASTTransform, AsyncRenderer, MarkdownPlugin } from '#/type'; +import type { Highlight, HighlightSource } from './type'; + +// Extend the Window interface to include our highlight property +declare global { + interface Window { + // highlight.js 硬编码查找叫 `window.hljs` 的对象 + hljs?: Highlight; + } +} + +export const highlightTransform: ASTTransform = (nodes) => + mapAstNode(nodes, (node) => { + if (node.type !== 'code_block') return node; + + const language = getDisplayLanguageName(String(node.lang ?? '')); + return language && language !== node.lang + ? { ...node, lang: language } + : node; + }); + +// Build a highlight.js renderer driven by `data-language` and a language registry. +export const createHighlight = ( + source: HighlightSource, +): AsyncRenderer => ({ + name: 'hljs', + selector: '[data-async="hljs"]', + style: source.style, + async load() { + const hljs = await loadModule(source.script, 'hljs'); + hljs.configure({ ignoreUnescapedHTML: true }); + // Some language modules register themselves against the global hljs. + window.hljs = hljs; + return hljs; + }, + async render(element, hljs) { + const language = element.dataset.language; + if (!language) return; + + const code = element.querySelector('code'); + if (!code) return; + + if (!hljs.getLanguage(language) && source.language?.[language]) { + const module = await source.language[language](); + hljs.registerLanguage(language, module.default); + } + hljs.highlightElement(code); + }, +}); + +// Register language normalization for asynchronous highlight.js processing. +export const highlightPlugin: MarkdownPlugin = (parser) => { + parser.addAstTransform(highlightTransform); + parser.requireCapability('hljs'); +}; diff --git a/package/parser/src/plugin/highlight/type.ts b/package/parser/src/plugin/highlight/type.ts new file mode 100644 index 0000000..ff96b4a --- /dev/null +++ b/package/parser/src/plugin/highlight/type.ts @@ -0,0 +1,27 @@ +// @ffm/parser/src/plugin/highlight/type.ts + +export interface Highlight { + getLanguage(languageName: string): Language | undefined; + highlightElement(element: Element): void; + // registerLanguage 函数声明 + registerLanguage( + languageName: string, + languageDefinition: (highlight: any) => Language, + ): void; + configure(options: { ignoreUnescapedHTML: boolean }): void; + isInitialized?: boolean; +} + +export interface HighlightSource { + script: string; + style?: readonly string[]; + /** Lazy language modules keyed by normalized language name. */ + language?: Record Promise<{ default: unknown }>>; +} + +export interface Language { + name: string; + aliases?: string[]; + contains?: any[]; + keywords?: Record | string; +} diff --git a/package/parser/src/plugin/highlight/util.ts b/package/parser/src/plugin/highlight/util.ts new file mode 100644 index 0000000..44f98ff --- /dev/null +++ b/package/parser/src/plugin/highlight/util.ts @@ -0,0 +1,64 @@ +// @ffm/parser/src/plugin/highlight/util.ts + +/** + * 语言别名映射表,用于统一请求 CDN 语言标识符。 + */ +export const highlightNameMap: Record = { + 'c++': 'cpp', + 'c#': 'csharp', + cs: 'csharp', + js: 'javascript', + ts: 'typescript', + sh: 'bash', + yml: 'yaml', + html: 'xml', // 官方没有 html + md: 'markdown', + rs: 'rust', + rb: 'ruby', + pl: 'perl', + ps1: 'powershell', + py: 'python', +} as const; + +// 一个小型的、针对特殊写法的映射表 +const displayNameMap: Record = { + javascript: 'JavaScript', + typescript: 'TypeScript', + + xml: 'XML', + html: 'HTML', + css: 'CSS', + scss: 'SCSS', + json: 'JSON', + + yaml: 'YAML', + svg: 'SVG', + + cpp: 'C++', + csharp: 'C#', + objectivec: 'Objective-C', + + php: 'PHP', + vbnet: 'VB.NET', + + sql: 'SQL', + pgsql: 'PostgreSQL', + + x86asm: 'x86 Assembly', + armasm: 'ARM Assembly', + mipsasm: 'MIPS Assembly', + + ffm: 'Fuyeor Flavored Markdown', + fon: 'FON', +} as const; + +// 语言显示名称工具 +export function getDisplayLanguageName(lang: string): string { + if (!lang) return ''; + const lowerLang = lang.toLowerCase(); + // 优先使用特殊写法,否则自动将首字母大写 + return ( + displayNameMap[lowerLang] || + lowerLang.charAt(0).toUpperCase() + lowerLang.slice(1) + ); +} diff --git a/package/parser/src/plugin/hydrate.ts b/package/parser/src/plugin/hydrate.ts new file mode 100644 index 0000000..11599d4 --- /dev/null +++ b/package/parser/src/plugin/hydrate.ts @@ -0,0 +1,60 @@ +// @ffm/parser/src/async/hydrate.ts +import type { AsyncCapability, AsyncRenderer, HydrateOption } from '#/type'; +import { loadStyle } from './loader'; + +// Walk a container and hydrate every declared async capability in parallel. +export async function hydrate( + root: ParentNode, + renderers: readonly AsyncRenderer[], + option?: HydrateOption, +): Promise { + const acquisition = new Map>(); + const tasks: Promise[] = []; + + for (const renderer of renderers) { + if (option?.capability && !option.capability.has(renderer.name)) continue; + + const elements = root.querySelectorAll( + `${renderer.selector}:not([data-ffm-rendered])`, + ); + if (elements.length === 0) continue; + + renderer.style?.forEach(loadStyle); + + tasks.push( + run(renderer, elements, acquisition, option?.onError).catch((error) => { + option?.onError?.(renderer.name, error); + }), + ); + } + + await Promise.allSettled(tasks); +} + +async function run( + renderer: AsyncRenderer, + elements: NodeListOf, + acquisition: Map>, + onError: HydrateOption['onError'], +): Promise { + let pending = acquisition.get(renderer.name); + if (!pending) { + pending = (async () => { + if (renderer.style) await Promise.all(renderer.style.map(loadStyle)); + return renderer.load(); + })(); + acquisition.set(renderer.name, pending); + } + const lib = await pending; + + const results = await Promise.allSettled( + Array.from(elements, (element) => { + element.dataset.ffmRendered = 'true'; + return renderer.render(element, lib); + }), + ); + + for (const result of results) { + if (result.status === 'rejected') onError?.(renderer.name, result.reason); + } +} diff --git a/package/parser/src/plugin/index.ts b/package/parser/src/plugin/index.ts new file mode 100644 index 0000000..0b81cda --- /dev/null +++ b/package/parser/src/plugin/index.ts @@ -0,0 +1,26 @@ +// @ffm/parser/src/async/index.ts +export { hydrate } from './hydrate'; +export { loadStyle, loadModule, loadEffect, loadScript } from './loader'; +export { + twemojiPlugin, + twemojiTransform, + transformTwemojiNode, + getTwemojiUrl, +} from './twemoji'; +export { + latexInlineRule, + latexBlockRule, + latexPlugin, + createLatex, +} from './latex'; +export { createMermaid } from './mermaid'; +export { createAbc } from './abc'; +export { createSmiles } from './smiles'; +export { + highlightTransform, + highlightPlugin, + createHighlight, +} from './highlight'; +export { highlightNameMap, getDisplayLanguageName } from './highlight/util'; + +export type { AsyncCapability, AsyncRenderer, HydrateOption } from '#/type'; diff --git a/package/parser/src/plugin/latex.ts b/package/parser/src/plugin/latex/index.ts similarity index 78% rename from package/parser/src/plugin/latex.ts rename to package/parser/src/plugin/latex/index.ts index 4936f0a..95c468c 100644 --- a/package/parser/src/plugin/latex.ts +++ b/package/parser/src/plugin/latex/index.ts @@ -1,6 +1,13 @@ -// @ffm/parser/src/plugin/latex.ts +// @ffm/parser/src/plugin/latex/index.ts import { BlockState, InlineState } from '#/core/state'; -import type { BlockRule, InlineRule, MarkdownPlugin } from '#/type'; +import { loadScript } from '#/plugin/loader'; +import type { + BlockRule, + InlineRule, + AsyncRenderer, + MarkdownPlugin, +} from '#/type'; +import type { Katex, KatexSource } from './type'; const inlineMathMarker = '$'; const blockMathMarker = '$$'; @@ -93,7 +100,24 @@ export const latexBlockRule: BlockRule = { }, }; +// Build a KaTeX renderer; CDN URLs are supplied by the host. +export const createLatex = (source: KatexSource): AsyncRenderer => ({ + name: 'latex', + selector: '[data-async="latex"]', + style: source.style, + // katex will finds `window.katex` + load: () => loadScript(source.script, 'katex'), + render(element, latex) { + latex.render(element.textContent ?? '', element, { + throwOnError: false, + output: 'html', + displayMode: element.classList.contains('math-block'), + }); + }, +}); + // Register LaTeX block and inline rules on a markdown-parser instance. export const latexPlugin: MarkdownPlugin = (parser) => { parser.addBlockRule(latexBlockRule).addInlineRule(latexInlineRule); + parser.requireCapability('latex'); }; diff --git a/package/parser/src/plugin/latex/type.ts b/package/parser/src/plugin/latex/type.ts new file mode 100644 index 0000000..0abeea4 --- /dev/null +++ b/package/parser/src/plugin/latex/type.ts @@ -0,0 +1,21 @@ +// @ffm/parser/src/plugin/latex/type.ts + +export interface Katex { + render( + text: string, + element: HTMLElement, + options?: { + displayMode?: boolean; + throwOnError?: boolean; + errorColor?: string; + macros?: Record; + colorIsTextColor?: boolean; + output?: 'html' | 'mathml' | 'htmlAndMathml'; + }, + ): void; +} + +export interface KatexSource { + script: string; + style?: readonly string[]; +} diff --git a/package/parser/src/plugin/loader.ts b/package/parser/src/plugin/loader.ts new file mode 100644 index 0000000..8242075 --- /dev/null +++ b/package/parser/src/plugin/loader.ts @@ -0,0 +1,83 @@ +// @ffm/parser/src/async/loader.ts +const scriptCache = new Map>(); +const moduleCache = new Map>(); +const styleCache = new Set(); + +// Load a classic script once and resolve the global it exposes. +export function loadScript(url: string, global: string): Promise { + const cached = scriptCache.get(url); + if (cached) return cached as Promise; + + const { promise, resolve, reject } = Promise.withResolvers(); + const element = window.document.createElement('script'); + element.src = url; + element.async = true; + element.crossOrigin = 'anonymous'; + element.addEventListener('load', () => { + const value = (window as unknown as Record)[global]; + // onload implies synchronous execution finished; a missing global is a real error. + if (value === undefined) + reject(new Error(`Global "${global}" is missing after loading "${url}"`)); + else resolve(value as T); + }); + element.addEventListener('error', () => + reject(new Error(`Failed to load script: "${url}"`)), + ); + window.document.head.append(element); + + promise.catch(() => scriptCache.delete(url)); + scriptCache.set(url, promise); + return promise; +} + +// Load a script purely for its side effects (e.g. registering into window.hljs). +export function loadEffect(url: string): Promise { + const cached = scriptCache.get(url); + if (cached) return cached.then(() => undefined); + + const { promise, resolve, reject } = Promise.withResolvers(); + const element = window.document.createElement('script'); + element.src = url; + element.async = true; + element.crossOrigin = 'anonymous'; + element.addEventListener('load', () => resolve()); + element.addEventListener('error', () => + reject(new Error(`Failed to load script: "${url}"`)), + ); + window.document.head.append(element); + + promise.catch(() => scriptCache.delete(url)); + scriptCache.set(url, promise); + return promise; +} + +// Dynamically import an ES module; Vite must not try to bundle the URL. +export function loadModule(url: string): Promise { + const cached = moduleCache.get(url); + if (cached) return cached as Promise; + + const promise = import(/* @vite-ignore */ url) as Promise; + promise.catch(() => moduleCache.delete(url)); + moduleCache.set(url, promise); + return promise; +} + +// Inject a stylesheet once; on failure drop it so the caller can retry. +export function loadStyle(url: string): Promise { + if (styleCache.has(url)) return Promise.resolve(); + styleCache.add(url); + + const { promise, resolve, reject } = Promise.withResolvers(); + const element = window.document.createElement('link'); + element.rel = 'stylesheet'; + element.crossOrigin = 'anonymous'; + element.href = url; + element.addEventListener('load', () => resolve()); + element.addEventListener('error', () => { + styleCache.delete(url); + element.remove(); + reject(new Error(`Failed to load stylesheet: "${url}"`)); + }); + window.document.head.append(element); + return promise; +} diff --git a/package/parser/src/plugin/mermaid/index.ts b/package/parser/src/plugin/mermaid/index.ts new file mode 100644 index 0000000..7daeba2 --- /dev/null +++ b/package/parser/src/plugin/mermaid/index.ts @@ -0,0 +1,41 @@ +// @ffm/parser/src/plugin/mermaid/index.ts +import { loadScript } from '#/plugin/loader'; +import { createCodeBlockTransform } from '#/plugin/ast'; +import type { AsyncRenderer, MarkdownPlugin } from '#/type'; +import type { Mermaid, MermaidSource } from './type'; + +let sequence = 0; + +// Build a Mermaid renderer with strict security enforced at initialization. +export const createMermaid = ( + source: MermaidSource, +): AsyncRenderer => ({ + name: 'mermaid', + selector: '[data-async="mermaid"]', + style: source.style, + async load() { + const mermaid = await loadScript(source.script, 'mermaid'); + mermaid.initialize({ + startOnLoad: false, + securityLevel: 'strict', // 启用严格安全模式,禁止脚本和事件 + suppressErrorRendering: true, // 禁用渲染时的语法错误提示 + }); + return mermaid; + }, + async render(element, mermaid) { + const code = element.textContent ?? ''; + if (!code.trim()) { + element.textContent = ''; + return; + } + const { svg } = await mermaid.render(`ffm-mermaid-${sequence++}`, code); + element.innerHTML = svg; + }, +}); + +export const mermaidTransform = createCodeBlockTransform('mermaid'); + +export const mermaidPlugin: MarkdownPlugin = (parser) => { + parser.addAstTransform(mermaidTransform); + parser.requireCapability('mermaid'); +}; diff --git a/package/parser/src/plugin/mermaid/type.ts b/package/parser/src/plugin/mermaid/type.ts new file mode 100644 index 0000000..df49126 --- /dev/null +++ b/package/parser/src/plugin/mermaid/type.ts @@ -0,0 +1,20 @@ +// @ffm/parser/src/plugin/mermaid/type.ts + +export interface Mermaid { + parse(code: string): Promise; + render( + id: string, + code: string, + ): Promise<{ svg: string; bindFunctions?: (element: Element) => void }>; + initialize(config: { + startOnLoad?: boolean; + securityLevel?: string; + suppressErrorRendering?: boolean; + }): void; + isInitialized?: boolean; +} + +export interface MermaidSource { + script: string; + style?: readonly string[]; +} diff --git a/package/parser/src/plugin/smiles/index.ts b/package/parser/src/plugin/smiles/index.ts new file mode 100644 index 0000000..e42e2b4 --- /dev/null +++ b/package/parser/src/plugin/smiles/index.ts @@ -0,0 +1,81 @@ +// @ffm/parser/src/plugin/smiles/index.ts +import { createCodeBlockTransform } from '#/plugin/ast'; +import type { + InlineRule, + InlineState, + AsyncRenderer, + MarkdownPlugin, +} from '#/type'; + +export interface SmilesSource { + endpoint: string; + limit?: number; +} + +const defaultLimit = 100; +const inlineRegex = /^#\[smiles\s*=\s*`([^`]+)`\]/u; + +// Parse the FFM #[smiles = `...`] inline placeholder syntax. +export const smilesInlineRule: InlineRule = { + name: 'smiles_inline', + marker: ['#'], + parse(state: InlineState) { + if (state.currentChar !== '#') return null; + + const match = state.content.slice(state.pos).match(inlineRegex); + if (!match) return null; + + return { + node: { type: 'smiles_inline', value: match[1].trim() }, + consumedChars: match[0].length, + }; + }, +}; + +// 块级规则 +export const smilesBlockTransform = createCodeBlockTransform('smiles_block'); + +// Build a SMILES renderer with per-code deduplication and bounded cache. +export const createSmiles = (source: SmilesSource): AsyncRenderer => { + const limit = source.limit ?? defaultLimit; + const cache = new Map>(); + + const fetchSmiles = (smiles: string): Promise => { + const existing = cache.get(smiles); + if (existing) return existing; + + const promise = window + .fetch(`${source.endpoint}?smiles=${encodeURIComponent(smiles)}`) + .then((response) => { + if (!response.ok) + throw new Error(`SMILES request failed: ${response.status}`); + return response.text(); + }); + + promise.catch(() => cache.delete(smiles)); + if (cache.size >= limit) { + const oldest = cache.keys().next().value; + if (oldest !== undefined) cache.delete(oldest); + } + cache.set(smiles, promise); + return promise; + }; + + return { + name: 'smiles', + selector: '[data-async="smiles"]', + load: () => Promise.resolve(), + async render(element) { + const smiles = element.dataset.smiles; + if (!smiles) return; + element.innerHTML = await fetchSmiles(smiles); + }, + }; +}; + +// Register both FFM inline and fenced Smiles syntax. +export const smilesPlugin: MarkdownPlugin = (parser) => { + parser.addAstTransform(smilesBlockTransform); + parser.addInlineRule(smilesInlineRule); + parser.requireCapability('smiles'); +}; diff --git a/package/parser/src/plugin/twemoji.ts b/package/parser/src/plugin/twemoji/index.ts similarity index 89% rename from package/parser/src/plugin/twemoji.ts rename to package/parser/src/plugin/twemoji/index.ts index fb01ac1..1ba6a4b 100644 --- a/package/parser/src/plugin/twemoji.ts +++ b/package/parser/src/plugin/twemoji/index.ts @@ -1,6 +1,6 @@ -// @ffm/parser/src/plugin/twemoji.ts +// @ffm/parser/src/plugin/twemoji/index.ts import type { ASTNode, ASTTransform, MarkdownPlugin } from '#/type'; -import { mapAstNodes } from './ast'; +import { mapAstNode } from '#/plugin/ast'; const r = String.raw; const baseEmojiPattern = r`\p{Emoji}(?:\p{EMod}|[\u{E0020}-\u{E007E}]+\u{E007F}|\uFE0F?\u20E3?)`; @@ -54,7 +54,7 @@ export const transformTwemojiNode = (node: ASTNode): ASTNode[] => { }; export const twemojiTransform: ASTTransform = (nodes) => - mapAstNodes(nodes, (node) => + mapAstNode(nodes, (node) => node.type === 'text' ? transformTwemojiNode(node) : node, ); @@ -62,6 +62,3 @@ export const twemojiTransform: ASTTransform = (nodes) => export const twemojiPlugin: MarkdownPlugin = (parser) => { parser.addAstTransform(twemojiTransform); }; - -// Keep the name used by the existing Interactify markdown-it integration. -export const nativeEmojiPlugin = twemojiPlugin; diff --git a/package/parser/src/rule/inline.ts b/package/parser/src/rule/inline.ts index 67385d1..df0f70d 100644 --- a/package/parser/src/rule/inline.ts +++ b/package/parser/src/rule/inline.ts @@ -81,7 +81,7 @@ export const italicRule: InlineRule = { * parse `inlineCode` syntax */ export const inlineCodeRule: InlineRule = { - name: 'inline_code', + name: 'code_inline', marker: ['`'], parse(state: InlineState) { if (state.currentChar !== '`') return null; @@ -131,7 +131,7 @@ export const inlineCodeRule: InlineRule = { return { node: { - type: isColor ? 'color_code' : 'inline_code', + type: isColor ? 'color_code' : 'code_inline', value: rawContent, }, consumedChars: endIdx + markerLength - state.pos, diff --git a/package/parser/src/test/index.spec.ts b/package/parser/src/test/index.spec.ts index 5fe6b60..e394af7 100644 --- a/package/parser/src/test/index.spec.ts +++ b/package/parser/src/test/index.spec.ts @@ -1,23 +1,19 @@ // @ffm/parser/test/index.spec.ts -// pnpm test -import { readFileSync, writeFileSync } from 'node:fs'; +// pnpm -F @ffm/parser test +import { writeFileSync } from 'node:fs'; import { resolve } from 'node:path'; import { describe, it, expect, afterAll } from 'vitest'; -import { createFuyeorMarkdownParser } from '#/default'; +import { createMarkdownParser } from '#/default'; import { render } from '#/core/render'; -const parse = createFuyeorMarkdownParser(); +// commonMark: 0.13.2 edition +import commonMark from './spec/commonMark.json' with { type: 'json' }; +// githubMark: 0.29 edition +import githubMark from './spec/githubMark.json' with { type: 'json' }; + +const parse = createMarkdownParser(); const failures: any[] = []; -// load test JSON -const commonMark = JSON.parse( - // commonMark: 0.13.2 edition - readFileSync(resolve(__dirname, './spec/commonMark.json'), 'utf-8'), -); -const githubMark = JSON.parse( - // githubMark: 0.29 edition - readFileSync(resolve(__dirname, './spec/githubMark.json'), 'utf-8'), -); /** * skip unimplemented test cases */ diff --git a/package/parser/src/type.ts b/package/parser/src/type.ts index 34e8499..d51919a 100644 --- a/package/parser/src/type.ts +++ b/package/parser/src/type.ts @@ -3,31 +3,34 @@ import type { LinkMatch } from '@ffm/linkify'; import type { MarkdownParser } from './core/parser'; import type { BlockState, InlineState } from './core/state'; +export type { BlockState, InlineState } from './core/state'; + // built-in type; plugins can extend the string union type export type NodeType = | 'root' | 'paragraph' | 'text' | 'heading' - | 'code_block' + | 'bold' + | 'italic' + | 'link' + | 'hardbreak' + | 'hr' | 'blockquote' + | 'code_block' + | 'code_inline' | 'list' | 'list_item' | 'table' | 'table_row' | 'table_cell' - | 'math_inline' - | 'math_block' | 'emoji' + | 'math_block' + | 'math_inline' | 'mermaid' - | 'abc' - | 'smiles_inline' | 'smiles_block' - | 'bold' - | 'italic' - | 'link' - | 'hardbreak' - | 'hr' + | 'smiles_inline' + | 'abc' | string; export interface ASTNode { @@ -89,3 +92,33 @@ export interface MarkdownParserOption { export type ASTTransform = (nodes: ASTNode[]) => ASTNode[]; export type MarkdownPlugin = (parser: MarkdownParser) => void; + +// Render extension +export interface RenderContext { + render(nodes?: ASTNode[]): string; + escapeHtml(value: string): string; +} + +export type NodeRenderer = (node: ASTNode, ctx: RenderContext) => string; + +export interface RenderOption { + nodeRenderer?: Record; +} + +// Async capability contract +/** Stable identifier shared between plugin declarations and async renderers. */ +export type AsyncCapability = string; + +export interface AsyncRenderer { + readonly name: AsyncCapability; + readonly selector: string; + readonly style?: readonly string[]; + load(): Promise; + render(element: HTMLElement, lib: Lib): void | Promise; +} + +export interface HydrateOption { + /** Skip capabilities that the host has not declared. */ + capability?: ReadonlySet; + onError?: (name: AsyncCapability, error: unknown) => void; +} diff --git a/package/parser/tsconfig.json b/package/parser/tsconfig.json index 0840522..2fb0992 100644 --- a/package/parser/tsconfig.json +++ b/package/parser/tsconfig.json @@ -7,6 +7,7 @@ "target": "ESNext", "module": "ESNext", "moduleResolution": "Bundler", + "types": ["node"], "lib": ["ESNext", "DOM"], "strict": true, "isolatedModules": true, @@ -14,6 +15,5 @@ "skipLibCheck": true, "noEmit": true }, - "include": ["src/**/*.ts"], - "exclude": ["src/**/*.spec.ts", "src/test/**/*.ts"] + "include": ["src/**/*.ts"] } diff --git a/package/renderer/lit/src/render.ts b/package/renderer/lit/src/render.ts index 5bea102..9fa0db9 100644 --- a/package/renderer/lit/src/render.ts +++ b/package/renderer/lit/src/render.ts @@ -54,7 +54,7 @@ export function render(node?: ASTNode[]): (TemplateResult | string | null)[] { : html`${render(node.content)}`; } - case 'inline_code': + case 'code_inline': return html`${node.value}`; case 'color_code': { @@ -84,9 +84,9 @@ export function render(node?: ASTNode[]): (TemplateResult | string | null)[] { return html`
    ${node.lang ? html`
    ${node.lang}
    ` : ''} -
    ${node.value}
    +
    ${node.value}
    `; @@ -178,9 +178,11 @@ export function render(node?: ASTNode[]): (TemplateResult | string | null)[] {
    - ${node.title && node.title.length > 0 - ? html`
    ${render(node.title)}
    ` - : ''} + ${ + node.title && node.title.length > 0 + ? html`
    ${render(node.title)}
    ` + : '' + }
    ${render(node.content)}
    diff --git a/package/renderer/vue/src/render.ts b/package/renderer/vue/src/render.ts index 8b8dbe0..a9ffc41 100644 --- a/package/renderer/vue/src/render.ts +++ b/package/renderer/vue/src/render.ts @@ -1,38 +1,87 @@ // @ffm/vue-renderer/src/render.ts -import { h, type VNode } from 'vue'; +import { Fragment, h, type VNode } from 'vue'; import { isSafeColorValue, isSafeLinkUrl, type ASTNode } from '@ffm/parser'; -export function renderToVue(nodes: ASTNode[]): (VNode | string)[] { - return nodes.map((node) => { +// 渲染子节点;缺省时返回空数组 +const content = (node: ASTNode): (VNode | string)[] => + renderToVue(node.content ?? []); + +// 读取纯文本值;缺省时返回空串 +const raw = (node: ASTNode): string => + typeof node.value === 'string' ? node.value : ''; + +// 未知或降级节点的统一出口 +const passthrough = (node: ASTNode): VNode => h('span', content(node)); + +// 表格单元格对齐:与 HTML renderer 的 align 属性保持一致 +const alignAttr = (cell: ASTNode): Record => { + const align = cell.align; + return align === 'left' || align === 'center' || align === 'right' + ? { align } + : {}; +}; + +const renderTableHead = (cells?: ASTNode[]) => + cells?.length + ? h( + 'tr', + null, + cells.map((cell) => renderTableCell('th', cell)), + ) + : null; + +const renderTableRow = (rows?: ASTNode[]) => + rows?.length + ? h( + 'tbody', + null, + rows.map((row) => + h( + 'tr', + null, + (row.content ?? []).map((cell) => renderTableCell('td', cell)), + ), + ), + ) + : null; + +const renderTableCell = (tag: 'th' | 'td', cell: ASTNode): VNode => + h(tag, alignAttr(cell), content(cell)); + +export function renderToVue(nodeArray: ASTNode[]): (VNode | string)[] { + return nodeArray.map((node) => { switch (node.type) { - case 'heading': { - const level = - typeof node.level === 'number' && - Number.isInteger(node.level) && - node.level >= 1 && - node.level <= 6 - ? node.level - : null; - return level === null - ? h('span', renderToVue(node.content || [])) - : h(`h${level}`, renderToVue(node.content || [])); - } + // Common Flavored Markdown + case 'heading': + return h(`h${node.level ?? 1}`, content(node)); case 'paragraph': - return h('p', renderToVue(node.content || [])); + return h('p', content(node)); case 'text': - return node.value || ''; // Vue 天然防 XSS,直接返回字符串 + return raw(node); case 'bold': - return h('strong', renderToVue(node.content || [])); + return h('strong', content(node)); case 'italic': - return h('em', renderToVue(node.content || [])); + return h('em', content(node)); case 'underline': - return h('u', renderToVue(node.content || [])); + return h('u', content(node)); case 'strike': - return h('del', renderToVue(node.content || [])); - case 'inline_code': - return h('code', node.value || ''); + return h('del', content(node)); + case 'link': { + const url = raw(node).trim(); + return isSafeLinkUrl(url) + ? h('a', { href: url }, content(node)) + : passthrough(node); + } + case 'hr': + return h('hr'); + case 'hardbreak': + return h('br'); + + case 'blockquote': + return h('blockquote', content(node)); + case 'color_code': { - const color = String(node.value ?? ''); + const color = raw(node); if (!isSafeColorValue(color)) return color; return h('code', { class: 'ffm-color-code' }, [ h('span', { @@ -51,95 +100,54 @@ export function renderToVue(nodes: ASTNode[]): (VNode | string)[] { color, ]); } - case 'link': { - const url = String(node.url ?? '').trim(); - return isSafeLinkUrl(url) - ? h( - 'a', - { href: url, target: '_blank', rel: 'noopener noreferrer' }, - renderToVue(node.content || []), - ) - : h('span', renderToVue(node.content || [])); - } - case 'code_block': + case 'code_inline': + return h('code', raw(node)); + case 'code_block': { + const language = node.lang; + const code = raw(node); return h('div', { class: 'code-block-wrapper' }, [ - node.lang ? h('div', { class: 'code-lang' }, node.lang) : null, + language ? h('div', { class: 'code-lang' }, language) : null, h( 'pre', - null, + language + ? { 'data-language': language, 'data-async': 'hljs' } + : null, h( 'code', - { class: node.lang ? `language-${node.lang}` : '' }, - node.value || '', + { class: language ? `language-${language}` : 'hljs' }, + code, ), ), ]); + } + case 'list': return h( node.ordered ? 'ol' : 'ul', - node.ordered && node.start && node.start !== 1 - ? { start: node.start } - : {}, - renderToVue(node.content || []), + (node.start ?? 1) !== 1 ? { start: node.start } : null, + content(node), ); case 'list_item': - return h('li', renderToVue(node.content || [])); + return h('li', content(node)); + case 'table': return h('table', null, [ - h( - 'thead', - null, - h( - 'tr', - null, - (node.header ?? []).map((cell) => - h('th', renderToVue(cell.content || [])), - ), - ), - ), - node.content && node.content.length > 0 - ? h( - 'tbody', - null, - node.content.map((row) => - h( - 'tr', - null, - (row.content ?? []).map((cell) => - h('td', renderToVue(cell.content || [])), - ), - ), - ), - ) - : null, + // @ts-ignore + node.header ? h('thead', null, renderTableHead(node.header)) : null, + renderTableRow(node.content), ]); - case 'hr': - return h('hr'); - case 'blockquote': - return h('blockquote', renderToVue(node.content || [])); - case 'hardbreak': - return h('br'); + + // Fuyeor Flavored Markdown case 'accordion': - return h( - 'div', - { class: 'ffm-accordion' }, - renderToVue(node.content || []), - ); + return h('div', { class: 'ffm-accordion' }, content(node)); case 'accordion_item': return h('details', { name: node.name }, [ - h('summary', renderToVue(node.title || [])), - h( - 'div', - { class: 'accordion-content' }, - renderToVue(node.content || []), - ), + h('summary', renderToVue(node.title ?? [])), + h('div', { class: 'accordion-content' }, content(node)), ]); + case 'chain': - return h( - 'div', - { class: 'chain-container' }, - renderToVue(node.content || []), - ); + return h('div', { class: 'chain-container' }, content(node)); case 'chain_item': { const statusClass = node.hasCheckbox ? node.isCompleted @@ -152,26 +160,78 @@ export function renderToVue(nodes: ASTNode[]): (VNode | string)[] { node.title && node.title.length > 0 ? h('div', { class: 'chain-title' }, renderToVue(node.title)) : null, - h('div', { class: 'chain-body' }, renderToVue(node.content || [])), + h('div', { class: 'chain-body' }, content(node)), ]), ]); } + case 'slide': return h('div', { class: 'slide-container-wrapper' }, [ - h( - 'div', - { class: 'slide-container' }, - renderToVue(node.content || []), - ), + h('div', { class: 'slide-container' }, content(node)), ]); case 'slide_item': + return h('div', { class: 'slide-item' }, content(node)); + + // 异步节点:属性与 HTML renderer 输出完全对齐,供 hydrate() 扫描 + case 'emoji': + return h('img', { + class: 'emoji', + draggable: 'false', + alt: String(node.alt ?? node.value ?? ''), + src: String(node.src ?? ''), + }); + + case 'math_inline': + return h( + 'span', + { class: 'math-inline', 'data-async': 'latex' }, + raw(node), + ); + case 'math_block': return h( 'div', - { class: 'slide-item' }, - renderToVue(node.content || []), + { class: 'math-block', 'data-async': 'latex' }, + raw(node), ); + + case 'mermaid': + return h( + 'div', + { class: 'language-mermaid', 'data-async': 'mermaid' }, + raw(node), + ); + + case 'smiles_inline': + return h('span', { + class: 'language-smiles smiles-inline', + 'data-async': 'smiles', + 'data-smiles': raw(node), + }); + case 'smiles_block': + return h( + Fragment, + null, + raw(node) + .split('\n') + .filter((line) => line.trim().length > 0) + .map((line) => + h('div', { + class: 'language-smiles smiles-block', + 'data-async': 'smiles', + 'data-smiles': line.trim(), + }), + ), + ); + + case 'abc': + return h( + 'div', + { class: 'language-abc', 'data-async': 'abc' }, + raw(node), + ); + default: - return h('span', renderToVue(node.content || [])); + return passthrough(node); } }); } diff --git a/playground/src/document/component/preview.vue b/playground/src/document/component/preview.vue index a3bcef0..fece923 100644 --- a/playground/src/document/component/preview.vue +++ b/playground/src/document/component/preview.vue @@ -19,13 +19,19 @@ + + diff --git a/playground/src/document/component/preview.vue b/playground/src/document/component/preview.vue index fece923..08af16d 100644 --- a/playground/src/document/component/preview.vue +++ b/playground/src/document/component/preview.vue @@ -35,6 +35,7 @@ import { import { renderToVue } from '@ffm/vue-renderer'; import { usePlaygroundSource } from '@/document/composable/usePlaygroundSource'; import { useScrollSync } from '@/document/composable/useScrollSync'; +import { formatHtml } from '@/document/util/formatter'; const emit = defineEmits<{ (event: 'scroll', percentage: number): void; @@ -85,13 +86,18 @@ const activeView = computed(() => { case 'ast': return () => h('pre', json.value); case 'html': - return () => h('pre', html.value); + return () => h('pre', formattedHtml.value); default: return () => h('div', { class: 'markdown-rendered' }, renderToVue(ast.value)); } }); +const formattedHtml = computed(() => { + if (activeTab.value !== 'html') return ''; + return formatHtml(html.value); +}); + // ast 或 tab 变化后水合异步节点(KaTeX / Mermaid / ABC / SMILES / hljs) watch( [ast, activeTab], @@ -148,6 +154,8 @@ defineExpose({ scrollToPercentage, html }); z-index: 9; margin: 0; display: flex; + /* 不参与剩余高度分配 */ + flex: 0 0 auto; position: sticky; border: none; top: 0; @@ -188,9 +196,12 @@ defineExpose({ scrollToPercentage, html }); } } +/* 只在这一块滚动,高度由 flex 决定 */ .output-content { + flex: 1 1 auto; + min-height: 0; + height: auto; padding: 12px 12px; - height: 100vh; overflow-y: auto; pre { diff --git a/playground/src/document/util/formatter.ts b/playground/src/document/util/formatter.ts new file mode 100644 index 0000000..0408bbb --- /dev/null +++ b/playground/src/document/util/formatter.ts @@ -0,0 +1,76 @@ +// @/document/util/formatter.ts + +// prettier-ignore +const voidElement = new Set([ + 'area', 'base', 'br', 'col', 'embed', 'hr', 'img', + 'input', 'link', 'meta', 'source', 'track', 'wbr', +]); + +const preElement = new Set(['pre', 'textarea']); + +// prettier-ignore +const inlineElement = new Set([ + 'a', 'b', 'code', 'em', 'i', 's', 'small', 'span', 'strong', 'sub', 'sup', +]); + +function isInlineOnly(element: Element): boolean { + for (const child of element.childNodes) { + if (child.nodeType === Node.ELEMENT_NODE) { + const tag = (child as Element).tagName.toLowerCase(); + if (!inlineElement.has(tag)) return false; + } + } + return true; +} + +function serializeNode(node: Node, depth = 0): string { + const indent = ' '.repeat(depth); + + if (node.nodeType === Node.TEXT_NODE) { + const text = node.textContent?.trim() ?? ''; + return text ? `${indent}${text}\n` : ''; + } + + if (node.nodeType === Node.ELEMENT_NODE) { + const element = node as Element; + const tag = element.tagName.toLowerCase(); + const attrs = element + .getAttributeNames() + .map((name) => ` ${name}="${element.getAttribute(name)}"`) + .join(''); + + if (voidElement.has(tag)) return `${indent}<${tag}${attrs}>\n`; + if (preElement.has(tag)) + return `${indent}<${tag}${attrs}>${element.innerHTML}\n`; + + if (isInlineOnly(element)) { + return `${indent}<${tag}${attrs}>${element.innerHTML.trim()}\n`; + } + + let inner = ''; + for (const child of element.childNodes) { + inner += serializeNode(child, depth + 1); + } + + return `${indent}<${tag}${attrs}>\n${inner}${indent}\n`; + } + + return ''; +} + +/** + * format HTML using