fix: ensure compatibility for rspack by flattening scope array in customShareInfo (#4555)

2heal1 · web-flow · commit f81bbea6501c · 2026-03-17T18:38:56.000+08:00
diff --git a/.changeset/shaggy-taxis-sneeze.md b/.changeset/shaggy-taxis-sneeze.md
@@ -0,0 +1,5 @@
+---
+'@module-federation/webpack-bundler-runtime': patch
+---
+
+fix(webpack-bundler-runtime): ensure compatibility for rspack by flattening scope array in customShareInfo
diff --git a/packages/webpack-bundler-runtime/__tests__/consumes.spec.ts b/packages/webpack-bundler-runtime/__tests__/consumes.spec.ts
@@ -371,6 +371,216 @@ describe('consumes', () => {
     expect(moduleObj.exports).toBe('factory result');
   });
 
+  test('should unwrap nested array scope for rspack compatibility', async () => {
+    // Setup
+    const mockModuleId = 'moduleId1';
+    const mockPromises: Promise<any>[] = [];
+    const mockShareKey = 'testShareKey';
+    // Rspack wraps scope in nested array: [['default']]
+    const mockShareInfo = {
+      scope: [['default']],
+      shareConfig: {
+        singleton: true,
+        requiredVersion: '1.0.0',
+      },
+    };
+
+    const mockFactory = jest.fn().mockReturnValue('factory result');
+    const mockLoadSharePromise = Promise.resolve(mockFactory);
+
+    const mockFederationInstance = {
+      loadShare: jest.fn().mockReturnValue(mockLoadSharePromise),
+    };
+
+    const mockWebpackRequire = {
+      o: jest
+        .fn()
+        .mockImplementation((obj, key) =>
+          Object.prototype.hasOwnProperty.call(obj, key),
+        ),
+      m: {},
+      c: {},
+      federation: {
+        instance: mockFederationInstance,
+      },
+    };
+
+    const mockOptions: ConsumesOptions = {
+      chunkId: 'testChunkId',
+      promises: mockPromises,
+      chunkMapping: {
+        testChunkId: [mockModuleId],
+      },
+      installedModules: {},
+      moduleToHandlerMapping: {
+        [mockModuleId]: {
+          shareKey: mockShareKey,
+          getter: jest.fn(),
+          shareInfo: mockShareInfo,
+        },
+      },
+      webpackRequire: mockWebpackRequire as any,
+    };
+
+    // Execute
+    consumes(mockOptions);
+
+    // Verify promise is added
+    expect(mockPromises.length).toBe(1);
+
+    // Wait for promise to resolve
+    await mockPromises[0];
+
+    // Verify loadShare was called with unwrapped scope
+    expect(mockFederationInstance.loadShare).toHaveBeenCalledWith(
+      mockShareKey,
+      expect.objectContaining({
+        customShareInfo: expect.objectContaining({
+          scope: ['default'], // Should be unwrapped from [['default']]
+        }),
+      }),
+    );
+
+    // Verify the original shareInfo was not mutated (customShareInfo is a copy)
+    expect(mockShareInfo.scope).toEqual([['default']]);
+  });
+
+  test('should not unwrap non-nested array scope', async () => {
+    // Setup
+    const mockModuleId = 'moduleId1';
+    const mockPromises: Promise<any>[] = [];
+    const mockShareKey = 'testShareKey';
+    // Webpack style: scope is a flat array
+    const mockShareInfo = {
+      scope: ['default'],
+      shareConfig: {
+        singleton: true,
+        requiredVersion: '1.0.0',
+      },
+    };
+
+    const mockFactory = jest.fn().mockReturnValue('factory result');
+    const mockLoadSharePromise = Promise.resolve(mockFactory);
+
+    const mockFederationInstance = {
+      loadShare: jest.fn().mockReturnValue(mockLoadSharePromise),
+    };
+
+    const mockWebpackRequire = {
+      o: jest
+        .fn()
+        .mockImplementation((obj, key) =>
+          Object.prototype.hasOwnProperty.call(obj, key),
+        ),
+      m: {},
+      c: {},
+      federation: {
+        instance: mockFederationInstance,
+      },
+    };
+
+    const mockOptions: ConsumesOptions = {
+      chunkId: 'testChunkId',
+      promises: mockPromises,
+      chunkMapping: {
+        testChunkId: [mockModuleId],
+      },
+      installedModules: {},
+      moduleToHandlerMapping: {
+        [mockModuleId]: {
+          shareKey: mockShareKey,
+          getter: jest.fn(),
+          shareInfo: mockShareInfo,
+        },
+      },
+      webpackRequire: mockWebpackRequire as any,
+    };
+
+    // Execute
+    consumes(mockOptions);
+
+    // Wait for promise to resolve
+    await mockPromises[0];
+
+    // Verify loadShare was called with unchanged scope
+    expect(mockFederationInstance.loadShare).toHaveBeenCalledWith(
+      mockShareKey,
+      expect.objectContaining({
+        customShareInfo: expect.objectContaining({
+          scope: ['default'], // Should remain unchanged
+        }),
+      }),
+    );
+  });
+
+  test('should not unwrap scope when first element is not an array', async () => {
+    // Setup
+    const mockModuleId = 'moduleId1';
+    const mockPromises: Promise<any>[] = [];
+    const mockShareKey = 'testShareKey';
+    // Edge case: scope is an array but first element is not an array
+    const mockShareInfo = {
+      scope: ['default', 'other'],
+      shareConfig: {
+        singleton: true,
+        requiredVersion: '1.0.0',
+      },
+    };
+
+    const mockFactory = jest.fn().mockReturnValue('factory result');
+    const mockLoadSharePromise = Promise.resolve(mockFactory);
+
+    const mockFederationInstance = {
+      loadShare: jest.fn().mockReturnValue(mockLoadSharePromise),
+    };
+
+    const mockWebpackRequire = {
+      o: jest
+        .fn()
+        .mockImplementation((obj, key) =>
+          Object.prototype.hasOwnProperty.call(obj, key),
+        ),
+      m: {},
+      c: {},
+      federation: {
+        instance: mockFederationInstance,
+      },
+    };
+
+    const mockOptions: ConsumesOptions = {
+      chunkId: 'testChunkId',
+      promises: mockPromises,
+      chunkMapping: {
+        testChunkId: [mockModuleId],
+      },
+      installedModules: {},
+      moduleToHandlerMapping: {
+        [mockModuleId]: {
+          shareKey: mockShareKey,
+          getter: jest.fn(),
+          shareInfo: mockShareInfo,
+        },
+      },
+      webpackRequire: mockWebpackRequire as any,
+    };
+
+    // Execute
+    consumes(mockOptions);
+
+    // Wait for promise to resolve
+    await mockPromises[0];
+
+    // Verify loadShare was called with unchanged scope
+    expect(mockFederationInstance.loadShare).toHaveBeenCalledWith(
+      mockShareKey,
+      expect.objectContaining({
+        customShareInfo: expect.objectContaining({
+          scope: ['default', 'other'], // Should remain unchanged
+        }),
+      }),
+    );
+  });
+
   test('should handle promise rejection', async () => {
     // Setup
     const mockModuleId = 'moduleId1';
diff --git a/packages/webpack-bundler-runtime/src/consumes.ts b/packages/webpack-bundler-runtime/src/consumes.ts
@@ -64,6 +64,14 @@ export function consumes(options: ConsumesOptions) {
           moduleToHandlerMapping[id];
         const usedExports = getUsedExports(webpackRequire, shareKey);
         const customShareInfo: Partial<Shared> = { ...shareInfo };
+        // compatibility for rspack, which will wrap scope with array, but webpack will not
+        // https://github.com/web-infra-dev/rspack/blob/main/packages/rspack/src/runtime/moduleFederationDefaultRuntime.js#L95
+        if (
+          Array.isArray(customShareInfo.scope) &&
+          Array.isArray(customShareInfo.scope[0])
+        ) {
+          customShareInfo.scope = customShareInfo.scope[0];
+        }
         if (usedExports) {
           customShareInfo.treeShaking = {
             usedExports,

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +'@module-federation/webpack-bundler-runtime': patch
 +---
++
 +fix(webpack-bundler-runtime): ensure compatibility for rspack by flattening scope array in customShareInfo