@modern-js/app-tools 2.58.2 → 2.59.0

package/dist/esm/plugins/initialize/index.js

@@ -0,0 +1,119 @@
+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 { ensureAbsolutePath, getPort, isDev, isDevCommand } from "@modern-js/utils";
+import { checkIsLegacyConfig, createDefaultConfig, createLegacyDefaultConfig, transformNormalizedConfig } from "../../config";
+function initialize_default(param) {
+  var bundler = param.bundler;
+  return {
+    name: "@modern-js/plugin-initialize",
+    post: [
+      "@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"
+    ],
+    setup: function setup(api) {
+      var config = function() {
+        var appContext = api.useAppContext();
+        var userConfig = api.useConfigContext();
+        api.setAppContext(_object_spread_props(_object_spread({}, appContext), {
+          bundlerType: bundler
+        }));
+        return checkIsLegacyConfig(userConfig) ? createLegacyDefaultConfig(appContext) : createDefaultConfig(appContext);
+      };
+      return {
+        config,
+        resolvedConfig: function resolvedConfig(param2) {
+          var resolved = param2.resolved;
+          return _async_to_generator(function() {
+            var _resolved_output_distPath, appContext, userConfig, port, normalizedConfig, _normalizedConfig_autoLoadPlugins;
+            return _ts_generator(this, function(_state) {
+              switch (_state.label) {
+                case 0:
+                  appContext = api.useAppContext();
+                  userConfig = api.useConfigContext();
+                  return [
+                    4,
+                    getServerPort(resolved)
+                  ];
+                case 1:
+                  port = _state.sent();
+                  appContext = _object_spread_props(_object_spread({}, appContext), {
+                    port,
+                    distDirectory: ensureAbsolutePath(appContext.distDirectory, ((_resolved_output_distPath = resolved.output.distPath) === null || _resolved_output_distPath === void 0 ? void 0 : _resolved_output_distPath.root) || "dist")
+                  });
+                  api.setAppContext(appContext);
+                  normalizedConfig = checkIsLegacyConfig(resolved) ? transformNormalizedConfig(resolved) : resolved;
+                  resolved._raw = userConfig;
+                  resolved.server = _object_spread_props(_object_spread({}, normalizedConfig.server || {}), {
+                    port
+                  });
+                  resolved.autoLoadPlugins = (_normalizedConfig_autoLoadPlugins = normalizedConfig.autoLoadPlugins) !== null && _normalizedConfig_autoLoadPlugins !== void 0 ? _normalizedConfig_autoLoadPlugins : false;
+                  stabilizeConfig(resolved, normalizedConfig, [
+                    "source",
+                    "bff",
+                    "dev",
+                    "html",
+                    "output",
+                    "tools",
+                    "testing",
+                    "plugins",
+                    "builderPlugins",
+                    "runtime",
+                    "runtimeByEntries",
+                    "deploy",
+                    "performance"
+                  ]);
+                  if (bundler === "webpack") {
+                    resolved.security = normalizedConfig.security || {};
+                    resolved.experiments = normalizedConfig.experiments;
+                  }
+                  return [
+                    2,
+                    {
+                      resolved
+                    }
+                  ];
+              }
+            });
+          })();
+        }
+      };
+    }
+  };
+}
+;
+function stabilizeConfig(resolve, config, keys) {
+  keys.forEach(function(key) {
+    resolve[key] = config[key] || {};
+  });
+}
+function getServerPort(config) {
+  return _getServerPort.apply(this, arguments);
+}
+function _getServerPort() {
+  _getServerPort = _async_to_generator(function(config) {
+    var prodPort;
+    return _ts_generator(this, function(_state) {
+      prodPort = Number(process.env.PORT) || config.server.port || 8080;
+      if (isDev() && isDevCommand()) {
+        return [
+          2,
+          getPort(Number(process.env.PORT) || config.dev.port || prodPort)
+        ];
+      }
+      return [
+        2,
+        prodPort
+      ];
+    });
+  });
+  return _getServerPort.apply(this, arguments);
+}
+export {
+  initialize_default as default
+};

package/dist/esm/plugins/serverBuild.js

@@ -0,0 +1,87 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import fs from "fs";
+import path from "path";
+import { compile } from "@modern-js/server-utils";
+import { SERVER_DIR, SHARED_DIR, getMeta } from "@modern-js/utils";
+var TS_CONFIG_FILENAME = "tsconfig.json";
+function checkHasCache(appDir) {
+  var tsFilepath = path.resolve(appDir, SERVER_DIR, "cache.ts");
+  var jsfilepath = path.resolve(appDir, SERVER_DIR, "cache.js");
+  return fs.existsSync(tsFilepath) || fs.existsSync(jsfilepath);
+}
+function checkHasConfig(appDir) {
+  var metaName = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "modern-js";
+  var meta = getMeta(metaName);
+  var tsFilepath = path.resolve(appDir, SERVER_DIR, "".concat(meta, ".server.ts"));
+  var jsfilepath = path.resolve(appDir, SERVER_DIR, "".concat(meta, ".server.js"));
+  return fs.existsSync(tsFilepath) || fs.existsSync(jsfilepath);
+}
+function serverBuild_default() {
+  return {
+    name: "@modern-js/server-build",
+    setup: function setup(api) {
+      return {
+        afterBuild: function afterBuild() {
+          return _async_to_generator(function() {
+            var _api_useAppContext, appDirectory, distDirectory, metaName, modernConfig, distDir, serverDir, sharedDir, tsconfigPath, sourceDirs, server, alias, babel;
+            return _ts_generator(this, function(_state) {
+              switch (_state.label) {
+                case 0:
+                  _api_useAppContext = api.useAppContext(), appDirectory = _api_useAppContext.appDirectory, distDirectory = _api_useAppContext.distDirectory, metaName = _api_useAppContext.metaName;
+                  if (!checkHasCache(appDirectory) && !checkHasConfig(appDirectory, metaName)) {
+                    return [
+                      2
+                    ];
+                  }
+                  modernConfig = api.useResolvedConfigContext();
+                  distDir = path.resolve(distDirectory);
+                  serverDir = path.resolve(appDirectory, SERVER_DIR);
+                  sharedDir = path.resolve(appDirectory, SHARED_DIR);
+                  tsconfigPath = path.resolve(appDirectory, TS_CONFIG_FILENAME);
+                  sourceDirs = [];
+                  if (fs.existsSync(serverDir)) {
+                    sourceDirs.push(serverDir);
+                    if (fs.existsSync(sharedDir)) {
+                      sourceDirs.push(sharedDir);
+                    }
+                  }
+                  server = modernConfig.server;
+                  alias = modernConfig.source.alias;
+                  babel = modernConfig.tools.babel;
+                  if (!(sourceDirs.length > 0))
+                    return [
+                      3,
+                      2
+                    ];
+                  return [
+                    4,
+                    compile(appDirectory, {
+                      server,
+                      alias,
+                      babelConfig: babel
+                    }, {
+                      sourceDirs,
+                      distDir,
+                      tsconfigPath
+                    })
+                  ];
+                case 1:
+                  _state.sent();
+                  _state.label = 2;
+                case 2:
+                  return [
+                    2
+                  ];
+              }
+            });
+          })();
+        }
+      };
+    }
+  };
+}
+;
+export {
+  serverBuild_default as default
+};

package/dist/esm/types/config/index.js

@@ -0,0 +1 @@
+export * from "./output";

package/dist/esm/types/index.js

@@ -0,0 +1,3 @@
+export * from "./hooks";
+export * from "./config";
+export * from "./legacyConfig";

package/dist/esm/utils/config.js

@@ -0,0 +1,122 @@
+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 * as path from "path";
+import { bundle } from "@modern-js/node-bundle-require";
+import { fs, CONFIG_FILE_EXTENSIONS, OUTPUT_CONFIG_FILE, ensureAbsolutePath, getServerConfig } from "@modern-js/utils";
+import { stringify } from "flatted";
+var defineServerConfig = function(config) {
+  return config;
+};
+var buildServerConfig = function() {
+  var _ref = _async_to_generator(function(param) {
+    var appDirectory, distDirectory, configFile, options, watch, configFilePath, getOutputFile, configHelperFilePath, helperCode;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          appDirectory = param.appDirectory, distDirectory = param.distDirectory, configFile = param.configFile, options = param.options, watch = param.watch;
+          return [
+            4,
+            getServerConfig(appDirectory, configFile)
+          ];
+        case 1:
+          configFilePath = _state.sent();
+          getOutputFile = function() {
+            var _ref2 = _async_to_generator(function(filepath) {
+              return _ts_generator(this, function(_state2) {
+                return [
+                  2,
+                  path.resolve(distDirectory, "".concat(filepath.replace(new RegExp(CONFIG_FILE_EXTENSIONS.join("|")), ""), ".cjs"))
+                ];
+              });
+            });
+            return function getOutputFile2(filepath) {
+              return _ref2.apply(this, arguments);
+            };
+          }();
+          if (!configFilePath)
+            return [
+              3,
+              5
+            ];
+          configHelperFilePath = path.normalize(path.join(distDirectory, "./config-helper.js"));
+          helperCode = "\n      export const defineConfig = (config) => config;\n    ";
+          return [
+            4,
+            fs.ensureDir(distDirectory)
+          ];
+        case 2:
+          _state.sent();
+          return [
+            4,
+            fs.writeFile(configHelperFilePath, helperCode)
+          ];
+        case 3:
+          _state.sent();
+          return [
+            4,
+            bundle(configFilePath, _object_spread_props(_object_spread({}, options), {
+              watch,
+              getOutputFile,
+              esbuildPlugins: [
+                {
+                  name: "native-build-config",
+                  setup: function setup(ctx) {
+                    ctx.onResolve({
+                      filter: /app-tools\/server/
+                    }, function() {
+                      return {
+                        path: configHelperFilePath
+                      };
+                    });
+                  }
+                }
+              ]
+            }))
+          ];
+        case 4:
+          _state.sent();
+          _state.label = 5;
+        case 5:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function buildServerConfig2(_) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var emitResolvedConfig = function() {
+  var _ref = _async_to_generator(function(appDirectory, resolvedConfig) {
+    var _resolvedConfig_output_distPath, outputPath, output;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          outputPath = ensureAbsolutePath(appDirectory, path.join(((_resolvedConfig_output_distPath = resolvedConfig.output.distPath) === null || _resolvedConfig_output_distPath === void 0 ? void 0 : _resolvedConfig_output_distPath.root) || "./dist", OUTPUT_CONFIG_FILE));
+          output = stringify(resolvedConfig);
+          return [
+            4,
+            fs.writeFile(outputPath, output, {
+              encoding: "utf-8"
+            })
+          ];
+        case 1:
+          _state.sent();
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function emitResolvedConfig2(appDirectory, resolvedConfig) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  buildServerConfig,
+  defineServerConfig,
+  emitResolvedConfig
+};

package/dist/esm/utils/createServer.js

@@ -0,0 +1,58 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { applyPlugins } from "@modern-js/prod-server";
+import { createDevServer } from "@modern-js/server";
+var server = null;
+var getServer = function() {
+  return server;
+};
+var setServer = function(newServer) {
+  server = newServer;
+};
+var closeServer = function() {
+  var _ref = _async_to_generator(function() {
+    return _ts_generator(this, function(_state) {
+      if (server) {
+        server.close();
+        server = null;
+      }
+      return [
+        2
+      ];
+    });
+  });
+  return function closeServer2() {
+    return _ref.apply(this, arguments);
+  };
+}();
+var createServer = function() {
+  var _ref = _async_to_generator(function(options) {
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          if (server) {
+            server.close();
+          }
+          return [
+            4,
+            createDevServer(options, applyPlugins)
+          ];
+        case 1:
+          server = _state.sent().server;
+          return [
+            2,
+            server
+          ];
+      }
+    });
+  });
+  return function createServer2(options) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  closeServer,
+  createServer,
+  getServer,
+  setServer
+};

package/dist/esm/utils/env.js

@@ -0,0 +1,16 @@
+import { cutNameByHyphen } from "@modern-js/utils/universal";
+function getAutoInjectEnv(appContext) {
+  var metaName = appContext.metaName;
+  var prefix = "".concat(cutNameByHyphen(metaName), "_").toUpperCase();
+  var envReg = new RegExp("^".concat(prefix));
+  return Object.keys(process.env).reduce(function(prev, key) {
+    var value = process.env[key];
+    if (envReg.test(key) && typeof value !== "undefined") {
+      prev["process.env.".concat(key)] = value;
+    }
+    return prev;
+  }, {});
+}
+export {
+  getAutoInjectEnv
+};

package/dist/esm/utils/generateWatchFiles.js

@@ -0,0 +1,71 @@
+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 path from "path";
+import { fs, getServerConfig } from "@modern-js/utils";
+var getPackageConfig = function(appDirectory, packageJsonConfig) {
+  var PACKAGE_JSON_CONFIG_NAME = "modernConfig";
+  var json = JSON.parse(fs.readFileSync(path.resolve(appDirectory, "./package.json"), "utf8"));
+  return json[packageJsonConfig !== null && packageJsonConfig !== void 0 ? packageJsonConfig : PACKAGE_JSON_CONFIG_NAME];
+};
+var addServerConfigToDeps = function() {
+  var _ref = _async_to_generator(function(dependencies, appDirectory, serverConfigFile) {
+    var serverConfig;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            getServerConfig(appDirectory, serverConfigFile)
+          ];
+        case 1:
+          serverConfig = _state.sent();
+          if (serverConfig) {
+            dependencies.push(serverConfig);
+          }
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function addServerConfigToDeps2(dependencies, appDirectory, serverConfigFile) {
+    return _ref.apply(this, arguments);
+  };
+}();
+function generateWatchFiles(appContext, configDir) {
+  return _generateWatchFiles.apply(this, arguments);
+}
+function _generateWatchFiles() {
+  _generateWatchFiles = _async_to_generator(function(appContext, configDir) {
+    var appDirectory, configFile, configPath, dependencies;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          appDirectory = appContext.appDirectory, configFile = appContext.configFile;
+          configPath = path.join(appDirectory, configDir || "");
+          dependencies = getPackageConfig(appContext.appDirectory, appContext.packageName) ? [
+            path.resolve(appDirectory, "./package.json")
+          ] : [];
+          return [
+            4,
+            addServerConfigToDeps(dependencies, appContext.appDirectory, appContext.serverConfigFile)
+          ];
+        case 1:
+          _state.sent();
+          return [
+            2,
+            [
+              "".concat(configPath, "/html"),
+              configFile || "./config"
+            ].concat(_to_consumable_array(dependencies))
+          ];
+      }
+    });
+  });
+  return _generateWatchFiles.apply(this, arguments);
+}
+export {
+  addServerConfigToDeps,
+  generateWatchFiles
+};

package/dist/esm/utils/getSelectedEntries.js

@@ -0,0 +1,67 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { chalk, inquirer } from "@modern-js/utils";
+import { i18n, localeKeys } from "../locale";
+var getSelectedEntries = function() {
+  var _ref = _async_to_generator(function(entry, entrypoints) {
+    var entryNames, selected;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          entryNames = entrypoints.map(function(e) {
+            return e.entryName;
+          });
+          if (!entry) {
+            return [
+              2,
+              entryNames
+            ];
+          }
+          if (!(typeof entry === "boolean"))
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            inquirer.prompt([
+              {
+                type: "checkbox",
+                name: "selected",
+                choices: entryNames,
+                message: i18n.t(localeKeys.command.dev.selectEntry),
+                validate: function validate(answer) {
+                  if (answer.length < 1) {
+                    return i18n.t(localeKeys.command.dev.requireEntry);
+                  }
+                  return true;
+                }
+              }
+            ])
+          ];
+        case 1:
+          selected = _state.sent().selected;
+          return [
+            2,
+            selected
+          ];
+        case 2:
+          entry.forEach(function(name) {
+            if (!entryNames.includes(name)) {
+              throw new Error("Can not found entry ".concat(chalk.yellow(name), ", the entry should be one of ").concat(chalk.yellow(entryNames.join(", "))));
+            }
+          });
+          return [
+            2,
+            entry
+          ];
+      }
+    });
+  });
+  return function getSelectedEntries2(entry, entrypoints) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  getSelectedEntries
+};

package/dist/esm/utils/loadPlugins.js

@@ -0,0 +1,74 @@
+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 { loadServerPlugins as loadServerPluginInstances } from "@modern-js/prod-server";
+function getServerPlugins(api) {
+  return _getServerPlugins.apply(this, arguments);
+}
+function _getServerPlugins() {
+  _getServerPlugins = _async_to_generator(function(api) {
+    var metaName, runner, plugins, filtedPlugins;
+    var _arguments = arguments;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          metaName = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : "modern-js";
+          runner = api.useHookRunners();
+          return [
+            4,
+            runner._internalServerPlugins({
+              plugins: []
+            })
+          ];
+        case 1:
+          plugins = _state.sent().plugins;
+          filtedPlugins = plugins.filter(function(plugin) {
+            return plugin.name.includes(metaName);
+          });
+          api.setAppContext(_object_spread_props(_object_spread({}, api.useAppContext()), {
+            serverPlugins: filtedPlugins
+          }));
+          return [
+            2,
+            filtedPlugins
+          ];
+      }
+    });
+  });
+  return _getServerPlugins.apply(this, arguments);
+}
+function loadServerPlugins(api, appDirectory, metaName) {
+  return _loadServerPlugins.apply(this, arguments);
+}
+function _loadServerPlugins() {
+  _loadServerPlugins = _async_to_generator(function(api, appDirectory, metaName) {
+    var plugins, instances;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            getServerPlugins(api, metaName)
+          ];
+        case 1:
+          plugins = _state.sent();
+          return [
+            4,
+            loadServerPluginInstances(plugins, appDirectory)
+          ];
+        case 2:
+          instances = _state.sent();
+          return [
+            2,
+            instances
+          ];
+      }
+    });
+  });
+  return _loadServerPlugins.apply(this, arguments);
+}
+export {
+  getServerPlugins,
+  loadServerPlugins
+};