@umijs/plugins 4.0.0-beta.8 → 4.0.0-canary-20240513.3

package/dist/locale.d.ts

@@ -1,3 +1,4 @@
+import { IApi } from 'umi';
+export declare const packageNormalize: (packageName: string) => string;
 declare const _default: (api: IApi) => void;
 export default _default;
-//# sourceMappingURL=locale.d.ts.map

package/dist/locale.js

@@ -1,5 +1,258 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = (api) => {
-    api;
+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/locale.ts
+var locale_exports = {};
+__export(locale_exports, {
+  default: () => locale_default,
+  packageNormalize: () => packageNormalize
+});
+module.exports = __toCommonJS(locale_exports);
+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_constants = require("./constants");
+var import_localeUtils = require("./utils/localeUtils");
+var import_withTmpPath = require("./utils/withTmpPath");
+var LOCALE_TEMPLATES_DIR = (0, import_path.join)(import_constants.TEMPLATES_DIR, "locale");
+var packageNormalize = (packageName) => packageName.replace(/[@\/\-.]/g, "_");
+var locale_default = (api) => {
+  let hasAntd = false;
+  try {
+    hasAntd = !!require.resolve("antd");
+  } catch (e) {
+    api.logger.warn("antd is not installed. <SelecLang /> unavailable");
+  }
+  const defaultConfig = {
+    baseNavigator: true,
+    useLocalStorage: true,
+    baseSeparator: "-",
+    antd: hasAntd
+  };
+  api.describe({
+    key: "locale",
+    config: {
+      schema({ zod }) {
+        return zod.object({
+          default: zod.string(),
+          useLocalStorage: zod.boolean(),
+          baseNavigator: zod.boolean(),
+          title: zod.boolean(),
+          antd: zod.boolean(),
+          baseSeparator: zod.string()
+        }).partial();
+      }
+    },
+    enableBy: api.EnableBy.config
+  });
+  const reactIntlPkgPath = (0, import_plugin_utils.winPath)(
+    (0, import_path.dirname)(require.resolve("react-intl/package"))
+  );
+  api.addEntryImportsAhead(
+    () => (0, import_localeUtils.isNeedPolyfill)(api.config.targets || {}) ? [
+      {
+        source: require.resolve("intl")
+      }
+    ] : []
+  );
+  const addAntdLocales = async (args) => {
+    var _a;
+    return await api.applyPlugins({
+      key: "addAntdLocales",
+      type: api.ApplyPluginsType.add,
+      initialValue: [
+        `antd/${((_a = api.config) == null ? void 0 : _a.ssr) ? "lib" : "es"}/locale/${(0, import_localeUtils.getAntdLocale)(
+          args.lang,
+          args.country
+        )}`
+      ],
+      args
+    });
+  };
+  const getList = async (resolveKey) => {
+    var _a;
+    const { paths } = api;
+    return (0, import_localeUtils.getLocaleList)({
+      localeFolder: "locales",
+      separator: (_a = api.config.locale) == null ? void 0 : _a.baseSeparator,
+      absSrcPath: paths.absSrcPath,
+      absPagesPath: paths.absPagesPath,
+      addAntdLocales,
+      resolveKey
+    });
+  };
+  api.onGenerateFiles(async () => {
+    var _a, _b, _c;
+    const localeTpl = (0, import_fs.readFileSync)(
+      (0, import_path.join)(LOCALE_TEMPLATES_DIR, "locale.tpl"),
+      "utf-8"
+    );
+    const resolveKey = api.config.moment2dayjs ? "dayjs" : "moment";
+    const momentPkgPath = (0, import_plugin_utils.winPath)(
+      (0, import_path.dirname)(require.resolve(`${resolveKey}/package.json`))
+    );
+    const EventEmitterPkg = (0, import_plugin_utils.winPath)(
+      (0, import_path.dirname)(require.resolve("event-emitter/package"))
+    );
+    const { baseSeparator, baseNavigator, antd, title, useLocalStorage } = {
+      ...defaultConfig,
+      ...api.config.locale
+    };
+    const defaultLocale = ((_a = api.config.locale) == null ? void 0 : _a.default) || `zh${baseSeparator}CN`;
+    const localeList = await getList(resolveKey);
+    const momentLocales = localeList.map(({ momentLocale }) => momentLocale).filter((locale) => locale);
+    const antdLocales = localeList.map(({ antdLocale }) => antdLocale).filter((locale) => locale);
+    let MomentLocales = momentLocales;
+    let DefaultMomentLocale = "";
+    if (!MomentLocales.length && ((_b = api.config.locale) == null ? void 0 : _b.default)) {
+      const [lang, country = ""] = defaultLocale.split(baseSeparator);
+      const { momentLocale } = (0, import_localeUtils.getMomentLocale)(lang, country, resolveKey);
+      if (momentLocale) {
+        MomentLocales = [momentLocale];
+        DefaultMomentLocale = momentLocale;
+      }
+    }
+    let DefaultAntdLocales = [];
+    if (!antdLocales.length && antd) {
+      const [lang, country = ""] = defaultLocale.split(baseSeparator);
+      DefaultAntdLocales = import_plugin_utils.lodash.uniq(
+        await addAntdLocales({
+          lang,
+          country
+        })
+      );
+    }
+    const NormalizeAntdLocalesName = function() {
+      return packageNormalize(this);
+    };
+    api.writeTmpFile({
+      content: import_plugin_utils.Mustache.render(localeTpl, {
+        MomentLocales,
+        DefaultMomentLocale,
+        NormalizeAntdLocalesName,
+        DefaultAntdLocales,
+        Antd: !!antd,
+        Title: title && api.config.title,
+        BaseSeparator: baseSeparator,
+        DefaultLocale: defaultLocale,
+        DefaultLang: defaultLocale,
+        momentPkgPath
+      }),
+      path: "locale.tsx"
+    });
+    const localeExportsTpl = (0, import_fs.readFileSync)(
+      (0, import_path.join)(LOCALE_TEMPLATES_DIR, "localeExports.tpl"),
+      "utf-8"
+    );
+    const localeDirName = "locales";
+    const localeDirPath = (0, import_path.join)(api.paths.absSrcPath, localeDirName);
+    api.writeTmpFile({
+      path: "localeExports.ts",
+      content: import_plugin_utils.Mustache.render(localeExportsTpl, {
+        EventEmitterPkg,
+        BaseSeparator: baseSeparator,
+        BaseNavigator: baseNavigator,
+        UseLocalStorage: !!useLocalStorage,
+        LocaleDir: localeDirName,
+        ExistLocaleDir: (0, import_fs.existsSync)(localeDirPath),
+        LocaleList: localeList.map((locale) => ({
+          ...locale,
+          antdLocale: locale.antdLocale.map((antdLocale, index) => ({
+            locale: antdLocale,
+            index
+          })),
+          paths: locale.paths.map((path, index) => ({
+            path,
+            index
+          }))
+        })),
+        Antd: !!antd,
+        DefaultLocale: JSON.stringify(defaultLocale),
+        warningPkgPath: (0, import_plugin_utils.winPath)((0, import_path.dirname)(require.resolve("warning/package"))),
+        reactIntlPkgPath
+      })
+    });
+    const runtimeTpl = (0, import_fs.readFileSync)(
+      (0, import_path.join)(LOCALE_TEMPLATES_DIR, "runtime.tpl"),
+      "utf-8"
+    );
+    api.writeTmpFile({
+      path: "runtime.tsx",
+      content: import_plugin_utils.Mustache.render(runtimeTpl, {
+        Title: !!title
+      })
+    });
+    const selectLang = (0, import_fs.readFileSync)(
+      (0, import_path.join)(LOCALE_TEMPLATES_DIR, "SelectLang.tpl"),
+      "utf-8"
+    );
+    api.writeTmpFile({
+      path: "SelectLang.tsx",
+      content: import_plugin_utils.Mustache.render(selectLang, {
+        Antd: !!antd,
+        LocaleList: localeList,
+        ShowSelectLang: localeList.length > 1 && !!antd,
+        antdFiles: ((_c = api.config) == null ? void 0 : _c.ssr) ? "lib" : "es"
+      })
+    });
+    api.writeTmpFile({
+      path: "index.ts",
+      content: `
+export { addLocale, setLocale, getLocale, getIntl, useIntl, injectIntl, formatMessage, FormattedMessage, getAllLocales, FormattedDate, FormattedDateParts, FormattedDisplayName, FormattedHTMLMessage, FormattedList, FormattedNumber, FormattedNumberParts, FormattedPlural, FormattedRelativeTime, FormattedTime, FormattedTimeParts, IntlProvider, RawIntlProvider } from './localeExports';
+export { SelectLang } from './SelectLang';
+`
+    });
+    api.writeTmpFile({
+      path: import_umi.RUNTIME_TYPE_FILE_NAME,
+      content: `
+import {
+  IntlCache,
+  createIntl,
+} from '${reactIntlPkgPath}';
+type OptionalIntlConfig = Omit<Parameters<typeof createIntl>[0], 'locale' | 'defaultLocale'>;
+export interface IRuntimeConfig {
+    locale?: {
+      getLocale?: () => string;
+      cache?: IntlCache;
+    } & OptionalIntlConfig;
+};`
+    });
+  });
+  api.addRuntimePlugin(() => [(0, import_withTmpPath.withTmpPath)({ api, path: "runtime.tsx" })]);
+  api.addRuntimePluginKey(() => ["locale"]);
+  api.addTmpGenerateWatcherPaths(async () => {
+    const resolveKey = api.config.moment2dayjs ? "dayjs" : "moment";
+    const localeList = await getList(resolveKey);
+    return (0, import_localeUtils.exactLocalePaths)(localeList);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  packageNormalize
+});

package/dist/mf.d.ts

@@ -0,0 +1,2 @@
+import type { IApi } from 'umi';
+export default function mf(api: IApi): void;

package/dist/mf.js

@@ -0,0 +1,358 @@
+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/mf.ts
+var mf_exports = {};
+__export(mf_exports, {
+  default: () => mf
+});
+module.exports = __toCommonJS(mf_exports);
+var import_bundler_utils = require("@umijs/bundler-utils");
+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_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) {
+  api.describe({
+    key: "mf",
+    config: {
+      schema({ zod }) {
+        return zod.object({
+          name: zod.string(),
+          remotes: zod.array(
+            zod.object({
+              aliasName: zod.string().optional(),
+              //  string 上没有 required
+              name: zod.string(),
+              entry: zod.string().optional(),
+              entries: zod.object({}).optional(),
+              keyResolver: zod.string().optional()
+            })
+          ),
+          shared: zod.record(zod.any()),
+          library: zod.record(zod.any()),
+          remoteHash: zod.boolean()
+        }).partial();
+      }
+    },
+    enableBy: api.EnableBy.config
+  });
+  api.modifyWebpackConfig(async (config, { webpack }) => {
+    const exposes = await constructExposes();
+    const remotes = formatRemotes();
+    const shared = getShared();
+    if (isEmpty(remotes) && isEmpty(exposes)) {
+      api.logger.warn(
+        "ModuleFederation exposes and remotes are empty, plugin will not work"
+      );
+      return config;
+    }
+    if (!isEmpty(remotes)) {
+      if (api.env === "production" || !api.config.mfsu) {
+        changeUmiEntry(config);
+      }
+    }
+    let name = "_";
+    if (!isEmpty(exposes)) {
+      name = mfName();
+      addMFEntry(
+        config,
+        name,
+        (0, import_path.join)(api.paths.absTmpPath, "plugin-mf", mfSetupPathFileName)
+      );
+    }
+    const useHash = typeof api.config.mf.remoteHash === "boolean" ? api.config.mf.remoteHash : api.config.hash && api.env !== "development";
+    const mfConfig = {
+      name,
+      remotes,
+      filename: useHash ? "remote.[contenthash:8].js" : "remote.js",
+      exposes,
+      shared,
+      library: api.config.mf.library
+    };
+    const { ModuleFederationPlugin } = webpack.container;
+    config.plugins.push(new ModuleFederationPlugin(mfConfig));
+    api.logger.debug(
+      `ModuleFederationPlugin is enabled with config ${JSON.stringify(
+        mfConfig
+      )}`
+    );
+    return config;
+  });
+  api.modifyDefaultConfig(async (memo) => {
+    if (memo.mfsu) {
+      const exposes = await constructExposes();
+      if (!isEmpty(exposes)) {
+        memo.mfsu.remoteName = mfName();
+        memo.mfsu.mfName = `mf_${memo.mfsu.remoteName}`;
+      }
+      const remotes = formatRemotes();
+      memo.mfsu.remoteAliases = Object.keys(remotes);
+      memo.mfsu.shared = getShared();
+    }
+    return memo;
+  });
+  api.onGenerateFiles(() => {
+    api.writeTmpFile({
+      // ref https://webpack.js.org/concepts/module-federation/#infer-publicpath-from-script
+      content: `/* infer remote public */;
+      __webpack_public_path__ = document.currentScript.src + '/../';`,
+      path: mfSetupPathFileName
+    });
+    const { remotes = [] } = api.config.mf;
+    api.writeTmpFile({
+      path: "index.tsx",
+      context: {
+        remoteCodeString: (0, import_mfUtils.toRemotesCodeString)(remotes)
+      },
+      tplPath: (0, import_plugin_utils.winPath)((0, import_path.join)(MF_TEMPLATES_DIR, "runtime.ts.tpl"))
+    });
+  });
+  api.register({
+    key: "onGenerateFiles",
+    // ensure after generate tpm files
+    stage: 10001,
+    fn: async () => {
+      if (api.env === "development" && api.config.mfsu) {
+        return;
+      }
+      const entry = (0, import_path.join)(api.paths.absTmpPath, "umi.ts");
+      const content = (0, import_fs.readFileSync)(
+        (0, import_path.join)(api.paths.absTmpPath, "umi.ts"),
+        "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_plugin_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_plugin_utils.winPath)(entry)}')`);
+      }
+      if (!hasDefaultExport) {
+        mfEntryContent.push("export default 1");
+      }
+      api.writeTmpFile({
+        content: mfEntryContent.join("\n"),
+        path: mfAsyncEntryFileName
+      });
+    }
+  });
+  function formatRemotes() {
+    const { remotes = [] } = api.userConfig.mf;
+    const memo = {};
+    remotes.forEach((remote) => {
+      const aliasName = remote.aliasName || remote.name;
+      const r = formatRemote(remote);
+      if (memo[aliasName]) {
+        return api.logger.error(
+          `${aliasName} already set as ${memo[aliasName]}, new value ${r} will be ignored`
+        );
+      }
+      memo[aliasName] = r;
+    });
+    return memo;
+  }
+  function formatRemote(remote) {
+    if (remote.entry) {
+      return `${remote.name}@${remote.entry}`;
+    }
+    if (remote.entries && remote.keyResolver) {
+      const dynamicUrl = `promise new Promise(resolve => {
+  const entries = ${JSON.stringify(remote.entries)};
+  const key = ${remote.keyResolver};
+
+  const remoteUrlWithVersion = entries[key];
+  const script = document.createElement('script')
+  script.src = remoteUrlWithVersion
+  script.onload = () => {
+    // the injected script has loaded and is available on window
+    // we can now resolve this Promise
+    const proxy = {
+      get: (request) => window.${remote.name}.get(request),
+      init: (arg) => {
+        try {
+          return window.${remote.name}.init(arg)
+        } catch(e) {
+          console.log('remote container already initialized')
+        }
+      }
+    }
+    resolve(proxy)
+  }
+  // inject this script with the src set to the versioned remoteEntry.js
+  document.head.appendChild(script);
+})
+`;
+      return dynamicUrl;
+    } else {
+      api.logger.error("you should provider entry or entries and keyResolver");
+      throw Error("Wrong MF#remotes config");
+    }
+  }
+  async function constructExposes() {
+    const exposes = {};
+    const exposesPath = (0, import_path.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_plugin_utils.winPath)(
+          (0, import_path.join)(api.paths.absSrcPath, "exposes", dirent.name)
+        );
+      } else {
+        api.logger.warn(
+          `${dirent.name} is not a directory, ignore in ModuleFederation expose`
+        );
+      }
+    }
+    return exposes;
+  }
+  function mfName() {
+    const name = api.userConfig.mf.name;
+    if (!name) {
+      api.logger.warn(
+        `module federation name is not defined , "unNamedMF" will be used`
+      );
+    }
+    if (!isValidIdentifyName(name)) {
+      throw new Error(
+        `module federation name '${name}' is not valid javascript identifier.`
+      );
+    }
+    return name || "unNamedMF";
+  }
+  function getShared() {
+    const { shared = {} } = api.userConfig.mf;
+    return shared;
+  }
+  function changeUmiEntry(config) {
+    const { entry } = config;
+    const asyncEntryPath = (0, import_plugin_utils.winPath)(
+      (0, import_path.join)(api.paths.absTmpPath, "plugin-mf", mfAsyncEntryFileName)
+    );
+    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 {
+          api.logger.info(
+            `umi.ts not found in entry.umi ${JSON.stringify(entry.umi)}`
+          );
+        }
+      }
+    } else {
+      api.logger.warn("umi entry not found");
+    }
+  }
+  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/model.d.ts

@@ -1,3 +1,3 @@
+import { IApi } from 'umi';
 declare const _default: (api: IApi) => void;
 export default _default;
-//# sourceMappingURL=model.d.ts.map