@module-federation/nextjs-mf 5.3.2 → 5.4.0

package/lib/dependencies/webpack/lib/sharing/utils.js

@@ -0,0 +1,104 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../../../../_virtual/_commonjsHelpers.js');
+var utils = require('../../../../_virtual/utils.js');
+require('../../../../_virtual/fs.js');
+var fs = require('../../../../_virtual/fs2.js');
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { join, dirname, readJson } = fs.__exports;
+
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+
+/**
+ * @param {string} str maybe required version
+ * @returns {boolean} true, if it looks like a version
+ */
+var isRequiredVersion = utils.__exports.isRequiredVersion = str => {
+	return /^([\d^=v<>~]|[*xX]$)/.test(str);
+};
+
+/**
+ *
+ * @param {InputFileSystem} fs file system
+ * @param {string} directory directory to start looking into
+ * @param {string[]} descriptionFiles possible description filenames
+ * @param {function(Error=, {data: object, path: string}=): void} callback callback
+ */
+const getDescriptionFile = (fs, directory, descriptionFiles, callback) => {
+	let i = 0;
+	const tryLoadCurrent = () => {
+		if (i >= descriptionFiles.length) {
+			const parentDirectory = dirname(fs, directory);
+			if (!parentDirectory || parentDirectory === directory) return callback();
+			return getDescriptionFile(
+				fs,
+				parentDirectory,
+				descriptionFiles,
+				callback
+			);
+		}
+		const filePath = join(fs, directory, descriptionFiles[i]);
+		readJson(fs, filePath, (err, data) => {
+			if (err) {
+				if ("code" in err && err.code === "ENOENT") {
+					i++;
+					return tryLoadCurrent();
+				}
+				return callback(err);
+			}
+			if (!data || typeof data !== "object" || Array.isArray(data)) {
+				return callback(
+					new Error(`Description file ${filePath} is not an object`)
+				);
+			}
+			callback(null, { data, path: filePath });
+		});
+	};
+	tryLoadCurrent();
+};
+var getDescriptionFile_1 = utils.__exports.getDescriptionFile = getDescriptionFile;
+
+var getRequiredVersionFromDescriptionFile = utils.__exports.getRequiredVersionFromDescriptionFile = (data, packageName) => {
+	if (
+		data.optionalDependencies &&
+		typeof data.optionalDependencies === "object" &&
+		packageName in data.optionalDependencies
+	) {
+		return data.optionalDependencies[packageName];
+	}
+	if (
+		data.dependencies &&
+		typeof data.dependencies === "object" &&
+		packageName in data.dependencies
+	) {
+		return data.dependencies[packageName];
+	}
+	if (
+		data.peerDependencies &&
+		typeof data.peerDependencies === "object" &&
+		packageName in data.peerDependencies
+	) {
+		return data.peerDependencies[packageName];
+	}
+	if (
+		data.devDependencies &&
+		typeof data.devDependencies === "object" &&
+		packageName in data.devDependencies
+	) {
+		return data.devDependencies[packageName];
+	}
+};
+
+exports["default"] = utils.__exports;
+exports.getDescriptionFile = getDescriptionFile_1;
+exports.getRequiredVersionFromDescriptionFile = getRequiredVersionFromDescriptionFile;
+exports.isRequiredVersion = isRequiredVersion;

package/lib/dependencies/webpack/lib/util/fs.js

@@ -0,0 +1,359 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../../../../_virtual/_commonjsHelpers.js');
+var fs = require('../../../../_virtual/fs2.js');
+require('../../../../_virtual/_path.js');
+var path$1 = require('path');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path$1);
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const path = path__default["default"];
+
+/** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
+/** @typedef {import("../FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+
+/**
+ * @typedef {Object} IStats
+ * @property {() => boolean} isFile
+ * @property {() => boolean} isDirectory
+ * @property {() => boolean} isBlockDevice
+ * @property {() => boolean} isCharacterDevice
+ * @property {() => boolean} isSymbolicLink
+ * @property {() => boolean} isFIFO
+ * @property {() => boolean} isSocket
+ * @property {number | bigint} dev
+ * @property {number | bigint} ino
+ * @property {number | bigint} mode
+ * @property {number | bigint} nlink
+ * @property {number | bigint} uid
+ * @property {number | bigint} gid
+ * @property {number | bigint} rdev
+ * @property {number | bigint} size
+ * @property {number | bigint} blksize
+ * @property {number | bigint} blocks
+ * @property {number | bigint} atimeMs
+ * @property {number | bigint} mtimeMs
+ * @property {number | bigint} ctimeMs
+ * @property {number | bigint} birthtimeMs
+ * @property {Date} atime
+ * @property {Date} mtime
+ * @property {Date} ctime
+ * @property {Date} birthtime
+ */
+
+/**
+ * @typedef {Object} IDirent
+ * @property {() => boolean} isFile
+ * @property {() => boolean} isDirectory
+ * @property {() => boolean} isBlockDevice
+ * @property {() => boolean} isCharacterDevice
+ * @property {() => boolean} isSymbolicLink
+ * @property {() => boolean} isFIFO
+ * @property {() => boolean} isSocket
+ * @property {string | Buffer} name
+ */
+
+/** @typedef {function((NodeJS.ErrnoException | null)=): void} Callback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, Buffer=): void} BufferCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, Buffer|string=): void} BufferOrStringCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, (string | Buffer)[] | IDirent[]=): void} DirentArrayCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, string=): void} StringCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, number=): void} NumberCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, IStats=): void} StatsCallback */
+/** @typedef {function((NodeJS.ErrnoException | Error | null)=, any=): void} ReadJsonCallback */
+/** @typedef {function((NodeJS.ErrnoException | Error | null)=, IStats|string=): void} LstatReadlinkAbsoluteCallback */
+
+/**
+ * @typedef {Object} WatcherInfo
+ * @property {Set<string>} changes get current aggregated changes that have not yet send to callback
+ * @property {Set<string>} removals get current aggregated removals that have not yet send to callback
+ * @property {Map<string, FileSystemInfoEntry | "ignore">} fileTimeInfoEntries get info about files
+ * @property {Map<string, FileSystemInfoEntry | "ignore">} contextTimeInfoEntries get info about directories
+ */
+
+// TODO webpack 6 deprecate missing getInfo
+/**
+ * @typedef {Object} Watcher
+ * @property {function(): void} close closes the watcher and all underlying file watchers
+ * @property {function(): void} pause closes the watcher, but keeps underlying file watchers alive until the next watch call
+ * @property {function(): Set<string>=} getAggregatedChanges get current aggregated changes that have not yet send to callback
+ * @property {function(): Set<string>=} getAggregatedRemovals get current aggregated removals that have not yet send to callback
+ * @property {function(): Map<string, FileSystemInfoEntry | "ignore">} getFileTimeInfoEntries get info about files
+ * @property {function(): Map<string, FileSystemInfoEntry | "ignore">} getContextTimeInfoEntries get info about directories
+ * @property {function(): WatcherInfo=} getInfo get info about timestamps and changes
+ */
+
+/**
+ * @callback WatchMethod
+ * @param {Iterable<string>} files watched files
+ * @param {Iterable<string>} directories watched directories
+ * @param {Iterable<string>} missing watched exitance entries
+ * @param {number} startTime timestamp of start time
+ * @param {WatchOptions} options options object
+ * @param {function(Error=, Map<string, FileSystemInfoEntry | "ignore">, Map<string, FileSystemInfoEntry | "ignore">, Set<string>, Set<string>): void} callback aggregated callback
+ * @param {function(string, number): void} callbackUndelayed callback when the first change was detected
+ * @returns {Watcher} a watcher
+ */
+
+// TODO webpack 6 make optional methods required
+
+/**
+ * @typedef {Object} OutputFileSystem
+ * @property {function(string, Buffer|string, Callback): void} writeFile
+ * @property {function(string, Callback): void} mkdir
+ * @property {function(string, DirentArrayCallback): void=} readdir
+ * @property {function(string, Callback): void=} rmdir
+ * @property {function(string, Callback): void=} unlink
+ * @property {function(string, StatsCallback): void} stat
+ * @property {function(string, StatsCallback): void=} lstat
+ * @property {function(string, BufferOrStringCallback): void} readFile
+ * @property {(function(string, string): string)=} join
+ * @property {(function(string, string): string)=} relative
+ * @property {(function(string): string)=} dirname
+ */
+
+/**
+ * @typedef {Object} InputFileSystem
+ * @property {function(string, BufferOrStringCallback): void} readFile
+ * @property {(function(string, ReadJsonCallback): void)=} readJson
+ * @property {function(string, BufferOrStringCallback): void} readlink
+ * @property {function(string, DirentArrayCallback): void} readdir
+ * @property {function(string, StatsCallback): void} stat
+ * @property {function(string, StatsCallback): void=} lstat
+ * @property {(function(string, BufferOrStringCallback): void)=} realpath
+ * @property {(function(string=): void)=} purge
+ * @property {(function(string, string): string)=} join
+ * @property {(function(string, string): string)=} relative
+ * @property {(function(string): string)=} dirname
+ */
+
+/**
+ * @typedef {Object} WatchFileSystem
+ * @property {WatchMethod} watch
+ */
+
+/**
+ * @typedef {Object} IntermediateFileSystemExtras
+ * @property {function(string): void} mkdirSync
+ * @property {function(string): NodeJS.WritableStream} createWriteStream
+ * @property {function(string, string, NumberCallback): void} open
+ * @property {function(number, Buffer, number, number, number, NumberCallback): void} read
+ * @property {function(number, Callback): void} close
+ * @property {function(string, string, Callback): void} rename
+ */
+
+/** @typedef {InputFileSystem & OutputFileSystem & IntermediateFileSystemExtras} IntermediateFileSystem */
+
+/**
+ *
+ * @param {InputFileSystem|OutputFileSystem|undefined} fs a file system
+ * @param {string} rootPath the root path
+ * @param {string} targetPath the target path
+ * @returns {string} location of targetPath relative to rootPath
+ */
+const relative = (fs, rootPath, targetPath) => {
+	if (fs && fs.relative) {
+		return fs.relative(rootPath, targetPath);
+	} else if (path.posix.isAbsolute(rootPath)) {
+		return path.posix.relative(rootPath, targetPath);
+	} else if (path.win32.isAbsolute(rootPath)) {
+		return path.win32.relative(rootPath, targetPath);
+	} else {
+		throw new Error(
+			`${rootPath} is neither a posix nor a windows path, and there is no 'relative' method defined in the file system`
+		);
+	}
+};
+var relative_1 = fs.__exports.relative = relative;
+
+/**
+ * @param {InputFileSystem|OutputFileSystem|undefined} fs a file system
+ * @param {string} rootPath a path
+ * @param {string} filename a filename
+ * @returns {string} the joined path
+ */
+const join = (fs, rootPath, filename) => {
+	if (fs && fs.join) {
+		return fs.join(rootPath, filename);
+	} else if (path.posix.isAbsolute(rootPath)) {
+		return path.posix.join(rootPath, filename);
+	} else if (path.win32.isAbsolute(rootPath)) {
+		return path.win32.join(rootPath, filename);
+	} else {
+		throw new Error(
+			`${rootPath} is neither a posix nor a windows path, and there is no 'join' method defined in the file system`
+		);
+	}
+};
+var join_1 = fs.__exports.join = join;
+
+/**
+ * @param {InputFileSystem|OutputFileSystem|undefined} fs a file system
+ * @param {string} absPath an absolute path
+ * @returns {string} the parent directory of the absolute path
+ */
+const dirname = (fs, absPath) => {
+	if (fs && fs.dirname) {
+		return fs.dirname(absPath);
+	} else if (path.posix.isAbsolute(absPath)) {
+		return path.posix.dirname(absPath);
+	} else if (path.win32.isAbsolute(absPath)) {
+		return path.win32.dirname(absPath);
+	} else {
+		throw new Error(
+			`${absPath} is neither a posix nor a windows path, and there is no 'dirname' method defined in the file system`
+		);
+	}
+};
+var dirname_1 = fs.__exports.dirname = dirname;
+
+/**
+ * @param {OutputFileSystem} fs a file system
+ * @param {string} p an absolute path
+ * @param {function(Error=): void} callback callback function for the error
+ * @returns {void}
+ */
+const mkdirp = (fs, p, callback) => {
+	fs.mkdir(p, err => {
+		if (err) {
+			if (err.code === "ENOENT") {
+				const dir = dirname(fs, p);
+				if (dir === p) {
+					callback(err);
+					return;
+				}
+				mkdirp(fs, dir, err => {
+					if (err) {
+						callback(err);
+						return;
+					}
+					fs.mkdir(p, err => {
+						if (err) {
+							if (err.code === "EEXIST") {
+								callback();
+								return;
+							}
+							callback(err);
+							return;
+						}
+						callback();
+					});
+				});
+				return;
+			} else if (err.code === "EEXIST") {
+				callback();
+				return;
+			}
+			callback(err);
+			return;
+		}
+		callback();
+	});
+};
+var mkdirp_1 = fs.__exports.mkdirp = mkdirp;
+
+/**
+ * @param {IntermediateFileSystem} fs a file system
+ * @param {string} p an absolute path
+ * @returns {void}
+ */
+const mkdirpSync = (fs, p) => {
+	try {
+		fs.mkdirSync(p);
+	} catch (err) {
+		if (err) {
+			if (err.code === "ENOENT") {
+				const dir = dirname(fs, p);
+				if (dir === p) {
+					throw err;
+				}
+				mkdirpSync(fs, dir);
+				fs.mkdirSync(p);
+				return;
+			} else if (err.code === "EEXIST") {
+				return;
+			}
+			throw err;
+		}
+	}
+};
+var mkdirpSync_1 = fs.__exports.mkdirpSync = mkdirpSync;
+
+/**
+ * @param {InputFileSystem} fs a file system
+ * @param {string} p an absolute path
+ * @param {ReadJsonCallback} callback callback
+ * @returns {void}
+ */
+const readJson = (fs, p, callback) => {
+	if ("readJson" in fs) return fs.readJson(p, callback);
+	fs.readFile(p, (err, buf) => {
+		if (err) return callback(err);
+		let data;
+		try {
+			data = JSON.parse(buf.toString("utf-8"));
+		} catch (e) {
+			return callback(e);
+		}
+		return callback(null, data);
+	});
+};
+var readJson_1 = fs.__exports.readJson = readJson;
+
+/**
+ * @param {InputFileSystem} fs a file system
+ * @param {string} p an absolute path
+ * @param {ReadJsonCallback} callback callback
+ * @returns {void}
+ */
+const lstatReadlinkAbsolute = (fs, p, callback) => {
+	let i = 3;
+	const doReadLink = () => {
+		fs.readlink(p, (err, target) => {
+			if (err && --i > 0) {
+				// It might was just changed from symlink to file
+				// we retry 2 times to catch this case before throwing the error
+				return doStat();
+			}
+			if (err || !target) return doStat();
+			const value = target.toString();
+			callback(null, join(fs, dirname(fs, p), value));
+		});
+	};
+	const doStat = () => {
+		if ("lstat" in fs) {
+			return fs.lstat(p, (err, stats) => {
+				if (err) return callback(err);
+				if (stats.isSymbolicLink()) {
+					return doReadLink();
+				}
+				callback(null, stats);
+			});
+		} else {
+			return fs.stat(p, callback);
+		}
+	};
+	if ("lstat" in fs) return doStat();
+	doReadLink();
+};
+var lstatReadlinkAbsolute_1 = fs.__exports.lstatReadlinkAbsolute = lstatReadlinkAbsolute;
+
+exports["default"] = fs.__exports;
+exports.dirname = dirname_1;
+exports.join = join_1;
+exports.lstatReadlinkAbsolute = lstatReadlinkAbsolute_1;
+exports.mkdirp = mkdirp_1;
+exports.mkdirpSync = mkdirpSync_1;
+exports.readJson = readJson_1;
+exports.relative = relative_1;

package/lib/internal.js

@@ -1,11 +1,19 @@
-import { parseOptions } from 'webpack/lib/container/options';
-import { isRequiredVersion } from 'webpack/lib/sharing/utils';
-import path from 'path';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var options = require('./dependencies/webpack/lib/container/options.js');
+var utils = require('./dependencies/webpack/lib/sharing/utils.js');
+var path = require('path');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 
 // the share scope we attach by default
 // in hosts we re-key them to prevent webpack moving the modules into their own chunks (cause eager error)
 // in remote these are marked as import:false as we always expect the host to prove them
-export const DEFAULT_SHARE_SCOPE = {
+const DEFAULT_SHARE_SCOPE = {
   react: {
     singleton: true,
     requiredVersion: false,
@@ -44,7 +52,7 @@ export const DEFAULT_SHARE_SCOPE = {
   },
 };
 // put host infront of any shared module key, so "hostreact"
-export const reKeyHostShared = (options) => {
+const reKeyHostShared = (options) => {
   return Object.entries({
     ...(options || {}),
     ...DEFAULT_SHARE_SCOPE,
@@ -68,7 +76,7 @@ export const reKeyHostShared = (options) => {
 };
 
 // split the @ syntax into url and global
-export const extractUrlAndGlobal = (urlAndGlobal) => {
+const extractUrlAndGlobal = (urlAndGlobal) => {
   const index = urlAndGlobal.indexOf('@');
   if (index <= 0 || index === urlAndGlobal.length - 1) {
     throw new Error(`Invalid request "${urlAndGlobal}"`);
@@ -77,7 +85,7 @@ export const extractUrlAndGlobal = (urlAndGlobal) => {
 };
 
 // browser template to convert remote into promise new promise and use require.loadChunk to load the chunk
-export const generateRemoteTemplate = (url, global) => {
+const generateRemoteTemplate = (url, global) => {
   return `promise new Promise(function (resolve, reject) {
     var __webpack_error__ = new Error();
     if (typeof ${global} !== 'undefined') return resolve();
@@ -132,17 +140,17 @@ export const generateRemoteTemplate = (url, global) => {
     }
     return proxy
   })`;
-}
+};
 
-const parseShareOptions = (options) => {
-  const sharedOptions = parseOptions(
-    options.shared,
+const parseShareOptions = (options$1) => {
+  const sharedOptions = options.parseOptions(
+    options$1.shared,
     (item, key) => {
       if (typeof item !== 'string')
         throw new Error('Unexpected array in shared');
       /** @type {SharedConfig} */
       const config =
-        item === key || !isRequiredVersion(item)
+        item === key || !utils.isRequiredVersion(item)
           ? {
               import: item,
             }
@@ -170,7 +178,7 @@ const parseShareOptions = (options) => {
 };
 
 // shared packages must be compiled into webpack bundle, not require() pass through
-export const internalizeSharedPackages = (options, compiler) => {
+const internalizeSharedPackages = (options, compiler) => {
   //TODO: should use this util for other areas where we read MF options from userland
   if (!options.shared) {
     return;
@@ -200,7 +208,7 @@ export const internalizeSharedPackages = (options, compiler) => {
   }
 };
 
-export const externalizedShares = Object.entries(DEFAULT_SHARE_SCOPE).reduce(
+const externalizedShares = Object.entries(DEFAULT_SHARE_SCOPE).reduce(
   (acc, item) => {
     const [key, value] = item;
     acc[key] = { ...value, import: false };
@@ -213,20 +221,20 @@ export const externalizedShares = Object.entries(DEFAULT_SHARE_SCOPE).reduce(
 );
 
 // determine output base path, derives .next folder location
-export const getOutputPath = (compiler) => {
+const getOutputPath = (compiler) => {
   const isServer = compiler.options.target !== 'client';
-  let outputPath = compiler.options.output.path.split(path.sep);
+  let outputPath = compiler.options.output.path.split(path__default["default"].sep);
   const foundIndex = outputPath.findIndex((i) => {
     return i === (isServer ? 'server' : 'static');
   });
   outputPath = outputPath
     .slice(0, foundIndex > 0 ? foundIndex : outputPath.length)
-    .join(path.sep);
+    .join(path__default["default"].sep);
 
   return outputPath;
 };
 
-export const removePlugins = [
+const removePlugins = [
   'NextJsRequireCacheHotReloader',
   'BuildManifestPlugin',
   'WellKnownErrorsPlugin',
@@ -239,3 +247,12 @@ export const removePlugins = [
   'DropClientPage',
   'ReactFreshWebpackPlugin',
 ];
+
+exports.DEFAULT_SHARE_SCOPE = DEFAULT_SHARE_SCOPE;
+exports.externalizedShares = externalizedShares;
+exports.extractUrlAndGlobal = extractUrlAndGlobal;
+exports.generateRemoteTemplate = generateRemoteTemplate;
+exports.getOutputPath = getOutputPath;
+exports.internalizeSharedPackages = internalizeSharedPackages;
+exports.reKeyHostShared = reKeyHostShared;
+exports.removePlugins = removePlugins;

package/lib/loaders/UrlNode.js

@@ -15,7 +15,7 @@
  * It was copied from
  * @see https://github.com/vercel/next.js/blob/canary/packages/next/shared/lib/router/utils/sorted-routes.ts
  */
-export class UrlNode {
+class UrlNode {
   placeholder = true;
   children = new Map();
   slugName = null;
@@ -207,3 +207,5 @@ export class UrlNode {
       ._insert(urlPaths.slice(1), slugNames, isCatchAll);
   }
 }
+
+module.exports = { UrlNode };

package/lib/loaders/patchNextClientPageLoader.js

@@ -32,7 +32,7 @@ function patchNextClientPageLoader(content) {
       class PageLoaderExtended extends PageLoader {
         constructor(buildId, assetPrefix) {
           super(buildId, assetPrefix);
-          global.mf_client = new MFClient(this);
+          global.mf_client = new MFClient(this, { mode: process.env.NODE_ENV });
         }
 
         _getPageListOriginal() {