feat: support runtime setting options

Author: antfu

src/index.ts

@@ -1,11 +1,9 @@
 import type { Options, PresetName } from 'markdown-it'
 import MarkdownIt from 'markdown-it'
 
-export type {
-  PluginSimple,
-  PluginWithOptions,
-  PluginWithParams,
-} from 'markdown-it'
+export type PluginSimple = (md: MarkdownItAsync) => void
+export type PluginWithOptions<T = any> = (md: MarkdownItAsync, options?: T) => void
+export type PluginWithParams = (md: MarkdownItAsync, ...params: any[]) => void
 
 export interface MarkdownItAsyncOptions extends Omit<Options, 'highlight'> {
   /**
@@ -43,7 +41,14 @@ export class MarkdownItAsync extends MarkdownIt {
     this.map = map
   }
 
+  use(plugin: PluginSimple): this
+  use<T = any>(plugin: PluginWithOptions<T>, options?: T): this
+  use(plugin: PluginWithParams, ...params: any[]): this {
+    return super.use(plugin as any, ...params)
+  }
+
   async renderAsync(src: string, env?: any): Promise<string> {
+    this.options.highlight = wrapHightlight(this.options.highlight, this.map)
     const result = this.render(src, env)
     return replaceAsync(result, placeholderRe, async (match, id) => {
       if (!this.map.has(id))
@@ -91,18 +96,28 @@ export function replaceAsync(string: string, searchValue: RegExp, replacer: (...
   }
 }
 
+type NotNull<T> = T extends null | undefined ? never : T
+
+const wrappedSet = new WeakSet<NotNull<Options['highlight']>>()
+
 function wrapHightlight(highlight: MarkdownItAsyncOptions['highlight'], map: MarkdownItASyncPlaceholderMap): Options['highlight'] {
   if (!highlight)
     return undefined
 
-  return (str, lang, attrs) => {
+  if (wrappedSet.has(highlight as any))
+    return highlight as any
+
+  const wrapped: NotNull<Options['highlight']> = (str, lang, attrs) => {
     const promise = highlight(str, lang, attrs)
     if (typeof promise === 'string')
       return promise
     const id = randStr()
     map.set(id, [promise, str, lang, attrs])
     return placeholder(id)
   }
+
+  wrappedSet.add(wrapped)
+  return wrapped
 }
 
 export default createMarkdownItAsync

test/index.test.ts

@@ -1,10 +1,20 @@
 import createMarkdownIt from 'markdown-it'
 import { codeToHtml, createHighlighter } from 'shiki'
-import { expect, it } from 'vitest'
+import { describe, expect, it } from 'vitest'
 import createMarkdownItAsync from '../src/'
 
-it('exported', async () => {
-  const shiki = await createHighlighter({
+const fixture = `
+# Hello
+
+Some code 
+
+\`\`\`ts
+console.log('Hello')
+\`\`\`
+`
+
+describe('markdown-it-async', async () => {
+  using shiki = await createHighlighter({
     themes: ['vitesse-light'],
     langs: ['ts'],
   })
@@ -14,27 +24,35 @@ it('exported', async () => {
       return shiki.codeToHtml(str, { lang, theme: 'vitesse-light' })
     },
   })
-  const mda = createMarkdownItAsync({
-    async highlight(str, lang) {
-      return await codeToHtml(str, {
-        lang,
-        theme: 'vitesse-light',
-      })
-    },
-  })
+  const expectedResult = mds.render(fixture)
 
-  const fixture = `
-# Hello
+  it('exported', async () => {
+    const mda = createMarkdownItAsync({
+      async highlight(str, lang) {
+        return await codeToHtml(str, {
+          lang,
+          theme: 'vitesse-light',
+        })
+      },
+    })
 
-Some code 
+    expect(expectedResult)
+      .toEqual(await mda.renderAsync(fixture))
+  })
 
-\`\`\`ts
-console.log('Hello')
-\`\`\`
-`
+  it('via optons set', async () => {
+    const mda = createMarkdownItAsync()
 
-  const result1 = mds.render(fixture)
-  const result2 = await mda.renderAsync(fixture)
+    mda.use((md) => {
+      // @ts-expect-error cast, not yet have a solution to override this type
+      md.options.highlight = async (str, lang) => {
+        return await codeToHtml(str, {
+          lang,
+          theme: 'vitesse-light',
+        })
+      }
+    })
 
-  expect(result1).toEqual(result2)
+    expect(expectedResult).toEqual(await mda.renderAsync(fixture))
+  })
 })