// due to marked's soft-break behavior. The callout converter must split
// title from content correctly even when inline elements are involved.
const html = parseMarkdownToHtml('> [!note] Plain title\n> *emphasized continuation*')
expect(html).toContain('data-callout="note"')
expect(html).toContain('Plain title')
expect(html).toContain('emphasized continuation')
// Title should not include the continuation
expect(html).toMatch(/
Plain title<\/div>/)
})
it('handles title that itself contains inline emphasis', () => {
const html = parseMarkdownToHtml('> [!note] Title with *italic* word\n> body')
expect(html).toContain('data-callout="note"')
expect(html).toContain('Title with')
expect(html).toContain('
italic')
expect(html).toContain('body')
})
it('handles bare callout with no title and no body', () => {
// Edge case: just the type marker. Result should be a valid callout div
// with no title or content children — not malformed HTML.
const html = parseMarkdownToHtml('> [!note]')
expect(html).toContain('data-callout="note"')
expect(html).not.toContain('callout-title')
expect(html).not.toContain('callout-content')
expect(html).not.toContain('
')
})
})
// -----------------------------------------------------------------------------
// registerMarkdownCodeBlockProcessor
// -----------------------------------------------------------------------------
describe('registerMarkdownCodeBlockProcessor security', () => {
let app: App
let plugin: Plugin
let warnSpy: ReturnType
beforeEach(() => {
app = createTestApp()
plugin = createTestPlugin(app, 'codeblock-security-test')
plugin.load()
warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
})
afterEach(() => {
plugin.unload()
app.destroy()
warnSpy.mockRestore()
})
it('sanitizes language to prevent CSS selector injection', () => {
const handler = vi.fn()
plugin.registerMarkdownCodeBlockProcessor('foo, script', handler)
expect(warnSpy).toHaveBeenCalledWith(
expect.stringContaining('invalid characters')
)
expect(warnSpy).toHaveBeenCalledWith(
expect.stringContaining('sanitized to "fooscript"')
)
})
it('refuses registration when language sanitizes to empty string', () => {
const handler = vi.fn()
const before = getPostProcessorCount()
plugin.registerMarkdownCodeBlockProcessor('!!!@@@', handler)
expect(warnSpy).toHaveBeenCalledWith(
expect.stringContaining('empty after sanitization')
)
// Processor was NOT registered into the global registry
expect(getPostProcessorCount()).toBe(before)
})
it('refuses registration when language is empty string', () => {
const handler = vi.fn()
const before = getPostProcessorCount()
plugin.registerMarkdownCodeBlockProcessor('', handler)
expect(warnSpy).toHaveBeenCalledWith(
expect.stringContaining('empty after sanitization')
)
expect(getPostProcessorCount()).toBe(before)
})
it('returned no-op processor is safely callable', () => {
const handler = vi.fn()
const noop = plugin.registerMarkdownCodeBlockProcessor('', handler)
// Calling the returned sentinel must not throw, even with arbitrary args
expect(() => (noop as any)(document.createElement('div'), {} as any)).not.toThrow()
// And the original handler must NOT be invoked
expect(handler).not.toHaveBeenCalled()
})
it('warns when called on dead/unloaded plugin', () => {
plugin.unload()
warnSpy.mockClear()
const handler = vi.fn()
plugin.registerMarkdownCodeBlockProcessor('mylang', handler)
expect(warnSpy).toHaveBeenCalledWith(
expect.stringContaining('not loaded')
)
})
it('allows valid language names without warning', () => {
const handler = vi.fn()
plugin.registerMarkdownCodeBlockProcessor('mermaid', handler)
expect(warnSpy).not.toHaveBeenCalled()
})
it('allows hyphens and underscores in language names', () => {
const handler = vi.fn()
plugin.registerMarkdownCodeBlockProcessor('my-lang_v2', handler)
expect(warnSpy).not.toHaveBeenCalled()
})
})
describe('registerMarkdownCodeBlockProcessor handler invocation', () => {
let app: App
let plugin: Plugin
beforeEach(() => {
app = createTestApp()
plugin = createTestPlugin(app, 'codeblock-handler-test')
plugin.load()
})
afterEach(() => {
plugin.unload()
app.destroy()
})
it('awaits async handler before render returns', async () => {
const calls: string[] = []
plugin.registerMarkdownCodeBlockProcessor('mylang', async (source) => {
calls.push('start')
await new Promise((r) => setTimeout(r, 10))
calls.push(`end:${source.trim()}`)
})
const el = document.createElement('div')
await renderMarkdownToElement('```mylang\nbody\n```', el, '/', null)
expect(calls).toEqual(['start', 'end:body'])
})
it('catches sync errors from handler without breaking other processors', async () => {
const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
const otherProcessor = vi.fn()
plugin.registerMarkdownCodeBlockProcessor('mylang', () => {
throw new Error('handler explosion')
})
registerPostProcessor('other-plugin', otherProcessor, 100)
const el = document.createElement('div')
await renderMarkdownToElement('```mylang\nbody\n```\n\n# After', el, '/', null)
expect(consoleError).toHaveBeenCalledWith(
expect.stringContaining('threw synchronously'),
expect.any(Error)
)
expect(otherProcessor).toHaveBeenCalled()
consoleError.mockRestore()
})
it('catches async rejections from handler', async () => {
const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
plugin.registerMarkdownCodeBlockProcessor('mylang', async () => {
throw new Error('async handler explosion')
})
const el = document.createElement('div')
await renderMarkdownToElement('```mylang\nbody\n```', el, '/', null)
expect(consoleError).toHaveBeenCalledWith(
expect.stringContaining('rejected'),
expect.any(Error)
)
consoleError.mockRestore()
})
})
// -----------------------------------------------------------------------------
// Plugin unload integration
// -----------------------------------------------------------------------------
describe('Plugin unload clears post-processors (integration)', () => {
let app: App
let plugin: Plugin
beforeEach(() => {
app = createTestApp()
const manifest: PluginManifest = {
id: 'unload-test-plugin',
name: 'Unload Test Plugin',
version: '1.0.0',
minAppVersion: '1.0.0',
author: 'Test',
description: 'Test plugin',
}
class TestPlugin extends Plugin {
onload() {
this.registerMarkdownPostProcessor(() => {})
this.registerMarkdownPostProcessor(() => {})
}
}
plugin = new TestPlugin(app, manifest)
})
afterEach(() => {
app.destroy()
})
it('plugin.unload() clears its registered post-processors', () => {
expect(getPostProcessorCount()).toBe(0)
plugin.load()
expect(getPostProcessorCount()).toBe(2)
plugin.unload()
expect(getPostProcessorCount()).toBe(0)
})
it('plugin unload only clears its own processors, not others', () => {
registerPostProcessor('other-plugin', () => {}, 0)
expect(getPostProcessorCount()).toBe(1)
plugin.load()
expect(getPostProcessorCount()).toBe(3)
plugin.unload()
expect(getPostProcessorCount()).toBe(1)
})
it('clears N processors at once when plugin registers many', () => {
const manifest: PluginManifest = {
id: 'many-processors-plugin',
name: 'Many',
version: '1.0.0',
minAppVersion: '1.0.0',
author: 'Test',
description: '',
}
class ManyPlugin extends Plugin {
onload() {
for (let i = 0; i < 10; i++) {
this.registerMarkdownPostProcessor(() => {})
}
}
}
const many = new ManyPlugin(app, manifest)
many.load()
expect(getPostProcessorCount()).toBe(10)
many.unload()
expect(getPostProcessorCount()).toBe(0)
})
})