feat(rsbuild-plugin): apply the build engine for rslib

`rslib` was left out of the engine entirely, so a library build read none of the
Lynx config and had to mirror the parts it needed by hand.

Apply the engine there too, and gate the plugins that own the bundle — the
template, the dev server, the output layout — on the caller instead. `rslib`
assembles the bundle itself, and `rstest` has no bundle at all.

Author: upupming

.changeset/rslib-engine.md

@@ -0,0 +1,6 @@
+---
+"@lynx-js/react-rsbuild-plugin": patch
+"@lynx-js/rsbuild-plugin": patch
+---
+
+Apply the Lynx build engine for `rslib` as well, so a library build reads the Lynx config. The plugins that own the bundle — the template, the dev server, the output layout — stay off, since `rslib` assembles the bundle itself.

packages/rspeedy/plugin-lynx/src/index.ts

@@ -39,6 +39,24 @@ export type {
   LynxPluginOptions,
 } from './config.js'
 
+// `rslib` and `rstest` own the bundle themselves: an external bundle is
+// assembled and loaded by its consumer, and a test run has no bundle at all.
+// They read the engine config all the same.
+function onlyWhenTheEngineOwnsTheBundle(
+  plugins: RsbuildPlugin[],
+): RsbuildPlugin[] {
+  return plugins.map(plugin => ({
+    ...plugin,
+    setup(api) {
+      const { callerName } = api.context
+      if (callerName === 'rslib' || callerName === 'rstest') {
+        return
+      }
+      return plugin.setup(api)
+    },
+  }))
+}
+
 /**
  * @public
  */
@@ -53,18 +71,20 @@ export function pluginLynx(
       },
     },
     pluginConfig(options),
-    pluginChunkLoading(),
-    pluginCssMinimizer(),
-    pluginDev(),
-    pluginLynxDebugMetadata(),
-    pluginMinify(),
-    pluginOptimization(),
-    pluginOutput(),
-    pluginResolve(),
-    pluginServer(),
-    pluginSourcemap(),
-    pluginSwc(),
-    pluginTarget(),
-    pluginTemplate(),
+    ...onlyWhenTheEngineOwnsTheBundle([
+      pluginChunkLoading(),
+      pluginCssMinimizer(),
+      pluginDev(),
+      pluginLynxDebugMetadata(),
+      pluginMinify(),
+      pluginOptimization(),
+      pluginOutput(),
+      pluginResolve(),
+      pluginServer(),
+      pluginSourcemap(),
+      pluginSwc(),
+      pluginTarget(),
+      pluginTemplate(),
+    ]),
   ]
 }

packages/rspeedy/plugin-react/src/autoLynx.ts

@@ -22,17 +22,14 @@ function isEngineRegistered(api: RsbuildPluginAPI): boolean {
   )
 }
 
-// Rspeedy applies `pluginLynx` itself. With plain Rsbuild nothing does, so the
-// build engine is applied here to keep `pluginReactLynx` the only plugin a user
-// has to add.
+// Rspeedy applies `pluginLynx` itself. Nothing does with plain Rsbuild or
+// `rslib`, so the engine is applied here.
 export function pluginAutoLynx(): RsbuildPlugin {
   return {
     name: 'lynx:react:auto-lynx',
     async setup(api) {
-      // The callers that do not emit a Lynx template do not want the engine
-      // either. See the same condition in `applyEntry`.
-      const { callerName } = api.context
-      if (callerName === 'rslib' || callerName === 'rstest') {
+      // A test run has no bundle for the engine to configure.
+      if (api.context.callerName === 'rstest') {
         return
       }
 
@@ -43,11 +40,8 @@ export function pluginAutoLynx(): RsbuildPlugin {
       const original = api.getRsbuildConfig('original')
 
       for (const plugin of pluginLynx()) {
-        // `setup` is called directly instead of registering the plugins, since
-        // a plugin cannot add plugins. `apply` is honored here because Rsbuild
-        // only evaluates it for registered plugins.
-        // `action` is only set once a build or a server starts, and Rsbuild
-        // passes it along as-is, so it is passed along the same way here.
+        // A plugin cannot add plugins, so `setup` is called directly. That
+        // skips the `apply` Rsbuild would evaluate for a registered plugin.
         const { action } = api.context
         if (
           typeof plugin.apply === 'function'

packages/rspeedy/plugin-react/src/entry.ts

@@ -87,8 +87,6 @@ export function applyEntry(
     const emitTemplate = api.context.callerName !== 'rslib'
       && api.context.callerName !== 'rstest'
     if (emitTemplate) {
-      // `pluginAutoLynx` applies the engine for the same callers, so the config
-      // is there whenever a template is emitted.
       if (!lynxConfig) {
         throw new Error(
           'No Lynx config exposed. `pluginLynx` has to be applied for the Lynx build engine to be configured.',

packages/rspeedy/plugin-react/test/auto-lynx.test.ts

@@ -95,7 +95,8 @@ describe('pluginAutoLynx', () => {
     expect(include).toStrictEqual([...new Set(include)])
   })
 
-  test('does not apply the engine for the rslib caller', async () => {
+  test('applies the engine for the rslib caller, minus the bundle it does not own', async () => {
+    let lynxConfig: unknown
     const rsbuild = await createRsbuild({
       callerName: 'rslib',
       // eslint-disable-next-line n/no-unsupported-features/node-builtins
@@ -104,12 +105,25 @@ describe('pluginAutoLynx', () => {
         mode: 'production',
         environments: { lynx: {} },
         source: { entry: { main: './fixtures/basic.tsx' } },
-        plugins: [pluginReactLynx()],
+        plugins: [
+          pluginReactLynx(),
+          {
+            name: 'test:read-lynx-config',
+            setup(api) {
+              api.modifyBundlerChain(() => {
+                lynxConfig = api.useExposed(
+                  Symbol.for('@lynx-js/rsbuild-plugin:config'),
+                )
+              })
+            },
+          },
+        ],
       },
     })
 
     const [config] = await rsbuild.initConfigs()
 
+    expect(lynxConfig).toBeDefined()
     expect(
       config?.plugins?.some(plugin =>
         plugin?.constructor.name === 'LynxTemplatePlugin'