@modern-js/app-tools 2.62.1 → 2.62.2-alpha.0

package/dist/esm/new/compat/index.js

@@ -0,0 +1,33 @@
+import { getHookRunners } from "./hooks";
+var compatPlugin = function() {
+  return {
+    name: "@modern-js/app-tools-compat",
+    _registryApi: function(getAppContext, updateAppContext) {
+      var getInternalContext = function() {
+        return getAppContext()._internalContext;
+      };
+      return {
+        useAppContext: function() {
+          return getAppContext();
+        },
+        setAppContext: function(context) {
+          return updateAppContext(context);
+        },
+        useConfigContext: function() {
+          return getInternalContext().config;
+        },
+        useResolvedConfigContext: function() {
+          return getInternalContext().normalizedConfig;
+        },
+        useHookRunners: function() {
+          return getHookRunners(getInternalContext());
+        }
+      };
+    },
+    setup: function(_api) {
+    }
+  };
+};
+export {
+  compatPlugin
+};

package/dist/esm/new/compat/utils.js

@@ -0,0 +1,69 @@
+function transformHookRunner(hookRunnerName) {
+  switch (hookRunnerName) {
+    case "beforeConfig":
+      return "onBeforeConfig";
+    case "prepare":
+      return "onPrepare";
+    case "afterPrepare":
+      return "onAfterPrepare";
+    case "beforeGenerateRoutes":
+      return "onBeforeGenerateRoutes";
+    case "beforePrintInstructions":
+      return "onBeforePrintInstructions";
+    case "resolvedConfig":
+      return "modifyResolvedConfig";
+    case "commands":
+      return "addCommand";
+    case "watchFiles":
+      return "addWatchFiles";
+    case "filedChange":
+      return "onFileChanged";
+    case "beforeCreateCompiler":
+      return "onBeforeCreateCompiler";
+    case "afterCreateCompiler":
+      return "onAfterCreateCompiler";
+    case "beforeBuild":
+      return "onBeforeBuild";
+    case "afterBuild":
+      return "onAfterBuild";
+    case "beforeDev":
+      return "onBeforeDev";
+    case "afterDev":
+      return "onAfterDev";
+    case "beforeDeploy":
+      return "onBeforeDeploy";
+    case "afterDeploy":
+      return "onAfterDeploy";
+    case "beforeExit":
+      return "onBeforeExit";
+    case "beforeRestart":
+      return "onBeforeRestart";
+    case "htmlPartials":
+      return "modifyHtmlPartials";
+    default:
+      return hookRunnerName;
+  }
+}
+function transformHookParams(hookRunnerName, params) {
+  switch (hookRunnerName) {
+    case "resolvedConfig":
+      return {
+        resolved: params
+      };
+    default:
+      return params;
+  }
+}
+function transformHookResult(hookRunnerName, result) {
+  switch (hookRunnerName) {
+    case "resolvedConfig":
+      return result.resolved;
+    default:
+      return result;
+  }
+}
+export {
+  transformHookParams,
+  transformHookResult,
+  transformHookRunner
+};

package/dist/esm/new/constants.js

@@ -0,0 +1,10 @@
+var PACKAGE_JSON_CONFIG_NAME = "modernConfig";
+var DEFAULT_CONFIG_FILE = "modern.config";
+var DEFAULT_SERVER_CONFIG_FILE = "modern.server-runtime.config";
+var DEFAULT_RUNTIME_CONFIG_FILE = "modern.runtime";
+export {
+  DEFAULT_CONFIG_FILE,
+  DEFAULT_RUNTIME_CONFIG_FILE,
+  DEFAULT_SERVER_CONFIG_FILE,
+  PACKAGE_JSON_CONFIG_NAME
+};

package/dist/esm/new/context.js

@@ -0,0 +1,30 @@
+import path from "path";
+import { address } from "@modern-js/utils";
+var initAppContext = function(param) {
+  var appDirectory = param.appDirectory, runtimeConfigFile = param.runtimeConfigFile, options = param.options, serverConfigFile = param.serverConfigFile, tempDir = param.tempDir;
+  var _ref = options || {}, _ref_metaName = _ref.metaName, metaName = _ref_metaName === void 0 ? "modern-js" : _ref_metaName, _ref_apiDir = _ref.apiDir, apiDir = _ref_apiDir === void 0 ? "api" : _ref_apiDir, _ref_distDir = _ref.distDir, distDir = _ref_distDir === void 0 ? "" : _ref_distDir, _ref_sharedDir = _ref.sharedDir, sharedDir = _ref_sharedDir === void 0 ? "shared" : _ref_sharedDir;
+  return {
+    metaName,
+    runtimeConfigFile,
+    serverConfigFile,
+    ip: address.ip(),
+    port: 0,
+    moduleType: require(path.resolve(appDirectory, "./package.json")).type || "commonjs",
+    apiDirectory: path.resolve(appDirectory, apiDir),
+    lambdaDirectory: path.resolve(appDirectory, apiDir, "lambda"),
+    sharedDirectory: path.resolve(appDirectory, sharedDir),
+    distDirectory: distDir,
+    serverPlugins: [],
+    internalDirectory: path.resolve(appDirectory, tempDir || "./node_modules/.".concat(metaName)),
+    htmlTemplates: {},
+    serverRoutes: [],
+    entrypoints: [],
+    checkedEntries: [],
+    apiOnly: false,
+    internalDirAlias: "@_".concat(metaName.replace(/-/g, "_"), "_internal"),
+    internalSrcAlias: "@_".concat(metaName.replace(/-/g, "_"), "_src")
+  };
+};
+export {
+  initAppContext
+};

package/dist/esm/new/getConfigFile.js

@@ -0,0 +1,11 @@
+import path from "path";
+import { CONFIG_FILE_EXTENSIONS, findExists } from "@modern-js/utils";
+import { DEFAULT_CONFIG_FILE } from "./constants";
+var getConfigFile = function(configFile) {
+  return findExists(CONFIG_FILE_EXTENSIONS.map(function(extension) {
+    return path.resolve(process.cwd(), "".concat(configFile || DEFAULT_CONFIG_FILE).concat(extension));
+  }));
+};
+export {
+  getConfigFile
+};

package/dist/esm/new/index.js

@@ -0,0 +1,55 @@
+import { createAsyncHook } from "@modern-js/plugin-v2";
+import { appTools as oldAppTools } from "../old";
+import { compatPlugin } from "./compat";
+import { DEFAULT_RUNTIME_CONFIG_FILE, DEFAULT_SERVER_CONFIG_FILE } from "./constants";
+import { initAppContext } from "./context";
+export * from "../defineConfig";
+var appTools = function() {
+  var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+    // default webpack to be compatible with original projects
+    bundler: "webpack"
+  };
+  return {
+    name: "@modern-js/app-tools",
+    usePlugins: [
+      compatPlugin(),
+      oldAppTools(options)
+    ],
+    post: [
+      "@modern-js/app-tools-old"
+    ],
+    registryHooks: {
+      onBeforeConfig: createAsyncHook(),
+      onAfterPrepare: createAsyncHook(),
+      deploy: createAsyncHook(),
+      _internalRuntimePlugins: createAsyncHook(),
+      _internalServerPlugins: createAsyncHook(),
+      checkEntryPoint: createAsyncHook(),
+      modifyEntrypoints: createAsyncHook(),
+      modifyFileSystemRoutes: createAsyncHook(),
+      modifyServerRoutes: createAsyncHook(),
+      generateEntryCode: createAsyncHook(),
+      onBeforeGenerateRoutes: createAsyncHook(),
+      onBeforePrintInstructions: createAsyncHook(),
+      registerDev: createAsyncHook(),
+      registerBuildPlatform: createAsyncHook(),
+      addRuntimeExports: createAsyncHook()
+    },
+    setup: function(api) {
+      var _userConfig_output;
+      var context = api.getAppContext();
+      var userConfig = api.getConfig();
+      api.updateAppContext(initAppContext({
+        appDirectory: context.appDirectory,
+        options: {},
+        serverConfigFile: DEFAULT_SERVER_CONFIG_FILE,
+        runtimeConfigFile: DEFAULT_RUNTIME_CONFIG_FILE,
+        tempDir: (_userConfig_output = userConfig.output) === null || _userConfig_output === void 0 ? void 0 : _userConfig_output.tempDir
+      }));
+    }
+  };
+};
+export {
+  appTools,
+  initAppContext
+};

package/dist/esm/new/loadPlugins.js

@@ -0,0 +1,94 @@
+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 { compatibleRequire, createDebugger, dynamicImport, getInternalPlugins, tryResolve } from "@modern-js/utils";
+var debug = createDebugger("load-plugins");
+var resolveCliPlugin = function() {
+  var _ref = _async_to_generator(function(p, appDirectory) {
+    var pkg, pluginOptions, path, module, e, ref, result;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          pkg = typeof p === "string" ? p : p[0];
+          pluginOptions = typeof p === "string" ? void 0 : p[1];
+          path = tryResolve(pkg, appDirectory);
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            3,
+            ,
+            5
+          ]);
+          return [
+            4,
+            compatibleRequire(path)
+          ];
+        case 2:
+          module = _state.sent();
+          return [
+            3,
+            5
+          ];
+        case 3:
+          e = _state.sent();
+          return [
+            4,
+            dynamicImport(path)
+          ];
+        case 4:
+          ref = _state.sent(), module = ref.default, ref;
+          return [
+            3,
+            5
+          ];
+        case 5:
+          if (typeof module === "function") {
+            result = module(pluginOptions);
+            return [
+              2,
+              result
+            ];
+          }
+          return [
+            2,
+            module
+          ];
+      }
+    });
+  });
+  return function resolveCliPlugin2(p, appDirectory) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var loadInternalPlugins = function() {
+  var _ref = _async_to_generator(function(appDirectory, internalPlugins, autoLoad, autoLoadPlugins) {
+    var plugins, loadedPlugins;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          plugins = _to_consumable_array(autoLoadPlugins ? getInternalPlugins(appDirectory, internalPlugins) : []).concat(_to_consumable_array(autoLoad ? getInternalPlugins(appDirectory, autoLoad) : []));
+          return [
+            4,
+            Promise.all(plugins.map(function(plugin) {
+              var loadedPlugin = resolveCliPlugin(plugin, appDirectory);
+              debug("resolve plugin %s: %s", plugin, loadedPlugin);
+              return loadedPlugin;
+            }))
+          ];
+        case 1:
+          loadedPlugins = _state.sent();
+          return [
+            2,
+            loadedPlugins
+          ];
+      }
+    });
+  });
+  return function loadInternalPlugins2(appDirectory, internalPlugins, autoLoad, autoLoadPlugins) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  loadInternalPlugins
+};

package/dist/esm/new/run.js

@@ -0,0 +1,80 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { initAppDir } from "@modern-js/plugin-v2/cli";
+import { run as CLIPluginRun } from "@modern-js/plugin-v2/run";
+import { minimist } from "@modern-js/utils";
+import { handleSetupResult } from "./compat/hooks";
+import { PACKAGE_JSON_CONFIG_NAME } from "./constants";
+import { getConfigFile } from "./getConfigFile";
+import { loadInternalPlugins } from "./loadPlugins";
+import { getIsAutoLoadPlugins } from "./utils";
+function run(_) {
+  return _run.apply(this, arguments);
+}
+function _run() {
+  _run = _async_to_generator(function(param) {
+    var cwd, initialLog, version, internalPlugins, packageJsonConfig, configFile, command, cliParams, SUPPORT_CONFIG_PARAM_COMMANDS, customConfigFile, appDirectory, finalConfigFile, autoLoadPlugins, plugins;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          cwd = param.cwd, initialLog = param.initialLog, version = param.version, internalPlugins = param.internalPlugins, packageJsonConfig = param.packageJsonConfig, configFile = param.configFile;
+          command = process.argv[2];
+          cliParams = minimist(process.argv.slice(2));
+          SUPPORT_CONFIG_PARAM_COMMANDS = [
+            "dev",
+            "build",
+            "deploy",
+            "start",
+            "serve",
+            "inspect",
+            "upgrade"
+          ];
+          if (SUPPORT_CONFIG_PARAM_COMMANDS.includes(command)) {
+            customConfigFile = cliParams.config || cliParams.c;
+          }
+          if (command === "new") {
+            customConfigFile = cliParams["config-file"];
+          }
+          return [
+            4,
+            initAppDir(cwd)
+          ];
+        case 1:
+          appDirectory = _state.sent();
+          finalConfigFile = customConfigFile || getConfigFile(configFile);
+          return [
+            4,
+            getIsAutoLoadPlugins(appDirectory, finalConfigFile)
+          ];
+        case 2:
+          autoLoadPlugins = _state.sent();
+          return [
+            4,
+            loadInternalPlugins(appDirectory, internalPlugins === null || internalPlugins === void 0 ? void 0 : internalPlugins.cli, internalPlugins === null || internalPlugins === void 0 ? void 0 : internalPlugins.autoLoad, autoLoadPlugins)
+          ];
+        case 3:
+          plugins = _state.sent();
+          return [
+            4,
+            CLIPluginRun({
+              cwd,
+              initialLog: initialLog || "Modern.js Framework v".concat(version),
+              configFile: finalConfigFile,
+              packageJsonConfig: packageJsonConfig || PACKAGE_JSON_CONFIG_NAME,
+              internalPlugins: plugins,
+              handleSetupResult
+            })
+          ];
+        case 4:
+          _state.sent();
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _run.apply(this, arguments);
+}
+export {
+  run
+};

package/dist/esm/new/utils/index.js

@@ -0,0 +1,33 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { createLoadedConfig } from "@modern-js/plugin-v2/cli";
+function getIsAutoLoadPlugins(appDirectory) {
+  return _getIsAutoLoadPlugins.apply(this, arguments);
+}
+function _getIsAutoLoadPlugins() {
+  _getIsAutoLoadPlugins = _async_to_generator(function(appDirectory) {
+    var configFile, packageJsonConfig, _loaded_config, loaded, autoLoadPlugins;
+    var _arguments = arguments;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          configFile = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : "modern.config.ts", packageJsonConfig = _arguments.length > 2 && _arguments[2] !== void 0 ? _arguments[2] : "ModernConfig";
+          return [
+            4,
+            createLoadedConfig(appDirectory, configFile, packageJsonConfig)
+          ];
+        case 1:
+          loaded = _state.sent();
+          autoLoadPlugins = (_loaded_config = loaded.config) === null || _loaded_config === void 0 ? void 0 : _loaded_config.autoLoadPlugins;
+          return [
+            2,
+            autoLoadPlugins || false
+          ];
+      }
+    });
+  });
+  return _getIsAutoLoadPlugins.apply(this, arguments);
+}
+export {
+  getIsAutoLoadPlugins
+};

package/dist/esm/old.js

@@ -0,0 +1,258 @@
+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 _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { getLocaleLanguage } from "@modern-js/plugin-i18n/language-detector";
+import { castArray } from "@modern-js/uni-builder";
+import { cleanRequireCache, deprecatedCommands, emptyDir, getArgv, getCommand } from "@modern-js/utils";
+import { hooks } from "./hooks";
+import { i18n } from "./locale";
+import analyzePlugin from "./plugins/analyze";
+import deployPlugin from "./plugins/deploy";
+import initializePlugin from "./plugins/initialize";
+import serverBuildPlugin from "./plugins/serverBuild";
+import { buildCommand, deployCommand, devCommand, inspectCommand, newCommand, serverCommand, upgradeCommand } from "./commands";
+import { generateWatchFiles } from "./utils/generateWatchFiles";
+import { restart } from "./utils/restart";
+import { dev } from "./commands/dev";
+import { mergeConfig } from "@modern-js/core";
+export * from "./defineConfig";
+export * from "./types";
+var appTools = function() {
+  var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+    // default webpack to be compatible with original projects
+    bundler: "webpack"
+  };
+  return {
+    name: "@modern-js/app-tools-old",
+    post: [
+      "@modern-js/plugin-initialize",
+      "@modern-js/plugin-analyze",
+      "@modern-js/plugin-ssr",
+      "@modern-js/plugin-document",
+      "@modern-js/plugin-state",
+      "@modern-js/plugin-router",
+      "@modern-js/plugin-router-v5",
+      "@modern-js/plugin-polyfill"
+    ],
+    registerHook: hooks,
+    usePlugins: [
+      initializePlugin({
+        bundler: (options === null || options === void 0 ? void 0 : options.bundler) && [
+          "rspack",
+          "experimental-rspack"
+        ].includes(options.bundler) ? "rspack" : "webpack"
+      }),
+      analyzePlugin({
+        bundler: (options === null || options === void 0 ? void 0 : options.bundler) && [
+          "rspack",
+          "experimental-rspack"
+        ].includes(options.bundler) ? "rspack" : "webpack"
+      }),
+      serverBuildPlugin(),
+      deployPlugin()
+    ],
+    setup: function(api) {
+      var appContext = api.useAppContext();
+      api.setAppContext(_object_spread_props(_object_spread({}, appContext), {
+        toolsType: "app-tools"
+      }));
+      var locale = getLocaleLanguage();
+      i18n.changeLanguage({
+        locale
+      });
+      return {
+        beforeConfig: function beforeConfig() {
+          return _async_to_generator(function() {
+            var _userConfig_output, userConfig, appContext2;
+            return _ts_generator(this, function(_state) {
+              userConfig = api.useConfigContext();
+              appContext2 = api.useAppContext();
+              if ((_userConfig_output = userConfig.output) === null || _userConfig_output === void 0 ? void 0 : _userConfig_output.tempDir) {
+                api.setAppContext(_object_spread_props(_object_spread({}, appContext2), {
+                  internalDirectory: path.resolve(appContext2.appDirectory, userConfig.output.tempDir)
+                }));
+              }
+              return [
+                2
+              ];
+            });
+          })();
+        },
+        commands: function commands(param) {
+          var program = param.program;
+          return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+              switch (_state.label) {
+                case 0:
+                  return [
+                    4,
+                    devCommand(program, api)
+                  ];
+                case 1:
+                  _state.sent();
+                  return [
+                    4,
+                    buildCommand(program, api)
+                  ];
+                case 2:
+                  _state.sent();
+                  serverCommand(program, api);
+                  deployCommand(program, api);
+                  newCommand(program, locale);
+                  inspectCommand(program, api);
+                  upgradeCommand(program);
+                  deprecatedCommands(program);
+                  return [
+                    2
+                  ];
+              }
+            });
+          })();
+        },
+        prepare: function prepare() {
+          return _async_to_generator(function() {
+            var command, isSkipBuild, resolvedConfig, appContext2;
+            return _ts_generator(this, function(_state) {
+              switch (_state.label) {
+                case 0:
+                  command = getCommand();
+                  if (command === "deploy") {
+                    isSkipBuild = [
+                      "-s",
+                      "--skip-build"
+                    ].some(function(tag) {
+                      return getArgv().includes(tag);
+                    });
+                    if (isSkipBuild) {
+                      return [
+                        2
+                      ];
+                    }
+                  }
+                  if (!(command === "dev" || command === "start" || command === "build" || command === "deploy"))
+                    return [
+                      3,
+                      2
+                    ];
+                  resolvedConfig = api.useResolvedConfigContext();
+                  if (!resolvedConfig.output.cleanDistPath)
+                    return [
+                      3,
+                      2
+                    ];
+                  appContext2 = api.useAppContext();
+                  return [
+                    4,
+                    emptyDir(appContext2.distDirectory)
+                  ];
+                case 1:
+                  _state.sent();
+                  _state.label = 2;
+                case 2:
+                  return [
+                    2
+                  ];
+              }
+            });
+          })();
+        },
+        watchFiles: function watchFiles() {
+          return _async_to_generator(function() {
+            var appContext2, config, files, watchFiles2;
+            return _ts_generator(this, function(_state) {
+              switch (_state.label) {
+                case 0:
+                  appContext2 = api.useAppContext();
+                  config = api.useResolvedConfigContext();
+                  return [
+                    4,
+                    generateWatchFiles(appContext2, config.source.configDir)
+                  ];
+                case 1:
+                  files = _state.sent();
+                  watchFiles2 = castArray(config.dev.watchFiles);
+                  watchFiles2.forEach(function(param) {
+                    var type = param.type, paths = param.paths;
+                    if (type === "reload-server") {
+                      var _files;
+                      (_files = files).push.apply(_files, _to_consumable_array(Array.isArray(paths) ? paths : [
+                        paths
+                      ]));
+                    }
+                  });
+                  return [
+                    2,
+                    files
+                  ];
+              }
+            });
+          })();
+        },
+        fileChange: (
+          // 这里会被 core/initWatcher 监听的文件变动触发，如果是 src 目录下的文件变动，则不做 restart
+          function fileChange(e) {
+            return _async_to_generator(function() {
+              var filename, eventType, isPrivate, closeServer;
+              return _ts_generator(this, function(_state) {
+                switch (_state.label) {
+                  case 0:
+                    filename = e.filename, eventType = e.eventType, isPrivate = e.isPrivate;
+                    if (!(!isPrivate && (eventType === "change" || eventType === "unlink")))
+                      return [
+                        3,
+                        4
+                      ];
+                    return [
+                      4,
+                      import("./utils/createServer.js")
+                    ];
+                  case 1:
+                    closeServer = _state.sent().closeServer;
+                    return [
+                      4,
+                      closeServer()
+                    ];
+                  case 2:
+                    _state.sent();
+                    return [
+                      4,
+                      restart(api.useHookRunners(), filename)
+                    ];
+                  case 3:
+                    _state.sent();
+                    _state.label = 4;
+                  case 4:
+                    return [
+                      2
+                    ];
+                }
+              });
+            })();
+          }
+        ),
+        beforeRestart: function beforeRestart() {
+          return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+              cleanRequireCache([
+                require.resolve("./plugins/analyze")
+              ]);
+              return [
+                2
+              ];
+            });
+          })();
+        }
+      };
+    }
+  };
+};
+var old_default = appTools;
+export {
+  appTools,
+  old_default as default,
+  dev,
+  mergeConfig
+};

package/dist/esm/utils/restart.js

@@ -1,6 +1,6 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { cli } from "@modern-js/core";
+import { cli } from "@modern-js/plugin-v2/cli";
 import { chalk, clearConsole, getFullArgv, logger, program } from "@modern-js/utils";
 function restart(hooksRunner, filename) {
   return _restart.apply(this, arguments);