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

package/dist/esm/cli/run/create.js

@@ -0,0 +1,300 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { createDebugger, logger } from "@modern-js/utils";
+import { program } from "@modern-js/utils/commander";
+import { createPluginManager } from "../../manager";
+import { initPluginAPI } from "../api";
+import { createContext, initAppContext } from "../context";
+import { createLoadedConfig } from "./config/createLoadedConfig";
+import { createResolveConfig } from "./config/createResolvedConfig";
+import { checkIsDuplicationPlugin } from "./utils/checkIsDuplicationPlugin";
+import { initCommandsMap, setProgramVersion } from "./utils/commander";
+import { createFileWatcher } from "./utils/createFileWatcher";
+import { initAppDir } from "./utils/initAppDir";
+import { loadEnv } from "./utils/loadEnv";
+var debug = createDebugger("plugin-v2");
+var createCli = function() {
+  var createExistListener = function createExistListener2(event, context) {
+    return function() {
+      var _ref = _async_to_generator(function(err) {
+        var hasError;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              return [
+                4,
+                context.hooks.onBeforeExit.call()
+              ];
+            case 1:
+              _state.sent();
+              hasError = false;
+              if (_instanceof(err, Error)) {
+                logger.error(err.stack);
+                hasError = true;
+              } else if (err && (event === "unhandledRejection" || event === "uncaughtException")) {
+                console.trace("Unknown Error", err);
+                hasError = true;
+              }
+              process.nextTick(function() {
+                process.exit(hasError ? 1 : 0);
+              });
+              return [
+                2
+              ];
+          }
+        });
+      });
+      return function(err) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+  };
+  var init = function init2(options) {
+    return _init.apply(this, arguments);
+  };
+  var run = function run2(options) {
+    return _run.apply(this, arguments);
+  };
+  var initOptions;
+  var pluginManager = createPluginManager();
+  var existListenerMap = /* @__PURE__ */ new Map();
+  function _init() {
+    _init = _async_to_generator(function(options) {
+      var _context_hooks_onAfterPrepare, _context_hooks, _options_metaName, metaName, configFile, config, command, version, packageJsonConfig, internalPlugins, handleSetupResult, appDirectory, loaded, allPlugins, plugins, context, pluginAPI, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, plugin, _plugin_setup, setupResult, err, extraConfigs, normalizedConfig, resolved;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            pluginManager.clear();
+            initOptions = options;
+            _options_metaName = options.metaName, metaName = _options_metaName === void 0 ? "MODERN" : _options_metaName, configFile = options.configFile, config = options.config, command = options.command, version = options.version, packageJsonConfig = options.packageJsonConfig, internalPlugins = options.internalPlugins, handleSetupResult = options.handleSetupResult;
+            return [
+              4,
+              initAppDir(options === null || options === void 0 ? void 0 : options.cwd)
+            ];
+          case 1:
+            appDirectory = _state.sent();
+            initCommandsMap();
+            setProgramVersion(version);
+            loadEnv(appDirectory, process.env["".concat(metaName.toUpperCase(), "_ENV")]);
+            return [
+              4,
+              createLoadedConfig(appDirectory, configFile, packageJsonConfig, config)
+            ];
+          case 2:
+            loaded = _state.sent();
+            allPlugins = _to_consumable_array(internalPlugins || []).concat(_to_consumable_array(loaded.config.plugins || []));
+            checkIsDuplicationPlugin(allPlugins.map(function(plugin2) {
+              return plugin2.name;
+            }), loaded.config.autoLoadPlugins);
+            pluginManager.addPlugins(allPlugins);
+            return [
+              4,
+              pluginManager.getPlugins()
+            ];
+          case 3:
+            plugins = _state.sent();
+            debug("CLI Plugins:", plugins.map(function(p) {
+              return p.name;
+            }));
+            return [
+              4,
+              createContext({
+                appContext: initAppContext({
+                  packageName: loaded.packageName,
+                  configFile: loaded.configFile,
+                  command,
+                  appDirectory,
+                  plugins
+                }),
+                config: loaded.config,
+                normalizedConfig: {}
+              })
+            ];
+          case 4:
+            context = _state.sent();
+            pluginAPI = initPluginAPI({
+              context,
+              pluginManager
+            });
+            context.pluginAPI = pluginAPI;
+            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+            _state.label = 5;
+          case 5:
+            _state.trys.push([
+              5,
+              11,
+              12,
+              13
+            ]);
+            _iterator = plugins[Symbol.iterator]();
+            _state.label = 6;
+          case 6:
+            if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done))
+              return [
+                3,
+                10
+              ];
+            plugin = _step.value;
+            return [
+              4,
+              (_plugin_setup = plugin.setup) === null || _plugin_setup === void 0 ? void 0 : _plugin_setup.call(plugin, pluginAPI)
+            ];
+          case 7:
+            setupResult = _state.sent();
+            if (!handleSetupResult)
+              return [
+                3,
+                9
+              ];
+            return [
+              4,
+              handleSetupResult(setupResult, pluginAPI)
+            ];
+          case 8:
+            _state.sent();
+            _state.label = 9;
+          case 9:
+            _iteratorNormalCompletion = true;
+            return [
+              3,
+              6
+            ];
+          case 10:
+            return [
+              3,
+              13
+            ];
+          case 11:
+            err = _state.sent();
+            _didIteratorError = true;
+            _iteratorError = err;
+            return [
+              3,
+              13
+            ];
+          case 12:
+            try {
+              if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+            return [
+              7
+            ];
+          case 13:
+            [
+              "SIGINT",
+              "SIGTERM",
+              "unhandledRejection",
+              "uncaughtException"
+            ].forEach(function(event) {
+              if (existListenerMap.get(event)) {
+                process.off(event, existListenerMap.get(event));
+              }
+              var existListener = createExistListener(event, context);
+              existListenerMap.set(event, existListener);
+              process.on(event, existListener);
+            });
+            return [
+              4,
+              context.hooks.config.call()
+            ];
+          case 14:
+            extraConfigs = _state.sent();
+            return [
+              4,
+              createResolveConfig(loaded, extraConfigs)
+            ];
+          case 15:
+            normalizedConfig = _state.sent();
+            return [
+              4,
+              context.hooks.modifyResolvedConfig.call(normalizedConfig)
+            ];
+          case 16:
+            resolved = _state.sent();
+            context.normalizedConfig = resolved || normalizedConfig;
+            return [
+              4,
+              pluginAPI.updateAppContext(context)
+            ];
+          case 17:
+            _state.sent();
+            return [
+              4,
+              context.hooks.onPrepare.call()
+            ];
+          case 18:
+            _state.sent();
+            return [
+              4,
+              (_context_hooks = context.hooks) === null || _context_hooks === void 0 ? void 0 : (_context_hooks_onAfterPrepare = _context_hooks.onAfterPrepare) === null || _context_hooks_onAfterPrepare === void 0 ? void 0 : _context_hooks_onAfterPrepare.call()
+            ];
+          case 19:
+            _state.sent();
+            return [
+              2,
+              {
+                appContext: context
+              }
+            ];
+        }
+      });
+    });
+    return _init.apply(this, arguments);
+  }
+  function _run() {
+    _run = _async_to_generator(function(options) {
+      var _program_commands, appContext;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            return [
+              4,
+              init(options)
+            ];
+          case 1:
+            appContext = _state.sent().appContext;
+            return [
+              4,
+              appContext.hooks.addCommand.call({
+                program
+              })
+            ];
+          case 2:
+            _state.sent();
+            return [
+              4,
+              createFileWatcher(appContext)
+            ];
+          case 3:
+            _state.sent();
+            program.parse(process.argv);
+            if (!((_program_commands = program.commands) === null || _program_commands === void 0 ? void 0 : _program_commands.length)) {
+              logger.warn("No command found, please make sure you have registered plugins correctly.");
+            }
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return _run.apply(this, arguments);
+  }
+  return {
+    init,
+    run,
+    getPrevInitOptions: function() {
+      return initOptions;
+    }
+  };
+};
+export {
+  createCli
+};

package/dist/esm/cli/run/index.js

@@ -0,0 +1,10 @@
+import { createCli } from "./create";
+import { createLoadedConfig } from "./config/createLoadedConfig";
+import { initAppDir } from "./utils/initAppDir";
+var cli = createCli();
+export {
+  cli,
+  createCli,
+  createLoadedConfig,
+  initAppDir
+};

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

@@ -0,0 +1,60 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_without_properties } from "@swc/helpers/_/_object_without_properties";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { logger } from "@modern-js/utils";
+import { cli } from ".";
+var run = function() {
+  var _ref = _async_to_generator(function(options) {
+    var initialLog, version, cwd, configFile, params, command;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          initialLog = options.initialLog, version = options.version, cwd = options.cwd, configFile = options.configFile, params = _object_without_properties(options, [
+            "initialLog",
+            "version",
+            "cwd",
+            "configFile"
+          ]);
+          if (initialLog) {
+            logger.greet("  ".concat(initialLog, "\n"));
+          }
+          command = process.argv[2];
+          if (!process.env.NODE_ENV) {
+            if ([
+              "build",
+              "serve",
+              "deploy",
+              "analyze"
+            ].includes(command)) {
+              process.env.NODE_ENV = "production";
+            } else if (command === "test") {
+              process.env.NODE_ENV = "test";
+            } else {
+              process.env.NODE_ENV = "development";
+            }
+          }
+          return [
+            4,
+            cli.run(_object_spread({
+              version,
+              cwd,
+              command,
+              configFile
+            }, params))
+          ];
+        case 1:
+          _state.sent();
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function run2(options) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  run
+};

package/dist/esm/cli/run/utils/checkIsDuplicationPlugin.js

@@ -0,0 +1,24 @@
+import { logger } from "@modern-js/utils";
+function checkIsDuplicationPlugin(plugins) {
+  var autoLoadPlugin = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+  var set = /* @__PURE__ */ new Set();
+  var duplicationPlugins = [];
+  plugins.filter(function(plugin) {
+    return typeof plugin === "string";
+  }).forEach(function(plugin) {
+    if (set.has(plugin)) {
+      duplicationPlugins.push(plugin);
+    } else {
+      set.add(plugin);
+    }
+  });
+  if (duplicationPlugins.length > 0) {
+    logger.warn("Duplicate registration plugins: ".concat(duplicationPlugins.join(","), "."));
+    if (autoLoadPlugin) {
+      logger.warn("This is probably because you enabled `autoLoadPlugin` configuration and also registered these plugins manually");
+    }
+  }
+}
+export {
+  checkIsDuplicationPlugin
+};

package/dist/esm/cli/run/utils/commander.js

@@ -0,0 +1,42 @@
+import { program } from "@modern-js/utils";
+var setProgramVersion = function() {
+  var version = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "unknown";
+  var name = process.argv[1];
+  program.name(name).usage("<command> [options]").version(version);
+};
+function initCommandsMap() {
+  if (!program.hasOwnProperty("commandsMap")) {
+    Object.defineProperty(program, "commandsMap", {
+      get: function get() {
+        var map = /* @__PURE__ */ new Map();
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+        try {
+          for (var _iterator = program.commands[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var command = _step.value;
+            map.set(command._name, command);
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+        return map;
+      },
+      configurable: false
+    });
+  }
+}
+export {
+  initCommandsMap,
+  program,
+  setProgramVersion
+};

package/dist/esm/cli/run/utils/createFileWatcher.js

@@ -0,0 +1,110 @@
+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 crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+import { chokidar, createDebugger, isDevCommand } from "@modern-js/utils";
+var debug = createDebugger("watch-files");
+var hashMap = /* @__PURE__ */ new Map();
+var md5 = function(data) {
+  return crypto.createHash("md5").update(data).digest("hex");
+};
+var createFileWatcher = function() {
+  var _ref = _async_to_generator(function(appContext) {
+    var appDirectory, extraFiles, watched, privateWatched, isPrivate, watcher;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          if (!isDevCommand())
+            return [
+              3,
+              2
+            ];
+          appDirectory = appContext.appDirectory;
+          return [
+            4,
+            appContext.hooks.addWatchFiles.call()
+          ];
+        case 1:
+          extraFiles = _state.sent();
+          watched = extraFiles.filter(function(extra) {
+            return Array.isArray(extra);
+          }).flat();
+          privateWatched = extraFiles.filter(function(extra) {
+            return !Array.isArray(extra) && extra.isPrivate;
+          }).map(function(extra) {
+            return extra.files;
+          }).flat();
+          isPrivate = function(filename) {
+            return privateWatched.some(function(ff) {
+              return path.resolve(appDirectory, filename).startsWith(ff);
+            });
+          };
+          debug("watched: %o", watched);
+          watcher = chokidar.watch(_to_consumable_array(watched).concat(_to_consumable_array(privateWatched)), {
+            cwd: appDirectory,
+            ignoreInitial: true,
+            ignorePermissionErrors: true,
+            ignored: [
+              "**/__test__/**",
+              "**/*.test.(js|jsx|ts|tsx)",
+              "**/*.spec.(js|jsx|ts|tsx)",
+              "**/*.stories.(js|jsx|ts|tsx)"
+            ]
+          });
+          watcher.on("change", function(changed) {
+            var lastHash = hashMap.get(changed);
+            var currentHash = md5(fs.readFileSync(path.join(appDirectory, changed), "utf8"));
+            if (currentHash !== lastHash) {
+              debug("file change: %s", changed);
+              hashMap.set(changed, currentHash);
+              appContext.hooks.onFileChanged.call({
+                filename: changed,
+                eventType: "change",
+                isPrivate: isPrivate(changed)
+              });
+            }
+          });
+          watcher.on("add", function(changed) {
+            debug("add file: %s", changed);
+            var currentHash = md5(fs.readFileSync(path.join(appDirectory, changed), "utf8"));
+            hashMap.set(changed, currentHash);
+            appContext.hooks.onFileChanged.call({
+              filename: changed,
+              eventType: "add",
+              isPrivate: isPrivate(changed)
+            });
+          });
+          watcher.on("unlink", function(changed) {
+            debug("remove file: %s", changed);
+            if (hashMap.has(changed)) {
+              hashMap.delete(changed);
+            }
+            appContext.hooks.onFileChanged.call({
+              filename: changed,
+              eventType: "unlink",
+              isPrivate: isPrivate(changed)
+            });
+          });
+          watcher.on("error", function(err) {
+            throw err;
+          });
+          return [
+            2,
+            watcher
+          ];
+        case 2:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function createFileWatcher2(appContext) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  createFileWatcher
+};

package/dist/esm/cli/run/utils/debug.js

@@ -0,0 +1,5 @@
+import { createDebugger } from "@modern-js/utils";
+var debug = createDebugger("plugin-v2");
+export {
+  debug
+};

package/dist/esm/cli/run/utils/initAppDir.js

@@ -0,0 +1,36 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { pkgUp } from "@modern-js/utils";
+var initAppDir = function() {
+  var _ref = _async_to_generator(function(currentDir) {
+    var cwd, pkg;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          cwd = currentDir || process.cwd();
+          return [
+            4,
+            pkgUp({
+              cwd
+            })
+          ];
+        case 1:
+          pkg = _state.sent();
+          if (!pkg) {
+            throw new Error("no package.json found in current work dir: ".concat(cwd));
+          }
+          return [
+            2,
+            path.dirname(pkg)
+          ];
+      }
+    });
+  });
+  return function initAppDir2(currentDir) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  initAppDir
+};

package/dist/esm/cli/run/utils/loadEnv.js

@@ -0,0 +1,24 @@
+import fs from "fs";
+import path from "path";
+import { dotenv, dotenvExpand } from "@modern-js/utils";
+var loadEnv = function(appDirectory) {
+  var mode = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : process.env.NODE_ENV;
+  [
+    ".env.".concat(mode, ".local"),
+    ".env.local",
+    ".env.".concat(mode),
+    ".env"
+  ].map(function(name) {
+    return path.resolve(appDirectory, name);
+  }).filter(function(filePath) {
+    return fs.existsSync(filePath) && !fs.statSync(filePath).isDirectory();
+  }).forEach(function(filePath) {
+    var envConfig = dotenv.config({
+      path: filePath
+    });
+    dotenvExpand(envConfig);
+  });
+};
+export {
+  loadEnv
+};

package/dist/esm/cli/run/utils/mergeConfig.js

@@ -0,0 +1,43 @@
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+import { ensureArray, isOverriddenConfigKey } from "@modern-js/utils";
+import { isFunction, mergeWith } from "@modern-js/utils/lodash";
+var mergeConfig = function(configs) {
+  return mergeWith.apply(void 0, [
+    {}
+  ].concat(_to_consumable_array(configs), [
+    function(target, source, key) {
+      if (key === "designSystem" || key === "tailwindcss" && (typeof source === "undefined" ? "undefined" : _type_of(source)) === "object") {
+        return mergeWith({}, target !== null && target !== void 0 ? target : {}, source !== null && source !== void 0 ? source : {});
+      }
+      if (isOverriddenConfigKey(key)) {
+        return source !== null && source !== void 0 ? source : target;
+      }
+      if (Array.isArray(target) || Array.isArray(source)) {
+        if (target === void 0) {
+          return source;
+        }
+        if (source === void 0) {
+          return target;
+        }
+        return _to_consumable_array(ensureArray(target)).concat(_to_consumable_array(ensureArray(source)));
+      }
+      if (isFunction(target) || isFunction(source)) {
+        if (source === void 0) {
+          return target;
+        }
+        if (target === void 0) {
+          return source;
+        }
+        return [
+          target,
+          source
+        ];
+      }
+      return void 0;
+    }
+  ]));
+};
+export {
+  mergeConfig
+};