Turn vfile messages into Rollup logs (#2682)

During compilation, plugins may log vfile messages onto the vfile. Some
integrations already handle these. The Rollup plugin did not. This
change makes the Rollup plugin handle messages.

Fatal messages are unhandled on purpose. They are supposed to be thrown.
Even if they are not thrown, Rollup’s `this.error()` throws. So instead,
those are treated as warnings.

Author: remcohaszing

packages/rollup/lib/index.js

@@ -2,6 +2,7 @@
  * @import {FormatAwareProcessors} from '@mdx-js/mdx/internal-create-format-aware-processors'
  * @import {CompileOptions} from '@mdx-js/mdx'
  * @import {FilterPattern} from '@rollup/pluginutils'
+ * @import {VFileMessage} from 'vfile-message'
  * @import * as vite from 'vite'
  */
 
@@ -78,6 +79,15 @@ export function rollup(options) {
         formatAwareProcessors.extnames.includes(file.extname)
       ) {
         const compiled = await formatAwareProcessors.process(file)
+
+        for (const message of compiled.messages) {
+          if (message.fatal === undefined || message.fatal === null) {
+            this.info(vfileToRollup(message))
+          } else {
+            this.warn(vfileToRollup(message))
+          }
+        }
+
         const code = String(compiled.value)
         return {code, map: compiled.map}
       }
@@ -86,3 +96,47 @@ export function rollup(options) {
 
   return plugin
 }
+
+/**
+ * Turn a vfile message into a Rollup log.
+ *
+ * @param {VFileMessage} message
+ *   Message.
+ * @returns {vite.Rollup.RollupLog}
+ *   Log.
+ */
+function vfileToRollup(message) {
+  /** @type {vite.Rollup.RollupLog} */
+  const log = {
+    message: message.reason,
+    cause: message
+  }
+
+  if (
+    message.line !== undefined &&
+    message.line !== null &&
+    message.column !== undefined &&
+    message.column !== null
+  ) {
+    log.loc = {
+      file: message.file,
+      line: message.line,
+      column: message.column
+    }
+  }
+
+  if (message.source || message.ruleId) {
+    let pluginCode = message.source || ''
+    if (message.ruleId) {
+      if (pluginCode) {
+        pluginCode += ':'
+      }
+
+      pluginCode += message.ruleId
+    }
+
+    log.pluginCode = pluginCode
+  }
+
+  return log
+}

packages/rollup/test/index.js

@@ -1,6 +1,8 @@
 /**
+ * @import {Root} from 'mdast'
  * @import {MDXModule} from 'mdx/types.js'
- * @import {RollupOutput} from 'rollup'
+ * @import {RollupOutput, RollupLog} from 'rollup'
+ * @import {VFileMessage} from 'vfile-message'
  */
 
 import assert from 'node:assert/strict'
@@ -125,6 +127,106 @@ test('@mdx-js/rollup', async function (t) {
     assert.match(code, /jsxs?\(/)
   })
 
+  await t.test('should log vfile messages', async () => {
+    /** @type {VFileMessage | undefined} */
+    let info
+    /** @type {VFileMessage | undefined} */
+    let withRuleId
+    /** @type {VFileMessage | undefined} */
+    let withSource
+    /** @type {VFileMessage | undefined} */
+    let withSourceAndRuleId
+    /** @type {RollupLog[]} */
+    const logs = []
+    const input = fileURLToPath(new URL('vite-entry.mdx', import.meta.url))
+
+    await rollup({
+      external: ['react/jsx-runtime'],
+      input,
+      onLog(level, log) {
+        logs.push(
+          /** @type {RollupLog} */ (
+            // Strip symbol keys
+            Object.fromEntries(Object.entries(log))
+          )
+        )
+      },
+      plugins: [
+        rollupMdx({
+          remarkPlugins: [
+            () =>
+              /**
+               * @param {Root} ast
+               */
+              (ast, file) => {
+                info = file.info('info with location', ast)
+                withSource = file.message('warning with source', {
+                  source: 'source'
+                })
+                withRuleId = file.message('warning with ruleId', {
+                  ruleId: 'rule-id'
+                })
+                withSourceAndRuleId = file.message(
+                  'warning with source and ruleId',
+                  {
+                    source: 'source',
+                    ruleId: 'rule-id'
+                  }
+                )
+              }
+          ]
+        })
+      ]
+    })
+
+    assert.deepEqual(logs, [
+      {
+        cause: info,
+        code: 'PLUGIN_LOG',
+        hook: 'transform',
+        id: input,
+        loc: {
+          column: 1,
+          file: input,
+          line: 1
+        },
+        message:
+          '[plugin @mdx-js/rollup] test/vite-entry.mdx (1:1): info with location',
+        plugin: '@mdx-js/rollup'
+      },
+      {
+        cause: withSource,
+        code: 'PLUGIN_WARNING',
+        hook: 'transform',
+        id: input,
+        message:
+          '[plugin @mdx-js/rollup] test/vite-entry.mdx: warning with source',
+        plugin: '@mdx-js/rollup',
+        pluginCode: 'source'
+      },
+      {
+        cause: withRuleId,
+        code: 'PLUGIN_WARNING',
+        hook: 'transform',
+        id: input,
+        message:
+          '[plugin @mdx-js/rollup] test/vite-entry.mdx: warning with ruleId',
+        plugin: '@mdx-js/rollup',
+        pluginCode: 'rule-id'
+      },
+      {
+        cause: withSourceAndRuleId,
+        code: 'PLUGIN_WARNING',
+        hook: 'transform',
+        id: input,
+        message:
+          '[plugin @mdx-js/rollup] test/vite-entry.mdx: warning with source and ruleId',
+        plugin: '@mdx-js/rollup',
+        pluginCode: 'source:rule-id'
+      }
+    ])
+  })
+
   await t.test('should support the `?raw` query', async () => {
     const result = /** @type {Array<RollupOutput>} */ (
       await build({