feat: shareable runtime

.changeset/wild-guests-wonder.md

@@ -0,0 +1,5 @@
+---
+'@module-federation/enhanced': patch
+---
+
+support minimal runtime and use-host experimental option on federationRuntime

.vscode/launch.json

@@ -103,6 +103,18 @@
       "request": "launch",
       "type": "node-terminal"
     },
+    {
+      "name": "Run home_app",
+      "type": "node",
+      "request": "launch",
+      "program": "${workspaceFolder}/path/to/your/home_app.js",
+      "args": [],
+      "console": "integratedTerminal",
+      "runtimeExecutable": "nx",
+      "runtimeArgs": ["run", "3000-home:serve:development"],
+      "preLaunchTask": "pnpm build",
+      "skipFiles": ["<node_internals>/**"]
+    },
     {
       "command": "npm run app:next:prod",
       "name": "Run app:next:prod",

.vscode/tasks.json

@@ -0,0 +1,11 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "pnpm build",
+      "type": "shell",
+      "command": "pnpm run build",
+      "problemMatcher": []
+    },
+  ]
+}

packages/enhanced/src/lib/container/AsyncBoundaryPlugin.ts

@@ -1,3 +1,7 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Zackary Jackson @ScriptedAlchemy
+*/
 import { normalizeWebpackPath } from '@module-federation/sdk/normalize-webpack-path';
 import { moduleFederationPlugin } from '@module-federation/sdk';
 import type {

packages/enhanced/src/lib/container/ContainerEntryDependency.ts

@@ -20,7 +20,6 @@ class ContainerEntryDependency extends Dependency {
   public exposes: [string, ExposeOptions][];
   public shareScope: string;
   public injectRuntimeEntry: string;
-  /** Additional experimental options for container plugin customization */
   public experiments: containerPlugin.ContainerPluginOptions['experiments'];
 
   /**

packages/enhanced/src/lib/container/ContainerPlugin.ts

@@ -8,33 +8,25 @@ import ContainerEntryModuleFactory from './ContainerEntryModuleFactory';
 import ContainerExposedDependency from './ContainerExposedDependency';
 import { parseOptions } from './options';
 import type {
-  optimize,
   Compiler,
   Compilation,
   WebpackError,
   WebpackPluginInstance,
+  WebpackPluginFunction,
 } from 'webpack';
 import type { containerPlugin } from '@module-federation/sdk';
 import FederationRuntimePlugin from './runtime/FederationRuntimePlugin';
 import FederationModulesPlugin from './runtime/FederationModulesPlugin';
 import checkOptions from '../../schemas/container/ContainerPlugin.check';
 import schema from '../../schemas/container/ContainerPlugin';
 import FederationRuntimeDependency from './runtime/FederationRuntimeDependency';
+import type { OptimizationSplitChunksCacheGroup } from 'webpack/lib/optimize/SplitChunksPlugin';
+import type { Falsy } from 'webpack/declarations/WebpackOptions';
 
 const ModuleDependency = require(
   normalizeWebpackPath('webpack/lib/dependencies/ModuleDependency'),
 ) as typeof import('webpack/lib/dependencies/ModuleDependency');
 
-type ExcludeUndefined<T> = T extends undefined ? never : T;
-type NonUndefined<T> = ExcludeUndefined<T>;
-
-type OptimizationSplitChunksOptions = NonUndefined<
-  ConstructorParameters<typeof optimize.SplitChunksPlugin>[0]
->;
-
-type CacheGroups = OptimizationSplitChunksOptions['cacheGroups'];
-type CacheGroup = NonUndefined<CacheGroups>[string];
-
 const createSchemaValidation = require(
   normalizeWebpackPath('webpack/lib/util/create-schema-validation'),
 ) as typeof import('webpack/lib/util/create-schema-validation');
@@ -80,16 +72,21 @@ class ContainerPlugin {
     };
   }
 
-  // container should not be affected by splitChunks
   static patchChunkSplit(compiler: Compiler, name: string): void {
     const { splitChunks } = compiler.options.optimization;
-    const patchChunkSplit = (cacheGroup: CacheGroup) => {
+    const patchChunkSplit = (
+      cacheGroup:
+        | string
+        | false
+        | ((...args: any[]) => any)
+        | RegExp
+        | OptimizationSplitChunksCacheGroup,
+    ) => {
       switch (typeof cacheGroup) {
         case 'boolean':
         case 'string':
         case 'function':
           break;
-        //  cacheGroup.chunks will inherit splitChunks.chunks, so you only need to modify the chunks that are set separately
         case 'object':
           {
             if (cacheGroup instanceof RegExp) {
@@ -144,23 +141,21 @@ class ContainerPlugin {
     if (!splitChunks) {
       return;
     }
-    // patch splitChunk.chunks
     patchChunkSplit(splitChunks);
 
     const cacheGroups = splitChunks.cacheGroups;
     if (!cacheGroups) {
       return;
     }
 
-    // patch splitChunk.cacheGroups[key].chunks
     Object.keys(cacheGroups).forEach((cacheGroupKey) => {
       patchChunkSplit(cacheGroups[cacheGroupKey]);
     });
   }
 
   apply(compiler: Compiler): void {
     const useModuleFederationPlugin = compiler.options.plugins.find(
-      (p: WebpackPluginInstance) => {
+      (p: Falsy | WebpackPluginInstance | WebpackPluginFunction) => {
         if (typeof p !== 'object' || !p) {
           return false;
         }
@@ -225,7 +220,7 @@ class ContainerPlugin {
               resolve(undefined);
             },
           );
-        }).catch(callback);
+        }).catch((error) => callback(error));
 
         await new Promise((resolve, reject) => {
           compilation.addInclude(
@@ -242,17 +237,15 @@ class ContainerPlugin {
               resolve(undefined);
             },
           );
-        }).catch(callback);
+        }).catch((error) => callback(error));
 
         callback();
       },
     );
 
-    // this will still be copied into child compiler, so it needs a check to avoid running hook on child
-    // we have to use finishMake in order to check the entries created and see if there are multiple runtime chunks
     compiler.hooks.finishMake.tapAsync(
       PLUGIN_NAME,
-      (compilation: Compilation, callback) => {
+      async (compilation: Compilation, callback) => {
         if (
           compilation.compiler.parentCompilation &&
           compilation.compiler.parentCompilation !== compilation
@@ -288,16 +281,46 @@ class ContainerPlugin {
 
         dep.loc = { name };
 
-        compilation.addInclude(
-          compilation.options.context || '',
-          dep,
-          { name: undefined },
-          (error: WebpackError | null | undefined) => {
-            if (error) return callback(error);
-            hooks.addContainerEntryModule.call(dep);
-            callback();
-          },
-        );
+        await new Promise<void>((resolve, reject) => {
+          compilation.addInclude(
+            compilation.options.context || '',
+            dep,
+            { name: undefined },
+            (error: WebpackError | null | undefined) => {
+              if (error) return reject(error);
+              hooks.addContainerEntryModule.call(dep);
+              resolve();
+            },
+          );
+        }).catch((error) => callback(error));
+
+        const addDependency = async (
+          dependency: FederationRuntimeDependency,
+        ) => {
+          await new Promise<void>((resolve, reject) => {
+            compilation.addInclude(
+              compiler.context,
+              dependency,
+              { name: name, runtime: runtime },
+              (err, module) => {
+                if (err) return reject(err);
+                hooks.addFederationRuntimeModule.call(dependency);
+                resolve();
+              },
+            );
+          }).catch((error) => callback(error));
+        };
+
+        if (this._options?.experiments?.federationRuntime === 'use-host') {
+          const externalRuntimeDependency =
+            federationRuntimePluginInstance.getMinimalDependency(compiler);
+          await addDependency(externalRuntimeDependency);
+        } else {
+          const federationRuntimeDependency =
+            federationRuntimePluginInstance.getDependency(compiler);
+          await addDependency(federationRuntimeDependency);
+        }
+        callback();
       },
     );
 
@@ -314,6 +337,15 @@ class ContainerPlugin {
           ContainerExposedDependency,
           normalModuleFactory,
         );
+
+        compilation.dependencyFactories.set(
+          FederationRuntimeDependency,
+          normalModuleFactory,
+        );
+        compilation.dependencyTemplates.set(
+          FederationRuntimeDependency,
+          new ModuleDependency.Template(),
+        );
       },
     );