@umijs/plugins 4.0.0-canary.20240605.1 → 4.0.0-canary.20240624.1

package/dist/initial-state.js

@@ -65,7 +65,7 @@ export default function InitialStateProvider(props: any) {
       appLoaded.current = true;
     }
   }, [loading]);
-  if (loading && !appLoaded.current && typeof window !== 'undefined') {
+  if (loading && !appLoaded.current) {
     return <Loading />;
   }
   return props.children;

package/dist/layout.js

@@ -36,6 +36,7 @@ var import_fs = require("fs");
 var import_path = require("path");
 var import_umi = require("umi");
 var import_plugin_utils = require("umi/plugin-utils");
+var import_npmClient = require("./utils/npmClient");
 var import_resolveProjectDep = require("./utils/resolveProjectDep");
 var import_withTmpPath = require("./utils/withTmpPath");
 var antIconsPath = (0, import_plugin_utils.winPath)(
@@ -118,14 +119,7 @@ var layout_default = (api) => {
     return memo;
   });
   api.onGenerateFiles(() => {
-    var _a;
-    let realNpmClient = api.appData.npmClient;
-    if (api.appData.npmClient === import_plugin_utils.NpmClientEnum.tnpm && ((_a = api.pkg.tnpm) == null ? void 0 : _a.mode) && [import_plugin_utils.NpmClientEnum.npm, import_plugin_utils.NpmClientEnum.yarn].includes(api.pkg.tnpm.mode)) {
-      realNpmClient = api.pkg.tnpm.mode;
-    }
-    const isFlattedDepsDir = [import_plugin_utils.NpmClientEnum.npm, import_plugin_utils.NpmClientEnum.yarn].includes(
-      realNpmClient
-    );
+    const isFlattedDepsDir = (0, import_npmClient.isFlattedNodeModulesDir)(api);
     const PKG_TYPE_REFERENCE = `
 /// <reference types="${isFlattedDepsDir ? ANT_PRO_COMPONENT : resolvedPkgPath}" />
 ${isFlattedDepsDir ? '/// <reference types="antd" />' : ""}

package/dist/mf-v2.d.ts

@@ -0,0 +1,52 @@
+import { zod as z } from '@umijs/utils';
+import { IApi } from 'umi';
+export declare enum EVersion {
+    v1 = "v1",
+    v2 = "v2"
+}
+interface IOptions {
+    standalone?: boolean;
+}
+export declare function configSchema(zod: typeof z): z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    remotes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        entry: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        entry: string;
+    }, {
+        name: string;
+        entry: string;
+    }>, "many">>;
+    shared: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    library: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    remoteHash: z.ZodOptional<z.ZodBoolean>;
+    version: z.ZodOptional<z.ZodEnum<[EVersion.v1, EVersion.v2]>>;
+    overrideConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    remotes?: {
+        name: string;
+        entry: string;
+    }[] | undefined;
+    shared?: Record<string, any> | undefined;
+    library?: Record<string, any> | undefined;
+    remoteHash?: boolean | undefined;
+    version?: EVersion | undefined;
+    overrideConfig?: Record<string, any> | undefined;
+}, {
+    name?: string | undefined;
+    remotes?: {
+        name: string;
+        entry: string;
+    }[] | undefined;
+    shared?: Record<string, any> | undefined;
+    library?: Record<string, any> | undefined;
+    remoteHash?: boolean | undefined;
+    version?: EVersion | undefined;
+    overrideConfig?: Record<string, any> | undefined;
+}>;
+declare const _default: (api: IApi, options?: IOptions) => void;
+export default _default;
+export declare function isValidIdentifyName(name: string): boolean;

package/dist/mf-v2.js

@@ -0,0 +1,402 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/mf-v2.ts
+var mf_v2_exports = {};
+__export(mf_v2_exports, {
+  EVersion: () => EVersion,
+  configSchema: () => configSchema,
+  default: () => mf_v2_default,
+  isValidIdentifyName: () => isValidIdentifyName
+});
+module.exports = __toCommonJS(mf_v2_exports);
+var import_bundler_utils = require("@umijs/bundler-utils");
+var import_utils = require("@umijs/utils");
+var import_fs = require("fs");
+var import_path = __toESM(require("path"));
+var { isEmpty } = import_utils.lodash;
+var EVersion = /* @__PURE__ */ ((EVersion2) => {
+  EVersion2["v1"] = "v1";
+  EVersion2["v2"] = "v2";
+  return EVersion2;
+})(EVersion || {});
+var LOGGER_LABEL = import_utils.chalk.bold.blue("[module-federation-v2]");
+function configSchema(zod) {
+  return zod.object({
+    name: zod.string(),
+    remotes: zod.array(
+      zod.object({
+        name: zod.string(),
+        entry: zod.string()
+      })
+    ),
+    shared: zod.record(zod.any()),
+    library: zod.record(zod.any()),
+    remoteHash: zod.boolean(),
+    version: zod.enum(["v1" /* v1 */, "v2" /* v2 */]),
+    overrideConfig: zod.record(zod.any())
+  }).partial();
+}
+var mf_v2_default = (api, options) => {
+  const { standalone = true } = options || {};
+  if (standalone) {
+    api.describe({
+      key: "mfV2",
+      enableBy: api.EnableBy.config,
+      config: {
+        schema({ zod }) {
+          return configSchema(zod);
+        }
+      }
+    });
+  }
+  let bundlerWebpackPath;
+  try {
+    bundlerWebpackPath = import_path.default.dirname(
+      require.resolve("@umijs/bundler-webpack/package.json")
+    );
+  } catch {
+  }
+  api.onStart(() => {
+    if (!bundlerWebpackPath) {
+      throw new Error(
+        `Not found '@umijs/bundler-webpack', please check dependencies`
+      );
+    }
+    const infoMsg = `Using module federation v2`;
+    console.log(`${LOGGER_LABEL} ${import_utils.chalk.gray(infoMsg)}`);
+    process.env.FEDERATION_WEBPACK_PATH = import_path.default.join(
+      api.paths.absTmpPath,
+      `plugin-${api.plugin.key}`,
+      "webpack/lib/index.js"
+    );
+  });
+  api.onGenerateFiles(({ isFirstTime }) => {
+    if (!isFirstTime || !bundlerWebpackPath) {
+      return;
+    }
+    const webpackPath = import_path.default.join(bundlerWebpackPath, "compiled/webpack");
+    const deepImportPath = import_path.default.join(webpackPath, "deepImports.json");
+    const deepImports = require(deepImportPath);
+    deepImports.forEach((p) => {
+      const content = `
+module.exports = require('${p}')
+`.trimStart();
+      api.writeTmpFile({
+        path: `${p}.js`,
+        content
+      });
+    });
+    const entryContent = `module.exports = require('webpack')`;
+    api.writeTmpFile({
+      path: "webpack/lib/index.js",
+      content: entryContent
+    });
+  });
+  const getConfig = () => {
+    const key = api.plugin.key;
+    const config = api.userConfig[key] || api.config[key] || {};
+    return config;
+  };
+  const constructExposes = async () => {
+    const exposes = {};
+    const exposesPath = import_path.default.join(api.paths.absSrcPath, "exposes");
+    if (!(0, import_fs.existsSync)(exposesPath)) {
+      return exposes;
+    }
+    const dir = (0, import_fs.opendirSync)(exposesPath);
+    for await (const dirent of dir) {
+      if (dirent.isDirectory()) {
+        exposes[`./${dirent.name}`] = (0, import_utils.winPath)(
+          import_path.default.join(exposesPath, dirent.name)
+        );
+      } else {
+        const warningMsg = `${dirent.name} is not a directory, ignore in ModuleFederation expose`;
+        console.log(`${LOGGER_LABEL} ${import_utils.chalk.yellow(warningMsg)}`);
+      }
+    }
+    return exposes;
+  };
+  const formatRemotes = (config) => {
+    const { remotes = [] } = config;
+    const memo = {};
+    remotes.forEach((remote) => {
+      const { name, entry } = remote;
+      if (!(name == null ? void 0 : name.length)) {
+        const errorMsg = `remote name is required`;
+        console.log(`${LOGGER_LABEL} ${import_utils.chalk.red(errorMsg)}`);
+        throw new Error(errorMsg);
+      }
+      const getFormatEntry = () => {
+        if (!(entry == null ? void 0 : entry.length)) {
+          const errorMsg = `you should provider entry for remote ${name}`;
+          console.log(`${LOGGER_LABEL} ${import_utils.chalk.red(errorMsg)}`);
+          throw new Error(errorMsg);
+        }
+        const hasAt = entry.includes("@");
+        if (hasAt) {
+          return entry;
+        }
+        return `${remote.name}@${entry}`;
+      };
+      const finalName = name;
+      const finalEntry = getFormatEntry();
+      if (memo[finalName]) {
+        const errorMsg = `remote ${finalName} is already exists, please check your config`;
+        console.log(`${LOGGER_LABEL} ${import_utils.chalk.red(errorMsg)}`);
+        throw new Error(errorMsg);
+      }
+      memo[finalName] = finalEntry;
+    });
+    return memo;
+  };
+  const getShared = (config) => {
+    const { shared = {} } = config;
+    return shared;
+  };
+  const mfAsyncEntryFileName = "asyncEntry.ts";
+  const getAppEntryFile = () => {
+    const entryFile = import_path.default.join(
+      api.paths.absTmpPath,
+      `plugin-${api.plugin.key}`,
+      mfAsyncEntryFileName
+    );
+    return (0, import_utils.winPath)(entryFile);
+  };
+  const changeUmiEntry = (config) => {
+    const { entry } = config;
+    const asyncEntryPath = getAppEntryFile();
+    if (entry.umi) {
+      if (typeof entry.umi === "string") {
+        entry.umi = asyncEntryPath;
+      } else if (Array.isArray(entry.umi)) {
+        const i = entry.umi.findIndex((f) => f.endsWith("umi.ts"));
+        if (i >= 0) {
+          entry.umi[i] = asyncEntryPath;
+        } else {
+          const warnMsg = `Not found umi entry in 'entry.umi' ${JSON.stringify(
+            entry.umi
+          )}`;
+          console.log(`${LOGGER_LABEL} ${import_utils.chalk.yellow(warnMsg)}`);
+        }
+      }
+    } else {
+      const warnMsg = `umi entry not found`;
+      console.log(`${LOGGER_LABEL} ${import_utils.chalk.yellow(warnMsg)}`);
+    }
+  };
+  const getMfName = (config) => {
+    const name = config.name;
+    const packageName = api.pkg.name;
+    const finalName = name || packageName;
+    if (!(finalName == null ? void 0 : finalName.length)) {
+      const errorMsg = `module federation name is not defined , please set 'name' in mf config or 'name' in package.json`;
+      console.log(`${LOGGER_LABEL} ${import_utils.chalk.red(errorMsg)}`);
+      throw new Error(errorMsg);
+    }
+    if (!isValidIdentifyName(finalName)) {
+      throw new Error(
+        `module federation name '${finalName}' is not valid javascript identifier.`
+      );
+    }
+    return finalName;
+  };
+  api.modifyWebpackConfig(async (config) => {
+    const pluginConfig = getConfig();
+    const exposes = await constructExposes();
+    const remotes = formatRemotes(pluginConfig);
+    const shared = getShared(pluginConfig);
+    if (isEmpty(remotes) && isEmpty(exposes)) {
+      const warnMsg = `ModuleFederation exposes and remotes are empty, plugin will not work`;
+      console.log(`${LOGGER_LABEL} ${import_utils.chalk.yellow(warnMsg)}`);
+      return config;
+    }
+    if (api.env === "production" || !api.config.mfsu) {
+      changeUmiEntry(config);
+    }
+    const name = getMfName(pluginConfig);
+    const useHash = typeof pluginConfig.remoteHash === "boolean" ? pluginConfig.remoteHash : api.config.hash && api.env !== "development";
+    const mfConfig = {
+      name,
+      remotes,
+      filename: useHash ? "remote.[contenthash:8].js" : "remote.js",
+      exposes,
+      shared,
+      library: pluginConfig.library,
+      ...pluginConfig.overrideConfig || {}
+    };
+    const checkConfig = () => {
+      if (api.config.mfsu) {
+        console.log(
+          `${LOGGER_LABEL} cannot use mfsu with module federation, please disable 'mfsu' in config (e.g. 'mfsu: false')`
+        );
+        throw new Error(`mfsu cannot use with module federation`);
+      }
+      if (!isEmpty(mfConfig.exposes)) {
+        const jsMinifier = api.config.jsMinifier || "esbuild";
+        if (jsMinifier === "esbuild") {
+          const library = pluginConfig.library;
+          if (!(library == null ? void 0 : library.type)) {
+            const errorMsg = `mf config 'library.type' is required when not set 'jsMinifier' or use 'esbuild'`;
+            const recommandMsg = `please set 'library.type' or use 'jsMinifier: terser' (e.g. 'library: { type: "window", name: "..." }')`;
+            const finalMsg = `${errorMsg}, ${recommandMsg}`;
+            console.log(`${LOGGER_LABEL} ${import_utils.chalk.red(finalMsg)}`);
+            throw new Error(finalMsg);
+          }
+        }
+      }
+    };
+    checkConfig();
+    const {
+      ModuleFederationPlugin
+    } = require("@module-federation/enhanced/webpack");
+    config.plugins.push(new ModuleFederationPlugin(mfConfig));
+    api.logger.debug(
+      `ModuleFederationPlugin V2 is enabled with config ${JSON.stringify(
+        mfConfig
+      )}`
+    );
+    return config;
+  });
+  api.register({
+    key: "onGenerateFiles",
+    stage: 10002,
+    fn: async () => {
+      const entry = import_path.default.join(api.paths.absTmpPath, "umi.ts");
+      const content = (0, import_fs.readFileSync)(entry, "utf-8");
+      const [_imports, exports] = await (0, import_bundler_utils.parseModule)({ content, path: entry });
+      const mfEntryContent = [];
+      let hasDefaultExport = false;
+      if (exports.length) {
+        mfEntryContent.push(
+          `const umiExports = await import('${(0, import_utils.winPath)(entry)}')`
+        );
+        for (const exportName of exports) {
+          if (exportName === "default") {
+            hasDefaultExport = true;
+            mfEntryContent.push(`export default umiExports.${exportName}`);
+          } else {
+            mfEntryContent.push(
+              `export const ${exportName} = umiExports.${exportName}`
+            );
+          }
+        }
+      } else {
+        mfEntryContent.push(`import('${(0, import_utils.winPath)(entry)}')`);
+      }
+      if (!hasDefaultExport) {
+        mfEntryContent.push("export default 1");
+      }
+      api.writeTmpFile({
+        content: mfEntryContent.join("\n"),
+        path: mfAsyncEntryFileName
+      });
+    }
+  });
+  api.modifyTSConfig((memo) => {
+    const typesDir = (0, import_utils.winPath)(import_path.default.join(api.cwd, "./@mf-types/*"));
+    memo.compilerOptions.paths["*"] = [typesDir];
+    return memo;
+  });
+};
+function isValidIdentifyName(name) {
+  const reservedKeywords = [
+    "abstract",
+    "await",
+    "boolean",
+    "break",
+    "byte",
+    "case",
+    "catch",
+    "char",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "double",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "false",
+    "final",
+    "finally",
+    "float",
+    "for",
+    "function",
+    "goto",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "instanceof",
+    "int",
+    "interface",
+    "let",
+    "long",
+    "native",
+    "new",
+    "null",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "return",
+    "short",
+    "static",
+    "super",
+    "switch",
+    "synchronized",
+    "this",
+    "throw",
+    "transient",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "volatile",
+    "while",
+    "with",
+    "yield"
+  ];
+  const regexIdentifierName = /^(?:[$_\p{ID_Start}])(?:[$_\u200C\u200D\p{ID_Continue}])*$/u;
+  if (reservedKeywords.includes(name) || !regexIdentifierName.test(name)) {
+    return false;
+  }
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EVersion,
+  configSchema,
+  isValidIdentifyName
+});

package/dist/mf.js

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -14,6 +16,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/mf.ts
@@ -27,16 +37,23 @@ var import_fs = require("fs");
 var import_path = require("path");
 var import_plugin_utils = require("umi/plugin-utils");
 var import_constants = require("./constants");
+var import_mf_v2 = __toESM(require("./mf-v2"));
 var import_mfUtils = require("./utils/mfUtils");
 var { isEmpty } = import_plugin_utils.lodash;
 var mfSetupPathFileName = "_mf_setup-public-path.js";
 var mfAsyncEntryFileName = "asyncEntry.ts";
 var MF_TEMPLATES_DIR = (0, import_path.join)(import_constants.TEMPLATES_DIR, "mf");
 function mf(api) {
+  var _a, _b;
   api.describe({
     key: "mf",
     config: {
       schema({ zod }) {
+        var _a2;
+        const useVersion = (_a2 = api.userConfig.mf) == null ? void 0 : _a2.version;
+        if (useVersion === import_mf_v2.EVersion.v2) {
+          return (0, import_mf_v2.configSchema)(zod);
+        }
         return zod.object({
           name: zod.string(),
           remotes: zod.array(
@@ -51,12 +68,18 @@ function mf(api) {
           ),
           shared: zod.record(zod.any()),
           library: zod.record(zod.any()),
-          remoteHash: zod.boolean()
+          remoteHash: zod.boolean(),
+          version: zod.enum([import_mf_v2.EVersion.v1, import_mf_v2.EVersion.v2])
         }).partial();
       }
     },
     enableBy: api.EnableBy.config
   });
+  const useV2 = ((_a = api.userConfig.mf) == null ? void 0 : _a.version) === import_mf_v2.EVersion.v2 || ((_b = api.config.mf) == null ? void 0 : _b.version) === import_mf_v2.EVersion.v2;
+  if (useV2) {
+    (0, import_mf_v2.default)(api, { standalone: false });
+    return;
+  }
   api.modifyWebpackConfig(async (config, { webpack }) => {
     const exposes = await constructExposes();
     const remotes = formatRemotes();
@@ -249,7 +272,7 @@ function mf(api) {
         `module federation name is not defined , "unNamedMF" will be used`
       );
     }
-    if (!isValidIdentifyName(name)) {
+    if (!(0, import_mf_v2.isValidIdentifyName)(name)) {
       throw new Error(
         `module federation name '${name}' is not valid javascript identifier.`
       );
@@ -285,74 +308,4 @@ function mf(api) {
   function addMFEntry(config, mfName2, path) {
     config.entry[mfName2] = path;
   }
-  function isValidIdentifyName(name) {
-    const reservedKeywords = [
-      "abstract",
-      "await",
-      "boolean",
-      "break",
-      "byte",
-      "case",
-      "catch",
-      "char",
-      "class",
-      "const",
-      "continue",
-      "debugger",
-      "default",
-      "delete",
-      "do",
-      "double",
-      "else",
-      "enum",
-      "export",
-      "extends",
-      "false",
-      "final",
-      "finally",
-      "float",
-      "for",
-      "function",
-      "goto",
-      "if",
-      "implements",
-      "import",
-      "in",
-      "instanceof",
-      "int",
-      "interface",
-      "let",
-      "long",
-      "native",
-      "new",
-      "null",
-      "package",
-      "private",
-      "protected",
-      "public",
-      "return",
-      "short",
-      "static",
-      "super",
-      "switch",
-      "synchronized",
-      "this",
-      "throw",
-      "transient",
-      "true",
-      "try",
-      "typeof",
-      "var",
-      "void",
-      "volatile",
-      "while",
-      "with",
-      "yield"
-    ];
-    const regexIdentifierName = /^(?:[$_\p{ID_Start}])(?:[$_\u200C\u200D\p{ID_Continue}])*$/u;
-    if (reservedKeywords.includes(name) || !regexIdentifierName.test(name)) {
-      return false;
-    }
-    return true;
-  }
 }

package/dist/qiankun/master.js

@@ -219,16 +219,6 @@ export { MicroAppWithMemoHistory } from './MicroAppWithMemoHistory';
       `
     });
   });
-  api.chainWebpack((config, { ssr }) => {
-    if (ssr) {
-      const originalExternals = config.get("externals");
-      config.externals({
-        ...originalExternals,
-        qiankun: "fs"
-      });
-    }
-    return config;
-  });
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/qiankun/slave.js

@@ -171,10 +171,7 @@ export interface IRuntimeConfig {
       `window.publicPath = window.__INJECTED_PUBLIC_PATH_BY_QIANKUN__ || "${api.config.publicPath || "/"}";`
     ];
   });
-  api.chainWebpack((config, { ssr }) => {
-    if (ssr) {
-      return;
-    }
+  api.chainWebpack((config) => {
     (0, import_assert.default)(api.pkg.name, "You should have name in package.json.");
     const {
       shouldNotAddLibraryChunkName = api.env === "production" || !Boolean(api.config.mfsu)
@@ -204,14 +201,11 @@ export interface IRuntimeConfig {
   });
   api.addEntryCode(() => [
     `
-const qiankun_noop = () => new Error('qiankun lifecycle is not available for server runtime!');
-const isServer = typeof window === 'undefined';
-export const bootstrap = isServer ? qiankun_noop: qiankun_genBootstrap(render);
-export const mount = isServer ? qiankun_noop : qiankun_genMount('${api.config.mountElementId}');
-export const unmount = isServer ? qiankun_noop : qiankun_genUnmount('${api.config.mountElementId}');
-export const update = isServer ? qiankun_noop : qiankun_genUpdate();
-// 增加 ssr 的判断
-if (!isServer && !window.__POWERED_BY_QIANKUN__) {
+export const bootstrap = qiankun_genBootstrap(render);
+export const mount = qiankun_genMount('${api.config.mountElementId}');
+export const unmount = qiankun_genUnmount('${api.config.mountElementId}');
+export const update = qiankun_genUpdate();
+if (!window.__POWERED_BY_QIANKUN__) {
   bootstrap().then(mount);
 }
     `

package/dist/react-query.js

@@ -24,25 +24,20 @@ __export(react_query_exports, {
 module.exports = __toCommonJS(react_query_exports);
 var import_utils = require("@umijs/utils");
 var import_path = require("path");
+var import_npmClient = require("./utils/npmClient");
 var import_resolveProjectDep = require("./utils/resolveProjectDep");
 var import_withTmpPath = require("./utils/withTmpPath");
-var react_query_default = (api) => {
-  api.describe({
-    key: "reactQuery",
-    config: {
-      schema({ zod }) {
-        return zod.object({
-          devtool: zod.union([zod.record(zod.any()), zod.boolean()]),
-          queryClient: zod.union([zod.record(zod.any()), zod.boolean()])
-        }).deepPartial();
-      }
-    },
-    enableBy: api.EnableBy.config
-  });
+var reactQueryInfo;
+var REACT_QUERY_DEP_NAME = "@tanstack/react-query";
+var REACT_QUERY_DEVTOOLS_DEP_NAME = "@tanstack/react-query-devtools";
+var REACT_QUERY_CORE_DEP_NAME = "@tanstack/query-core";
+var getReactQueryPkgInfo = (api) => {
+  if (reactQueryInfo) {
+    return reactQueryInfo;
+  }
   let pkgPath;
   let devtoolsPkgPath;
-  const REACT_QUERY_DEP_NAME = "@tanstack/react-query";
-  const REACT_QUERY_DEVTOOLS_DEP_NAME = "@tanstack/react-query-devtools";
+  let corePath;
   const defaultPkgPath = (0, import_utils.winPath)(
     (0, import_path.dirname)(require.resolve(`${REACT_QUERY_DEP_NAME}/package.json`))
   );
@@ -61,6 +56,16 @@ var react_query_default = (api) => {
       `[reactQuery] package '${REACT_QUERY_DEP_NAME}' resolve failed, ${e.message}`
     );
   }
+  try {
+    corePath = (0, import_utils.winPath)(
+      (0, import_path.dirname)(
+        require.resolve(`${REACT_QUERY_CORE_DEP_NAME}/package.json`, {
+          paths: [pkgPath]
+        })
+      )
+    );
+  } catch {
+  }
   try {
     const localDevtoolsPkgPath = (0, import_resolveProjectDep.resolveProjectDep)({
       pkg: api.pkg,
@@ -82,7 +87,35 @@ var react_query_default = (api) => {
   const useV5 = pkgVersion.startsWith("5");
   const useV5Devtools = devtoolsVersion.startsWith("5");
   const canUseDevtools = useV4 && useV4Devtools || useV5 && useV5Devtools;
+  reactQueryInfo = {
+    pkgPath,
+    devtoolsPkgPath,
+    defaultPkgPath,
+    defaultDevtoolPkgPath,
+    pkgVersion,
+    canUseDevtools,
+    useV4,
+    useV5,
+    corePath
+  };
+  return reactQueryInfo;
+};
+var react_query_default = (api) => {
+  api.describe({
+    key: "reactQuery",
+    config: {
+      schema({ zod }) {
+        return zod.object({
+          devtool: zod.union([zod.record(zod.any()), zod.boolean()]),
+          queryClient: zod.union([zod.record(zod.any()), zod.boolean()])
+        }).deepPartial();
+      }
+    },
+    enableBy: api.EnableBy.config
+  });
   api.onStart(() => {
+    getReactQueryPkgInfo(api);
+    const { pkgPath, defaultPkgPath, pkgVersion } = reactQueryInfo;
     if (pkgPath !== defaultPkgPath && !process.env.IS_UMI_BUILD_WORKER) {
       api.logger.info(`[reactQuery] use local package, version: ${pkgVersion}`);
     }
@@ -94,6 +127,7 @@ var react_query_default = (api) => {
     return ["reactQuery"];
   });
   api.modifyConfig((memo) => {
+    const { pkgPath, devtoolsPkgPath, canUseDevtools } = getReactQueryPkgInfo(api);
     memo.alias[REACT_QUERY_DEP_NAME] = pkgPath;
     if (canUseDevtools) {
       memo.alias[REACT_QUERY_DEVTOOLS_DEP_NAME] = devtoolsPkgPath;
@@ -102,6 +136,7 @@ var react_query_default = (api) => {
   });
   api.onGenerateFiles(() => {
     var _a;
+    const { pkgPath, devtoolsPkgPath, canUseDevtools, useV4, useV5 } = getReactQueryPkgInfo(api);
     const enableDevTools = api.config.reactQuery.devtool !== false && canUseDevtools;
     const enableQueryClient = api.config.reactQuery.queryClient !== false;
     const reactQueryRuntimeCode = ((_a = api.appData.appJS) == null ? void 0 : _a.exports.includes(
@@ -134,60 +169,105 @@ export function rootContainer(container) {
     </QueryClientProvider>
   );
 }
-      ` : ""
+      ` : "export {}"
     });
+    const exportMembers = [
+      // from @tanstack/query-core
+      "QueryClient",
+      "QueryCache",
+      "MutationCache",
+      "QueryObserver",
+      "InfiniteQueryObserver",
+      "QueriesObserver",
+      "MutationObserver",
+      // from @tanstack/react-query
+      "useQuery",
+      "useQueries",
+      "useInfiniteQuery",
+      "useMutation",
+      "useIsFetching",
+      "useIsMutating",
+      ...useV5 ? [
+        "useMutationState",
+        "useSuspenseQuery",
+        "useSuspenseInfiniteQuery",
+        "useSuspenseQueries",
+        "queryOptions",
+        "infiniteQueryOptions"
+      ] : [],
+      "QueryClientProvider",
+      "useQueryClient",
+      "QueryErrorResetBoundary",
+      "useQueryErrorResetBoundary",
+      "useIsRestoring",
+      "IsRestoringProvider"
+    ].filter(Boolean);
     api.writeTmpFile({
       path: "index.tsx",
       content: `
 export {
-  // from @tanstack/query-core
-  QueryClient,
-  MutationObserver,
-  MutationCache,
-  InfiniteQueryObserver,
-  QueriesObserver,
-  QueryObserver,
-  QueryCache,
-  // from @tanstack/react-query
-  useIsRestoring,
-  IsRestoringProvider,
-  useInfiniteQuery,
-  useIsMutating,
-  useIsFetching,
-  useMutation,
-  useQueries,
-  useQuery,
-  QueryClientProvider,
-  useQueryClient,
-  QueryErrorResetBoundary,
-  useQueryErrorResetBoundary,
-  ${useV5 ? "queryOptions," : ""}
+  ${exportMembers.join(",\n  ")}
 } from '${pkgPath}';
       `
     });
+    const exportTypes = [
+      // from @tanstack/query-core
+      "Query",
+      "QueryState",
+      "Mutation",
+      // from @tanstack/react-query
+      "QueriesResults",
+      "QueriesOptions",
+      "QueryErrorResetBoundaryProps",
+      "QueryClientProviderProps",
+      useV4 && "ContextOptions as QueryContextOptions,",
+      "UseQueryOptions",
+      "UseBaseQueryOptions",
+      "UseQueryResult",
+      "UseBaseQueryResult",
+      "UseInfiniteQueryOptions",
+      "UseMutationResult",
+      "UseMutateFunction",
+      "UseMutateAsyncFunction",
+      "UseBaseMutationResult"
+    ].filter(Boolean);
     api.writeTmpFile({
       path: "types.d.ts",
       content: `
 export type {
-  // from @tanstack/query-core
-  Query, QueryState, Mutation,
-  // from @tanstack/react-query
-  QueriesResults,
-  QueriesOptions,
-  QueryErrorResetBoundaryProps,
-  QueryClientProviderProps,
-  ${useV4 ? "ContextOptions as QueryContextOptions," : ""}
-  UseQueryOptions,
-  UseBaseQueryOptions,
-  UseQueryResult,
-  UseBaseQueryResult,
-  UseInfiniteQueryOptions,
-  UseMutationResult,
-  UseMutateFunction,
-  UseMutateAsyncFunction,
-  UseBaseMutationResult,
+  ${exportTypes.join(",\n  ")}
 } from '${pkgPath}';
       `
     });
+    api.writeTmpFile({
+      path: "types.d.ts",
+      content: enableQueryClient ? `
+import React from 'react';
+import { QueryClientConfig } from '${pkgPath}';
+${enableDevTools ? `
+import { ReactQueryDevtools } from '${devtoolsPkgPath}';
+` : ""}
+
+export type RuntimeReactQueryType = {
+  ${enableDevTools ? `
+  devtool?: React.ComponentProps<typeof ReactQueryDevtools>
+` : ""}
+  queryClient?: QueryClientConfig
+}` : "export type RuntimeReactQueryType = {}"
+    });
   });
+  const isFlattedDepsDir = (0, import_npmClient.isFlattedNodeModulesDir)(api);
+  if (!isFlattedDepsDir) {
+    api.modifyTSConfig((config) => {
+      const { corePath, useV5 } = getReactQueryPkgInfo(api);
+      if (useV5 && (corePath == null ? void 0 : corePath.length)) {
+        import_utils.lodash.set(
+          config,
+          `compilerOptions.paths["${REACT_QUERY_CORE_DEP_NAME}"]`,
+          [corePath]
+        );
+      }
+      return config;
+    });
+  }
 };

package/dist/utils/npmClient.d.ts

@@ -0,0 +1,2 @@
+import type { IApi } from 'umi';
+export declare const isFlattedNodeModulesDir: (api: IApi) => boolean;

package/dist/utils/npmClient.js

@@ -0,0 +1,45 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/npmClient.ts
+var npmClient_exports = {};
+__export(npmClient_exports, {
+  isFlattedNodeModulesDir: () => isFlattedNodeModulesDir
+});
+module.exports = __toCommonJS(npmClient_exports);
+var import_plugin_utils = require("umi/plugin-utils");
+var FLATTED_NPM_CLIENT = [
+  import_plugin_utils.NpmClientEnum.npm,
+  import_plugin_utils.NpmClientEnum.yarn
+];
+var isFlattedNodeModulesDir = (api) => {
+  var _a;
+  let currentNpmClient = api.appData.npmClient;
+  const tnpmCompatMode = api.appData.npmClient === import_plugin_utils.NpmClientEnum.tnpm && ((_a = api.pkg.tnpm) == null ? void 0 : _a.mode);
+  if (tnpmCompatMode) {
+    if (FLATTED_NPM_CLIENT.includes(api.pkg.tnpm.mode)) {
+      return true;
+    }
+  }
+  const isFlattedDir = FLATTED_NPM_CLIENT.includes(currentNpmClient);
+  return isFlattedDir;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isFlattedNodeModulesDir
+});

package/libs/qiankun/master/MicroApp.tsx

@@ -167,6 +167,13 @@ export const MicroApp = forwardRef(
       props: { settings: settingsFromConfig = {}, ...propsFromConfig } = {},
     } = appConfig || {};
 
+    const __globalRoutesInfo = {
+      appNameKeyAlias,
+      masterHistoryType,
+      base: globalSettings.base,
+      microAppRoutes: globalSettings.microAppRoutes,
+    };
+
     useEffect(() => {
       setComponentError(null);
       setLoading(true);
@@ -185,12 +192,7 @@ export const MicroApp = forwardRef(
             ...propsFromConfig,
             ...stateForSlave,
             ...propsFromParams,
-            __globalRoutesInfo: {
-              appNameKeyAlias,
-              masterHistoryType,
-              base: globalSettings.base,
-              microAppRoutes: globalSettings.microAppRoutes,
-            },
+            __globalRoutesInfo,
             setLoading,
           },
         },
@@ -263,6 +265,7 @@ export const MicroApp = forwardRef(
                 ...propsFromConfig,
                 ...stateForSlave,
                 ...propsFromParams,
+                __globalRoutesInfo,
                 setLoading,
               };
 

package/libs/qiankun/master/masterRuntimePlugin.tsx

@@ -77,10 +77,6 @@ function patchMicroAppRouteComponent(routes: any[]) {
 }
 
 export async function render(oldRender: typeof noop) {
-  // 在 ssr 的场景下，直接返回旧的 render
-  if (typeof window === 'undefined') {
-    return oldRender();
-  }
   const runtimeOptions = await getMasterRuntime();
   let masterOptions: MasterOptions = {
     ...getMasterOptions(),
@@ -142,10 +138,6 @@ export async function render(oldRender: typeof noop) {
 }
 
 export function patchClientRoutes({ routes }: { routes: any[] }) {
-  // 在 ssr 的场景下，不执行主应用的 patchClientRoutes
-  if (typeof window === 'undefined') {
-    return;
-  }
   const microAppRoutes = [].concat(
     deepFilterLeafRoutes(routes),
     deepFilterLeafRoutes(microAppRuntimeRoutes),

package/libs/qiankun/slave/slaveRuntimePlugin.ts

@@ -3,10 +3,6 @@ import { createHistory } from '@@/core/history';
 import qiankunRender, { contextOptsStack } from './lifecycles';
 
 export function render(oldRender: any) {
-  // 在 ssr 的场景下，直接返回旧的 render
-  if (typeof window === 'undefined') {
-    return oldRender();
-  }
   return qiankunRender().then(oldRender);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umijs/plugins",
-  "version": "4.0.0-canary.20240605.1",
+  "version": "4.0.0-canary.20240624.1",
   "description": "@umijs/plugins",
   "homepage": "https://github.com/umijs/umi/tree/master/packages/plugins#readme",
   "bugs": "https://github.com/umijs/umi/issues",
@@ -23,6 +23,7 @@
     "@ant-design/icons": "^4.7.0",
     "@ant-design/moment-webpack-plugin": "^0.0.3",
     "@ant-design/pro-components": "^2.0.1",
+    "@module-federation/enhanced": "^0.1.13",
     "@tanstack/react-query": "^4.24.10",
     "@tanstack/react-query-devtools": "^4.24.10",
     "antd-dayjs-webpack-plugin": "^1.0.6",
@@ -45,12 +46,12 @@
     "styled-components": "6.1.1",
     "tslib": "^2",
     "warning": "^4.0.3",
-    "@umijs/bundler-utils": "4.0.0-canary.20240605.1",
+    "@umijs/bundler-utils": "4.0.0-canary.20240624.1",
     "@umijs/valtio": "1.0.4"
   },
   "devDependencies": {
     "antd": "^4.24.1",
-    "umi": "4.0.0-canary.20240605.1"
+    "umi": "4.0.0-canary.20240624.1"
   },
   "publishConfig": {
     "access": "public"