Refactor loading remark plugins from tsconfig.json (#383)

`@mdx-js/language-service` now exposes a function
`resolveRemarkPlugins`, which resolves remark plugins in a environment
agnostic manner.

The language server implements Node.js specific logic to resolve this
from `tsconfig.json`.

.changeset/afraid-dodos-rhyme.md

@@ -0,0 +1,5 @@
+---
+"@mdx-js/language-service": patch
+---
+
+Expose function `resolveRemarkPlugins`

packages/language-server/index.js

@@ -1,21 +1,33 @@
 #!/usr/bin/env node
+
+/**
+ * @typedef {import('unified').PluggableList} PluggableList
+ * @typedef {import('unified').Plugin} Plugin
+ */
+
 import assert from 'node:assert'
+import path from 'node:path'
 import process from 'node:process'
 import {
   createMdxLanguagePlugin,
-  createMdxServicePlugin
+  createMdxServicePlugin,
+  resolveRemarkPlugins
 } from '@mdx-js/language-service'
 import {
   createConnection,
   createNodeServer,
   createTypeScriptProjectProvider
 } from '@volar/language-server/node.js'
+import {loadPlugin} from 'load-plugin'
+import remarkFrontmatter from 'remark-frontmatter'
+import remarkGfm from 'remark-gfm'
 import {create as createMarkdownServicePlugin} from 'volar-service-markdown'
 import {create as createTypeScriptServicePlugin} from 'volar-service-typescript'
-import {loadPlugins} from './lib/configuration.js'
 
 process.title = 'mdx-language-server'
 
+/** @type {PluggableList} */
+const defaultPlugins = [[remarkFrontmatter, ['toml', 'yaml']], remarkGfm]
 const connection = createConnection()
 const server = createNodeServer(connection)
 
@@ -45,14 +57,37 @@ connection.onInitialize((parameters) =>
     },
 
     async getLanguagePlugins(serviceEnvironment, projectContext) {
-      assert(server.modules.typescript, 'TypeScript module is missing')
+      const ts = server.modules.typescript
+      assert(ts, 'TypeScript module is missing')
+
+      const configFileName = projectContext?.typescript?.configFileName
+
+      /** @type {PluggableList | undefined} */
+      let plugins
 
-      const plugins = await loadPlugins(
-        projectContext?.typescript?.configFileName,
-        server.modules.typescript
-      )
+      if (configFileName) {
+        const cwd = path.dirname(configFileName)
+        const configSourceFile = ts.readJsonConfigFile(
+          configFileName,
+          ts.sys.readFile
+        )
+        const commandLine = ts.parseJsonSourceFileConfigFileContent(
+          configSourceFile,
+          ts.sys,
+          cwd,
+          undefined,
+          configFileName
+        )
+        plugins = await resolveRemarkPlugins(
+          commandLine.raw?.mdx,
+          (name) =>
+            /** @type {Promise<Plugin>} */ (
+              loadPlugin(name, {prefix: 'remark', cwd})
+            )
+        )
+      }
 
-      return [createMdxLanguagePlugin(plugins)]
+      return [createMdxLanguagePlugin(plugins || defaultPlugins)]
     }
   })
 )

packages/language-service/index.js

@@ -1,2 +1,3 @@
 export {createMdxLanguagePlugin} from './lib/language-plugin.js'
 export {createMdxServicePlugin} from './lib/service-plugin.js'
+export {resolveRemarkPlugins} from './lib/tsconfig.js'

packages/language-service/lib/tsconfig.js

@@ -0,0 +1,60 @@
+/**
+ * @typedef {import('typescript').ParsedCommandLine} ParsedCommandLine
+ * @typedef {import('unified').Pluggable} Pluggable
+ * @typedef {import('unified').PluggableList} PluggableList
+ * @typedef {import('unified').Plugin} Plugin
+ */
+
+/**
+ * Resolve remark plugins from TypeScript’s parsed command line options.
+ *
+ * @param {unknown} mdxConfig
+ *   The parsed command line options from which to resolve plugins.
+ * @param {(name: string) => Plugin | PromiseLike<Plugin>} resolvePlugin
+ *   A function to resolve a single remark plugin.
+ * @returns {Promise<PluggableList | undefined>}
+ *   An array of resolved plugins, or `undefined` in case of an invalid configuration.
+ */
+export async function resolveRemarkPlugins(mdxConfig, resolvePlugin) {
+  if (
+    typeof mdxConfig !== 'object' ||
+    !mdxConfig ||
+    !('plugins' in mdxConfig)
+  ) {
+    return
+  }
+
+  const pluginConfig = mdxConfig.plugins
+
+  if (typeof pluginConfig !== 'object' || !pluginConfig) {
+    return
+  }
+
+  const pluginArray = Array.isArray(pluginConfig)
+    ? pluginConfig
+    : Object.entries(pluginConfig)
+
+  if (pluginArray.length === 0) {
+    return
+  }
+
+  /** @type {Promise<Pluggable>[]} */
+  const plugins = []
+  for (const maybeTuple of pluginArray) {
+    const [name, ...options] = Array.isArray(maybeTuple)
+      ? maybeTuple
+      : [maybeTuple]
+
+    if (typeof name !== 'string') {
+      continue
+    }
+
+    plugins.push(
+      Promise.resolve(name)
+        .then(resolvePlugin)
+        .then((plugin) => [plugin, ...options])
+    )
+  }
+
+  return Promise.all(plugins)
+}