chore: type fixes to next mf (#2907)

Co-authored-by: ScriptedAlchemy <[email protected]>

Author: ScriptedAlchemy

packages/manifest/src/StatsManager.ts

@@ -64,7 +64,6 @@ class StatsManager {
   get fileName(): string {
     return getFileName(this._options.manifest).statsFileName;
   }
-
   private _getMetaData(
     compiler: Compiler,
     compilation: Compilation,

packages/nextjs-mf/src/loaders/helpers.ts

@@ -1,17 +1,15 @@
-import type { RuleSetRuleUnion, Loader } from '@module-federation/utilities';
+import type {
+  RuleSetRule,
+  RuleSetCondition,
+  RuleSetConditionAbsolute,
+  RuleSetUseItem,
+} from 'webpack';
 
-/**
- * This function injects a loader into the current module rule.
- * Note: This function mutates the `rule` argument.
- *
- * @param {RuleSetRuleUnion} rule - The current module rule.
- * @param {Loader} [loader={}] - The loader to be injected.
- */
-export function injectRuleLoader(rule: RuleSetRuleUnion, loader: Loader = {}) {
+export function injectRuleLoader(rule: any, loader: RuleSetUseItem = {}) {
   if (rule !== '...') {
     const _rule = rule as {
       loader?: string;
-      use?: (Loader | string)[];
+      use?: (RuleSetUseItem | string)[];
       options?: any;
     };
     if (_rule.loader) {
@@ -27,23 +25,23 @@ export function injectRuleLoader(rule: RuleSetRuleUnion, loader: Loader = {}) {
 /**
  * This function checks if the current module rule has a loader with the provided name.
  *
- * @param {RuleSetRuleUnion} rule - The current module rule.
+ * @param {RuleSetRule} rule - The current module rule.
  * @param {string} loaderName - The name of the loader to check.
  * @returns {boolean} Returns true if the current module rule has a loader with the provided name, otherwise false.
  */
-export function hasLoader(rule: RuleSetRuleUnion, loaderName: string) {
+export function hasLoader(rule: RuleSetRule, loaderName: string) {
+  //@ts-ignore
   if (rule !== '...') {
     const _rule = rule as {
       loader?: string;
-      use?: (Loader | string)[];
+      use?: (RuleSetUseItem | string)[];
       options?: any;
     };
     if (_rule.loader === loaderName) {
       return true;
     } else if (_rule.use && Array.isArray(_rule.use)) {
       for (let i = 0; i < _rule.use.length; i++) {
         const loader = _rule.use[i];
-        // check exact name, eg "url-loader" or its path "node_modules/url-loader/dist/cjs.js"
         if (
           typeof loader !== 'string' &&
           typeof loader !== 'function' &&
@@ -62,3 +60,133 @@ export function hasLoader(rule: RuleSetRuleUnion, loaderName: string) {
   }
   return false;
 }
+
+interface Resource {
+  path: string;
+  layer?: string;
+  issuerLayer?: string;
+}
+
+function matchesCondition(
+  condition:
+    | RuleSetCondition
+    | RuleSetConditionAbsolute
+    | RuleSetRule
+    | undefined,
+  resource: Resource,
+  currentPath: string,
+): boolean {
+  if (condition instanceof RegExp) {
+    return condition.test(resource.path);
+  } else if (typeof condition === 'string') {
+    return resource.path.includes(condition);
+  } else if (typeof condition === 'function') {
+    return condition(resource.path);
+  } else if (typeof condition === 'object') {
+    if ('test' in condition && condition.test) {
+      const tests = Array.isArray(condition.test)
+        ? condition.test
+        : [condition.test];
+      if (
+        !tests.some((test: RuleSetCondition) =>
+          matchesCondition(test, resource, currentPath),
+        )
+      ) {
+        return false;
+      }
+    }
+    if ('include' in condition && condition.include) {
+      const includes = Array.isArray(condition.include)
+        ? condition.include
+        : [condition.include];
+      if (
+        !includes.some((include: RuleSetCondition) =>
+          matchesCondition(include, resource, currentPath),
+        )
+      ) {
+        return false;
+      }
+    }
+    if ('exclude' in condition && condition.exclude) {
+      const excludes = Array.isArray(condition.exclude)
+        ? condition.exclude
+        : [condition.exclude];
+      if (
+        excludes.some((exclude: RuleSetCondition) =>
+          matchesCondition(exclude, resource, currentPath),
+        )
+      ) {
+        return false;
+      }
+    }
+    if ('and' in condition && condition.and) {
+      return condition.and.every((cond: RuleSetCondition) =>
+        matchesCondition(cond, resource, currentPath),
+      );
+    }
+    if ('or' in condition && condition.or) {
+      return condition.or.some((cond: RuleSetCondition) =>
+        matchesCondition(cond, resource, currentPath),
+      );
+    }
+    if ('not' in condition && condition.not) {
+      return !matchesCondition(condition.not, resource, currentPath);
+    }
+    if ('layer' in condition && condition.layer) {
+      if (
+        !resource.layer ||
+        !matchesCondition(
+          condition.layer,
+          { path: resource.layer },
+          currentPath,
+        )
+      ) {
+        return false;
+      }
+    }
+    if ('issuerLayer' in condition && condition.issuerLayer) {
+      if (
+        !resource.issuerLayer ||
+        !matchesCondition(
+          condition.issuerLayer,
+          { path: resource.issuerLayer },
+          currentPath,
+        )
+      ) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+export function findLoaderForResource(
+  rules: RuleSetRule[],
+  resource: Resource,
+  path: string[] = [],
+): RuleSetRule | null {
+  let lastMatchedRule: RuleSetRule | null = null;
+  for (let i = 0; i < rules.length; i++) {
+    const rule = rules[i];
+    const currentPath = [...path, `rules[${i}]`];
+    if (rule.oneOf) {
+      for (let j = 0; j < rule.oneOf.length; j++) {
+        const subRule = rule.oneOf[j];
+        const subPath = [...currentPath, `oneOf[${j}]`];
+
+        if (
+          subRule &&
+          matchesCondition(subRule, resource, subPath.join('->'))
+        ) {
+          return subRule;
+        }
+      }
+    } else if (
+      rule &&
+      matchesCondition(rule, resource, currentPath.join(' -> '))
+    ) {
+      lastMatchedRule = rule;
+    }
+  }
+  return lastMatchedRule;
+}

packages/nextjs-mf/src/plugins/NextFederationPlugin/set-options.ts

@@ -1,9 +1,8 @@
 import {
-  ModuleFederationPluginOptions,
   NextFederationPluginExtraOptions,
   NextFederationPluginOptions,
 } from '@module-federation/utilities';
-
+import type { moduleFederationPlugin } from '@module-federation/sdk';
 /**
  * This function sets the main and extra options for NextFederationPlugin. It splits the options object into
  * the main options and extra options, and sets default values for any options that are not defined.
@@ -20,7 +19,7 @@ import {
  * - debug: false
  */
 export function setOptions(options: NextFederationPluginOptions): {
-  mainOptions: ModuleFederationPluginOptions;
+  mainOptions: moduleFederationPlugin.ModuleFederationPluginOptions;
   extraOptions: NextFederationPluginExtraOptions;
 } {
   const { extraOptions, ...mainOpts } = options;

packages/nextjs-mf/src/plugins/NextFederationPlugin/validate-options.ts

@@ -1,5 +1,5 @@
 import type { Compiler } from 'webpack';
-import { ModuleFederationPluginOptions } from '@module-federation/utilities';
+import type { moduleFederationPlugin } from '@module-federation/sdk';
 
 /**
  * Validates the compiler options.
@@ -25,15 +25,15 @@ export function validateCompilerOptions(compiler: Compiler): boolean {
 /**
  * Validates the NextFederationPlugin options.
  *
- * @param {ModuleFederationPluginOptions} options - The ModuleFederationPluginOptions instance.
+ * @param {moduleFederationPlugin.ModuleFederationPluginOptions} options - The ModuleFederationPluginOptions instance.
  *
  * @throws Will throw an error if the filename option is not defined in the options or if the name option is not specified.
  * @remarks
  * This function validates the options passed to NextFederationPlugin. It ensures that the filename and name options are defined,
  * as they are required for using Module Federation.
  */
 export function validatePluginOptions(
-  options: ModuleFederationPluginOptions,
+  options: moduleFederationPlugin.ModuleFederationPluginOptions,
 ): boolean | void {
   // Throw an error if the filename option is not defined in the options
   if (!options.filename) {

packages/nextjs-mf/src/plugins/container/InvertedContainerPlugin.ts

@@ -1,5 +1,4 @@
 import type { Compiler } from 'webpack';
-import { ModuleFederationPluginOptions } from './types';
 import EmbeddedContainerPlugin from './EmbeddedContainerPlugin';
 import { AsyncBoundaryPlugin } from '@module-federation/enhanced';
 

packages/nextjs-mf/src/plugins/container/InvertedContainerRuntimeModule.ts

@@ -65,7 +65,6 @@ class InvertedContainerRuntimeModule extends RuntimeModule {
         `return innerRemote;`,
       ]),
       `};`,
-      `${RuntimeGlobals.require}.federation.attachRemote = attachRemote;`,
       `attachRemote();`,
     ]);
   }