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

`pluginAutoLynx` skipped `rslib` because an external bundle assembles its own
`.lynx.bundle`. It reads the engine config all the same, and now drives the
template hooks too, so skipping it left `pluginLynx` to be added by hand for
either to reach an external bundle — and left `@lynx-js/lynx-bundle-rslib-config`
carrying a second set of defaults for when it was not.

Apply the engine for it, the way plain Rsbuild already gets it. `pluginLynx`
leaves out the plugins that would rewrite what an external bundle assembles, so
what it gains is the config and the plugins that tap the template hooks.

Author: upupming

.changeset/rslib-auto-lynx.md

@@ -0,0 +1,5 @@
+---
+"@lynx-js/react-rsbuild-plugin": minor
+---
+
+Apply the Lynx build engine for the `rslib` caller too, so an external bundle no longer needs `pluginLynx` added by hand.

packages/rspeedy/lynx-bundle-rslib-config/test/external-bundle.test.ts

@@ -178,10 +178,14 @@ describe('with the engine config', () => {
     })
   }
 
-  it('emits the same bytes as a build without it', async () => {
-    // A local production build ships no debug metadata, so the engine adds
-    // nothing to the bundle here. The rstest harness sets `DEBUG=rspeedy` and
-    // CI sets `CI`, either of which would opt the build back into it.
+  it('emits the same bytes whether the engine is applied by hand or not', async () => {
+    // `pluginReactLynx` applies the engine, so adding `pluginLynx` on top of it
+    // has to be a no-op rather than a second copy.
+    //
+    // A local production build ships no debug metadata, which keeps the bytes
+    // free of the build paths that differ between the two. The rstest harness
+    // sets `DEBUG=rspeedy` and CI sets `CI`, either of which would opt the
+    // build back into it.
     const restore = new Map(
       ['DEBUG', 'CI', 'CI_REPO_NAME', 'BUILD_VERSION'].map(key => {
         const value = process.env[key]
@@ -191,7 +195,7 @@ describe('with the engine config', () => {
     )
     rstest.stubEnv('NODE_ENV', 'production')
     try {
-      await build(configFor('engine-off', []))
+      await build(configFor('engine-auto', []))
       await build(configFor('engine-on', pluginLynx()))
 
       expect(
@@ -200,7 +204,7 @@ describe('with the engine config', () => {
         ),
       ).toBe(
         sha256(
-          path.join(fixtureDir, 'dist/engine-off/engine-off.lynx.bundle'),
+          path.join(fixtureDir, 'dist/engine-auto/engine-auto.lynx.bundle'),
         ),
       )
     } finally {
@@ -211,8 +215,8 @@ describe('with the engine config', () => {
     }
   })
 
-  it('runs the plugins that tap the template hooks', async () => {
-    await build(configFor('engine-debug', pluginLynx()))
+  it('runs the plugins that tap the template hooks without being applied by hand', async () => {
+    await build(configFor('engine-debug', []))
 
     const decoded = await decodeTemplate(
       path.join(fixtureDir, 'dist/engine-debug/engine-debug.lynx.bundle'),

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

@@ -36,11 +36,11 @@ export function pluginAutoLynx(): RsbuildPlugin {
   return {
     name: 'lynx:react:auto-lynx',
     async setup(api) {
-      // `rslib` and `rstest` drive the build themselves — an external bundle
-      // assembles its own `.lynx.bundle`, and a test run emits nothing — so
-      // the engine has nothing to add. See the same condition in `applyEntry`.
-      const { callerName } = api.context
-      if (callerName === 'rslib' || callerName === 'rstest') {
+      // A test run emits nothing, so the engine has nothing to add. `rslib`
+      // does emit a bundle and reads the engine config, so the engine is
+      // applied for it; `pluginLynx` leaves out the plugins that would rewrite
+      // what an external bundle assembles itself.
+      if (api.context.callerName === 'rstest') {
         return
       }
 

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

@@ -87,8 +87,8 @@ 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.
+      // `pluginAutoLynx` applies the engine for every caller that assembles a
+      // template here, so the config is there whenever one 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

@@ -77,7 +77,31 @@ 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', async () => {
+    const rsbuild = await createRsbuild({
+      callerName: 'rslib',
+      // eslint-disable-next-line n/no-unsupported-features/node-builtins
+      cwd: import.meta.dirname,
+      rsbuildConfig: {
+        mode: 'development',
+        environments: { lynx: {} },
+        source: { entry: { main: './fixtures/basic.tsx' } },
+        plugins: [pluginReactLynx()],
+      },
+    })
+
+    const [config] = await rsbuild.initConfigs()
+
+    // `pluginLynxDebugMetadata` taps the template hooks, which an external
+    // bundle drives itself, so the engine reaches it without assembling one.
+    expect(
+      config?.plugins?.some(plugin =>
+        plugin?.constructor.name === 'LynxDebugMetadataPlugin'
+      ),
+    ).toBe(true)
+  })
+
+  test('leaves out the plugins that assemble a bundle for the rslib caller', async () => {
     const rsbuild = await createRsbuild({
       callerName: 'rslib',
       // eslint-disable-next-line n/no-unsupported-features/node-builtins
@@ -97,6 +121,9 @@ describe('pluginAutoLynx', () => {
         plugin?.constructor.name === 'LynxTemplatePlugin'
       ),
     ).toBe(false)
+    // `pluginChunkLoading` loads a chunk the way a template does, which is not
+    // how an external bundle is consumed.
+    expect(config?.output?.chunkLoading).toBeUndefined()
   })
 
   test('honors the apply condition of the engine plugins', async () => {