chore: fix webpack options types (#3039)

Author: ScriptedAlchemy

packages/enhanced/src/declarations/plugins/container/WebpackOptions.d.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');
@@ -83,7 +75,14 @@ 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':
@@ -160,7 +159,7 @@ class ContainerPlugin {
 
   apply(compiler: Compiler): void {
     const useModuleFederationPlugin = compiler.options.plugins.find(
-      (p: WebpackPluginInstance) => {
+      (p: Falsy | WebpackPluginInstance | WebpackPluginFunction) => {
         if (typeof p !== 'object' || !p) {
           return false;
         }

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

@@ -42,7 +42,8 @@ class ModuleFederationPlugin implements WebpackPluginInstance {
   private _patchBundlerConfig(compiler: Compiler): void {
     const { name } = this._options;
     const MFPluginNum = compiler.options.plugins.filter(
-      (p: WebpackPluginInstance) => p && p['name'] === 'ModuleFederationPlugin',
+      (p): p is WebpackPluginInstance =>
+        !!p && (p as any).name === 'ModuleFederationPlugin',
     ).length;
     if (name && MFPluginNum < 2) {
       new compiler.webpack.DefinePlugin({

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

@@ -369,7 +369,7 @@ class FederationRuntimePlugin {
       runtimePath = runtimePath.replace('.cjs', '.esm');
     }
 
-    const alias = compiler.options.resolve.alias || {};
+    const alias: any = compiler.options.resolve.alias || {};
     alias['@module-federation/runtime$'] =
       alias['@module-federation/runtime$'] || runtimePath;
     alias['@module-federation/runtime-tools$'] =
@@ -384,7 +384,7 @@ class FederationRuntimePlugin {
 
   apply(compiler: Compiler) {
     const useModuleFederationPlugin = compiler.options.plugins.find(
-      (p: WebpackPluginInstance) => {
+      (p): p is WebpackPluginInstance & { _options?: any } => {
         if (typeof p !== 'object' || !p) {
           return false;
         }
@@ -398,7 +398,7 @@ class FederationRuntimePlugin {
     }
 
     const useContainerPlugin = compiler.options.plugins.find(
-      (p: WebpackPluginInstance) => {
+      (p): p is WebpackPluginInstance & { _options?: any } => {
         if (typeof p !== 'object' || !p) {
           return false;
         }

packages/enhanced/src/lib/container/runtime/FederationRuntimePlugin.ts

@@ -1,7 +1,12 @@
-import type { WebpackPluginInstance, Compiler } from 'webpack';
+import type {
+  WebpackPluginInstance,
+  Compiler,
+  WebpackPluginFunction,
+} from 'webpack';
 import type { moduleFederationPlugin } from '@module-federation/sdk';
 import type IModuleFederationPlugin from '../lib/container/ModuleFederationPlugin';
 import type { ResourceInfo } from '@module-federation/manifest';
+import type { Falsy } from 'webpack/declarations/WebpackOptions';
 
 import { getWebpackPath } from '@module-federation/sdk/normalize-webpack-path';
 import path from 'node:path';
@@ -23,7 +28,8 @@ export default class ModuleFederationPlugin implements WebpackPluginInstance {
   apply(compiler: Compiler) {
     if (
       !compiler.options.plugins.find(
-        (p: WebpackPluginInstance) => p && p['name'] === PLUGIN_NAME,
+        (p: WebpackPluginInstance | WebpackPluginFunction | Falsy) =>
+          p && (p as WebpackPluginInstance)['name'] === PLUGIN_NAME,
       )
     ) {
       compiler.options.plugins.push(this);

packages/enhanced/src/wrapper/ModuleFederationPlugin.ts

@@ -126,8 +126,8 @@ export class NextFederationPlugin {
 
   private validateOptions(compiler: Compiler): boolean {
     const manifestPlugin = compiler.options.plugins.find(
-      (p: WebpackPluginInstance) =>
-        p?.constructor.name === 'BuildManifestPlugin',
+      (p): p is WebpackPluginInstance =>
+        p?.constructor?.name === 'BuildManifestPlugin',
     );
 
     if (manifestPlugin) {

packages/nextjs-mf/src/plugins/NextFederationPlugin/index.ts

@@ -34,25 +34,33 @@ export const applyPathFixes = (
   pluginOptions: moduleFederationPlugin.ModuleFederationPluginOptions,
   options: any,
 ) => {
-  const match = findLoaderForResource(compiler.options.module.rules, {
-    path: path.join(compiler.context, '/something/thing.js'),
-    issuerLayer: undefined,
-    layer: undefined,
-  });
+  const match = findLoaderForResource(
+    compiler.options.module.rules as RuleSetRule[],
+    {
+      path: path.join(compiler.context, '/something/thing.js'),
+      issuerLayer: undefined,
+      layer: undefined,
+    },
+  );
 
-  compiler.options.module.rules.forEach((rule: RuleSetRule) => {
-    // next-image-loader fix which adds remote's hostname to the assets url
-    if (options.enableImageLoaderFix && hasLoader(rule, 'next-image-loader')) {
-      injectRuleLoader(rule, {
-        loader: require.resolve('../../loaders/fixImageLoader'),
-      });
-    }
+  compiler.options.module.rules.forEach((rule) => {
+    if (typeof rule === 'object' && rule !== null) {
+      const typedRule = rule as RuleSetRule;
+      // next-image-loader fix which adds remote's hostname to the assets url
+      if (
+        options.enableImageLoaderFix &&
+        hasLoader(typedRule, 'next-image-loader')
+      ) {
+        injectRuleLoader(typedRule, {
+          loader: require.resolve('../../loaders/fixImageLoader'),
+        });
+      }
 
-    // url-loader fix for which adds remote's hostname to the assets url
-    if (options.enableUrlLoaderFix && hasLoader(rule, 'url-loader')) {
-      injectRuleLoader(rule, {
-        loader: require.resolve('../../loaders/fixUrlLoader'),
-      });
+      if (options.enableUrlLoaderFix && hasLoader(typedRule, 'url-loader')) {
+        injectRuleLoader(typedRule, {
+          loader: require.resolve('../../loaders/fixUrlLoader'),
+        });
+      }
     }
   });
 
@@ -80,7 +88,6 @@ export const applyPathFixes = (
       matchCopy = { ...match };
     }
 
-    // Create the first new rule using descriptionData
     const descriptionDataRule: RuleSetRule = {
       ...matchCopy,
       descriptionData: {
@@ -90,7 +97,6 @@ export const applyPathFixes = (
       include: undefined,
     };
 
-    // Create the second new rule using test on regex for /runtimePlugin/
     const testRule: RuleSetRule = {
       ...matchCopy,
       resourceQuery: /runtimePlugin/,
@@ -99,10 +105,10 @@ export const applyPathFixes = (
     };
 
     const oneOfRule = compiler.options.module.rules.find(
-      (rule: RuleSetRule) => {
-        return rule && typeof rule === 'object' && 'oneOf' in rule;
+      (rule): rule is RuleSetRule => {
+        return !!rule && typeof rule === 'object' && 'oneOf' in rule;
       },
-    ) as RuleSetRule;
+    ) as RuleSetRule | undefined;
 
     if (!oneOfRule) {
       compiler.options.module.rules.unshift({

packages/nextjs-mf/src/plugins/NextFederationPlugin/next-fragments.ts

@@ -39,10 +39,12 @@ export class FederatedTypesPlugin {
     );
 
     if (
-      !compiler.options.plugins.some(
-        (p: WebpackPluginInstance) =>
-          SUPPORTED_PLUGINS.indexOf(p?.constructor.name ?? '') !== -1,
-      )
+      !compiler.options.plugins
+        .filter((p): p is WebpackPluginInstance => !!p)
+        .some(
+          (p: WebpackPluginInstance) =>
+            SUPPORTED_PLUGINS.indexOf(p?.constructor.name ?? '') !== -1,
+        )
     ) {
       this.logger.error(
         'Unable to find the Module Federation Plugin, this is plugin no longer provides it by default. Please add it to your webpack config.',

packages/typescript/src/plugins/FederatedTypesPlugin.ts

@@ -62,7 +62,7 @@ declare class Compiler {
   resolverFactory: ResolverFactory;
   infrastructureLogger?: (arg0: string, arg1: LogTypeEnum, arg2: any[]) => void;
   platform: Readonly<PlatformTargetProperties>;
-  options: WebpackOptionsNormalized;
+  options: WebpackOptions;
   context: string;
   requestShortener: RequestShortener;
   cache: Cache;