@modern-js/plugin-v2 2.63.7 → 2.63.8-alpha.0

package/dist/esm/cli/api.js

@@ -0,0 +1,103 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_without_properties } from "@swc/helpers/_/_object_without_properties";
+import { merge } from "@modern-js/utils/lodash";
+import { debug } from "./run/utils/debug";
+function initPluginAPI(param) {
+  var context = param.context, pluginManager = param.pluginManager;
+  var hooks = context.hooks, extendsHooks = context.extendsHooks, plugins = context.plugins;
+  function getAppContext() {
+    if (context) {
+      var hooks2 = context.hooks, extendsHooks2 = context.extendsHooks, config = context.config, normalizedConfig = context.normalizedConfig, pluginAPI2 = context.pluginAPI, appContext = _object_without_properties(context, [
+        "hooks",
+        "extendsHooks",
+        "config",
+        "normalizedConfig",
+        "pluginAPI"
+      ]);
+      appContext._internalContext = context;
+      return appContext;
+    }
+    throw new Error("Cannot access context");
+  }
+  function getConfig() {
+    if (context.config) {
+      return context.config;
+    }
+    throw new Error("Cannot access config");
+  }
+  function getNormalizedConfig() {
+    if (context.normalizedConfig) {
+      return context.normalizedConfig;
+    }
+    throw new Error("Cannot access normalized config");
+  }
+  function getHooks() {
+    return context.hooks;
+  }
+  var extendsPluginApi = {};
+  plugins.forEach(function(plugin) {
+    var _registryApi = plugin._registryApi;
+    if (_registryApi) {
+      var apis = _registryApi(getAppContext, updateAppContext);
+      Object.keys(apis).forEach(function(apiName) {
+        extendsPluginApi[apiName] = apis[apiName];
+      });
+    }
+  });
+  if (extendsHooks) {
+    Object.keys(extendsHooks).forEach(function(hookName) {
+      extendsPluginApi[hookName] = extendsHooks[hookName].tap;
+    });
+  }
+  function updateAppContext(updateContext) {
+    context = merge(context, updateContext);
+  }
+  var pluginAPI = _object_spread({
+    isPluginExists: pluginManager.isPluginExists,
+    getAppContext,
+    getConfig,
+    getNormalizedConfig,
+    getHooks,
+    updateAppContext,
+    config: hooks.config.tap,
+    modifyConfig: hooks.modifyConfig.tap,
+    modifyResolvedConfig: hooks.modifyResolvedConfig.tap,
+    modifyRsbuildConfig: hooks.modifyRsbuildConfig.tap,
+    modifyBundlerChain: hooks.modifyBundlerChain.tap,
+    modifyRspackConfig: hooks.modifyRspackConfig.tap,
+    modifyWebpackChain: hooks.modifyWebpackChain.tap,
+    modifyWebpackConfig: hooks.modifyWebpackConfig.tap,
+    modifyHtmlPartials: hooks.modifyHtmlPartials.tap,
+    addCommand: hooks.addCommand.tap,
+    onPrepare: hooks.onPrepare.tap,
+    addWatchFiles: hooks.addWatchFiles.tap,
+    onFileChanged: hooks.onFileChanged.tap,
+    onBeforeRestart: hooks.onBeforeRestart.tap,
+    onBeforeCreateCompiler: hooks.onBeforeCreateCompiler.tap,
+    onDevCompileDone: hooks.onDevCompileDone.tap,
+    onAfterCreateCompiler: hooks.onAfterCreateCompiler.tap,
+    onBeforeBuild: hooks.onBeforeBuild.tap,
+    onAfterBuild: hooks.onAfterBuild.tap,
+    onBeforeDev: hooks.onBeforeDev.tap,
+    onAfterDev: hooks.onAfterDev.tap,
+    onBeforeDeploy: hooks.onBeforeDeploy.tap,
+    onAfterDeploy: hooks.onAfterDeploy.tap,
+    onBeforeExit: hooks.onBeforeExit.tap
+  }, extendsPluginApi);
+  return new Proxy(pluginAPI, {
+    get: function get(target, prop) {
+      if (prop === "then") {
+        return void 0;
+      }
+      if (prop in target) {
+        return target[prop];
+      }
+      return function() {
+        debug("api.".concat(prop.toString(), " not exist"));
+      };
+    }
+  });
+}
+export {
+  initPluginAPI
+};

package/dist/esm/cli/context.js

@@ -0,0 +1,53 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { initHooks } from "./hooks";
+function initAppContext(params) {
+  var appDirectory = params.appDirectory, _params_srcDir = params.srcDir, srcDir = _params_srcDir === void 0 ? "src" : _params_srcDir, _params_distDir = params.distDir, distDir = _params_distDir === void 0 ? "dist" : _params_distDir;
+  return {
+    packageName: params.packageName,
+    configFile: params.configFile,
+    command: params.command,
+    isProd: process.env.NODE_ENV === "production",
+    appDirectory,
+    srcDirectory: path.resolve(appDirectory, srcDir),
+    distDirectory: "",
+    nodeModulesDirectory: path.resolve(appDirectory, "node_modules"),
+    plugins: params.plugins
+  };
+}
+function createContext(_) {
+  return _createContext.apply(this, arguments);
+}
+function _createContext() {
+  _createContext = _async_to_generator(function(param) {
+    var appContext, config, normalizedConfig, plugins, extendsHooks;
+    return _ts_generator(this, function(_state) {
+      appContext = param.appContext, config = param.config, normalizedConfig = param.normalizedConfig;
+      plugins = appContext.plugins;
+      extendsHooks = {};
+      plugins.forEach(function(plugin) {
+        var _plugin_registryHooks = plugin.registryHooks, registryHooks = _plugin_registryHooks === void 0 ? {} : _plugin_registryHooks;
+        Object.keys(registryHooks).forEach(function(hookName) {
+          extendsHooks[hookName] = registryHooks[hookName];
+        });
+      });
+      return [
+        2,
+        _object_spread_props(_object_spread({}, appContext), {
+          hooks: _object_spread({}, initHooks(), extendsHooks),
+          extendsHooks,
+          config,
+          normalizedConfig
+        })
+      ];
+    });
+  });
+  return _createContext.apply(this, arguments);
+}
+export {
+  createContext,
+  initAppContext
+};

package/dist/esm/cli/hooks.js

@@ -0,0 +1,42 @@
+import { createAsyncHook, createCollectAsyncHook } from "../hooks";
+function initHooks() {
+  return {
+    /**
+    * add config for this cli plugin
+    */
+    config: createCollectAsyncHook(),
+    /**
+    * @private
+    * modify config for this cli plugin
+    */
+    modifyConfig: createAsyncHook(),
+    /**
+    * modify final config
+    */
+    modifyResolvedConfig: createAsyncHook(),
+    modifyRsbuildConfig: createAsyncHook(),
+    modifyBundlerChain: createAsyncHook(),
+    modifyRspackConfig: createAsyncHook(),
+    modifyWebpackChain: createAsyncHook(),
+    modifyWebpackConfig: createAsyncHook(),
+    modifyHtmlPartials: createAsyncHook(),
+    addCommand: createAsyncHook(),
+    addWatchFiles: createCollectAsyncHook(),
+    onPrepare: createAsyncHook(),
+    onFileChanged: createAsyncHook(),
+    onBeforeRestart: createAsyncHook(),
+    onBeforeCreateCompiler: createAsyncHook(),
+    onAfterCreateCompiler: createAsyncHook(),
+    onDevCompileDone: createAsyncHook(),
+    onBeforeBuild: createAsyncHook(),
+    onAfterBuild: createAsyncHook(),
+    onBeforeDev: createAsyncHook(),
+    onAfterDev: createAsyncHook(),
+    onBeforeDeploy: createAsyncHook(),
+    onAfterDeploy: createAsyncHook(),
+    onBeforeExit: createAsyncHook()
+  };
+}
+export {
+  initHooks
+};

package/dist/esm/cli/index.js

@@ -0,0 +1,14 @@
+import { initPluginAPI } from "./api";
+import { initAppContext, createContext } from "./context";
+import { initHooks } from "./hooks";
+import { cli, createLoadedConfig, initAppDir, createCli } from "./run";
+export {
+  cli,
+  createCli,
+  createContext,
+  createLoadedConfig,
+  initAppContext,
+  initAppDir,
+  initHooks,
+  initPluginAPI
+};

package/dist/esm/cli/run/config/createLoadedConfig.js

@@ -0,0 +1,190 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { fs, CONFIG_FILE_EXTENSIONS, chalk, getCommand, getNodeEnv, isDevCommand, isPlainObject, logger } from "@modern-js/utils";
+import { mergeWith } from "@modern-js/utils/lodash";
+import { mergeConfig } from "../utils/mergeConfig";
+import { getConfigFilePath, loadConfig } from "./loadConfig";
+function getConfigObject(config) {
+  return _getConfigObject.apply(this, arguments);
+}
+function _getConfigObject() {
+  _getConfigObject = /**
+  * A modern config can export a function or an object
+  * If it's a function, it will be called and return a config object
+  */
+  _async_to_generator(function(config) {
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          if (!(typeof config === "function"))
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            config({
+              env: getNodeEnv(),
+              command: getCommand()
+            })
+          ];
+        case 1:
+          return [
+            2,
+            _state.sent() || {}
+          ];
+        case 2:
+          return [
+            2,
+            config || {}
+          ];
+      }
+    });
+  });
+  return _getConfigObject.apply(this, arguments);
+}
+function loadLocalConfig(appDirectory, configFile) {
+  return _loadLocalConfig.apply(this, arguments);
+}
+function _loadLocalConfig() {
+  _loadLocalConfig = _async_to_generator(function(appDirectory, configFile) {
+    var localConfigFile, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, ext, replacedPath, loaded;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          localConfigFile = false;
+          if (typeof configFile === "string") {
+            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+            try {
+              for (_iterator = CONFIG_FILE_EXTENSIONS[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                ext = _step.value;
+                if (configFile.endsWith(ext)) {
+                  replacedPath = configFile.replace(ext, ".local".concat(ext));
+                  if (fs.existsSync(replacedPath)) {
+                    localConfigFile = replacedPath;
+                  }
+                }
+              }
+            } catch (err) {
+              _didIteratorError = true;
+              _iteratorError = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                  _iterator.return();
+                }
+              } finally {
+                if (_didIteratorError) {
+                  throw _iteratorError;
+                }
+              }
+            }
+          }
+          if (!localConfigFile)
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            loadConfig(appDirectory, localConfigFile)
+          ];
+        case 1:
+          loaded = _state.sent();
+          return [
+            2,
+            getConfigObject(loaded.config)
+          ];
+        case 2:
+          return [
+            2,
+            null
+          ];
+      }
+    });
+  });
+  return _loadLocalConfig.apply(this, arguments);
+}
+function assignPkgConfig(userConfig, pkgConfig) {
+  return mergeWith({}, userConfig, pkgConfig, function(objValue, srcValue) {
+    if (objValue === void 0 && isPlainObject(srcValue)) {
+      return _object_spread({}, srcValue);
+    }
+    return void 0;
+  });
+}
+function createLoadedConfig(appDirectory, configFilePath, packageJsonConfig, otherConfig) {
+  return _createLoadedConfig.apply(this, arguments);
+}
+function _createLoadedConfig() {
+  _createLoadedConfig = _async_to_generator(function(appDirectory, configFilePath, packageJsonConfig, otherConfig) {
+    var configFile, loaded, config, mergedConfig, localConfig;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          configFile = getConfigFilePath(appDirectory, configFilePath);
+          return [
+            4,
+            loadConfig(appDirectory, configFile, packageJsonConfig)
+          ];
+        case 1:
+          loaded = _state.sent();
+          if (!loaded.config && !loaded.pkgConfig) {
+            logger.warn("Can not find any config file in the current project, please check if you have a correct config file.");
+            logger.warn("Current project path: ".concat(chalk.yellow(appDirectory)));
+          }
+          return [
+            4,
+            getConfigObject(loaded.config)
+          ];
+        case 2:
+          config = _state.sent();
+          mergedConfig = config;
+          if (loaded.pkgConfig) {
+            mergedConfig = assignPkgConfig(config, loaded === null || loaded === void 0 ? void 0 : loaded.pkgConfig);
+          }
+          if (!isDevCommand())
+            return [
+              3,
+              4
+            ];
+          return [
+            4,
+            loadLocalConfig(appDirectory, configFile)
+          ];
+        case 3:
+          localConfig = _state.sent();
+          if (localConfig) {
+            mergedConfig = mergeConfig([
+              mergedConfig,
+              localConfig
+            ]);
+          }
+          _state.label = 4;
+        case 4:
+          if (otherConfig) {
+            mergedConfig = mergeConfig([
+              mergedConfig,
+              otherConfig
+            ]);
+          }
+          return [
+            2,
+            {
+              packageName: loaded.packageName,
+              config: mergedConfig,
+              configFile: loaded.configFile,
+              pkgConfig: loaded.pkgConfig,
+              jsConfig: loaded.config
+            }
+          ];
+      }
+    });
+  });
+  return _createLoadedConfig.apply(this, arguments);
+}
+export {
+  assignPkgConfig,
+  createLoadedConfig
+};

package/dist/esm/cli/run/config/createResolvedConfig.js

@@ -0,0 +1,30 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { createDebugger } from "@modern-js/utils";
+import { mergeConfig } from "../utils/mergeConfig";
+var debug = createDebugger("resolve-config");
+var createResolveConfig = function() {
+  var _ref = _async_to_generator(function(loaded, configs) {
+    var userConfig, resolved;
+    return _ts_generator(this, function(_state) {
+      userConfig = loaded.config;
+      resolved = mergeConfig([
+        {}
+      ].concat(_to_consumable_array(configs), [
+        userConfig
+      ]));
+      debug("resolved %o", resolved);
+      return [
+        2,
+        resolved
+      ];
+    });
+  });
+  return function createResolveConfig2(loaded, configs) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  createResolveConfig
+};

package/dist/esm/cli/run/config/loadConfig.js

@@ -0,0 +1,210 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { bundleRequire, defaultGetOutputFile } from "@modern-js/node-bundle-require";
+import { fs, CONFIG_CACHE_DIR, globby } from "@modern-js/utils";
+var getPackageConfig = function(appDirectory, packageJsonConfig) {
+  var json = JSON.parse(fs.readFileSync(path.resolve(appDirectory, "./package.json"), "utf8"));
+  return json[packageJsonConfig];
+};
+var getConfigFilePath = function(appDirectory, configFilePath) {
+  if (path.isAbsolute(configFilePath)) {
+    return configFilePath;
+  }
+  return path.resolve(appDirectory, configFilePath);
+};
+var clearFilesOverTime = function() {
+  var _ref = _async_to_generator(function(targetDir, overtime) {
+    var files, currentTime, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, file, err;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          _state.trys.push([
+            0,
+            2,
+            ,
+            3
+          ]);
+          return [
+            4,
+            globby("".concat(targetDir, "/**/*"), {
+              stats: true,
+              absolute: true
+            })
+          ];
+        case 1:
+          files = _state.sent();
+          currentTime = Date.now();
+          if (files.length > 0) {
+            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+            try {
+              for (_iterator = files[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                file = _step.value;
+                if (currentTime - file.stats.birthtimeMs >= overtime * 1e3) {
+                  fs.unlinkSync(file.path);
+                }
+              }
+            } catch (err2) {
+              _didIteratorError = true;
+              _iteratorError = err2;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                  _iterator.return();
+                }
+              } finally {
+                if (_didIteratorError) {
+                  throw _iteratorError;
+                }
+              }
+            }
+          }
+          return [
+            3,
+            3
+          ];
+        case 2:
+          err = _state.sent();
+          return [
+            3,
+            3
+          ];
+        case 3:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function clearFilesOverTime2(targetDir, overtime) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var bundleRequireWithCatch = function() {
+  var _ref = _async_to_generator(function(configFile, param) {
+    var appDirectory, mod, e;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          appDirectory = param.appDirectory;
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            3,
+            ,
+            4
+          ]);
+          return [
+            4,
+            bundleRequire(configFile, {
+              autoClear: false,
+              getOutputFile: function() {
+                var _ref2 = _async_to_generator(function(filePath) {
+                  var defaultOutputFileName, _, outputPath, timeLimit;
+                  return _ts_generator(this, function(_state2) {
+                    switch (_state2.label) {
+                      case 0:
+                        _ = path.basename;
+                        return [
+                          4,
+                          defaultGetOutputFile(filePath)
+                        ];
+                      case 1:
+                        defaultOutputFileName = _.apply(path, [
+                          _state2.sent()
+                        ]);
+                        outputPath = path.join(appDirectory, CONFIG_CACHE_DIR);
+                        timeLimit = 10 * 60;
+                        return [
+                          4,
+                          clearFilesOverTime(outputPath, timeLimit)
+                        ];
+                      case 2:
+                        _state2.sent();
+                        return [
+                          2,
+                          path.join(outputPath, defaultOutputFileName)
+                        ];
+                    }
+                  });
+                });
+                return function(filePath) {
+                  return _ref2.apply(this, arguments);
+                };
+              }()
+            })
+          ];
+        case 2:
+          mod = _state.sent();
+          return [
+            2,
+            mod
+          ];
+        case 3:
+          e = _state.sent();
+          if (_instanceof(e, Error)) {
+            e.message = "Get Error while loading config file: ".concat(configFile, ", please check it and retry.\n").concat(e.message || "");
+          }
+          throw e;
+        case 4:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function bundleRequireWithCatch2(configFile, _) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var loadConfig = function() {
+  var _ref = _async_to_generator(function(appDirectory, configFile, packageJsonConfig) {
+    var pkgConfig, packageName, config, mod;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          if (packageJsonConfig) {
+            pkgConfig = getPackageConfig(appDirectory, packageJsonConfig);
+          }
+          packageName = require(path.resolve(appDirectory, "./package.json")).name;
+          if (!configFile)
+            return [
+              3,
+              2
+            ];
+          delete require.cache[configFile];
+          return [
+            4,
+            bundleRequireWithCatch(configFile, {
+              appDirectory
+            })
+          ];
+        case 1:
+          mod = _state.sent();
+          config = mod.default || mod;
+          _state.label = 2;
+        case 2:
+          return [
+            2,
+            {
+              packageName,
+              configFile,
+              config,
+              pkgConfig
+            }
+          ];
+      }
+    });
+  });
+  return function loadConfig2(appDirectory, configFile, packageJsonConfig) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  clearFilesOverTime,
+  getConfigFilePath,
+  getPackageConfig,
+  loadConfig
+};