@modern-js/app-tools 2.58.2 → 2.59.0

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

@@ -0,0 +1,380 @@
+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 _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import * as path from "path";
+import { fs, createDebugger, getArgv, isApiOnly, isDevCommand, minimist } from "@modern-js/utils";
+import { createBuilderGenerator } from "../../builder";
+import { initialNormalizedConfig } from "../../config";
+import { emitResolvedConfig } from "../../utils/config";
+import { getSelectedEntries } from "../../utils/getSelectedEntries";
+import { printInstructions } from "../../utils/printInstructions";
+import { generateRoutes } from "../../utils/routes";
+import { checkIsBuildCommands } from "./utils";
+var debug = createDebugger("plugin-analyze");
+function analyze_default(param) {
+  var bundler = param.bundler;
+  return {
+    name: "@modern-js/plugin-analyze",
+    post: [
+      "@modern-js/runtime"
+    ],
+    setup: function(api) {
+      var pagesDir = [];
+      var nestedRouteEntries = [];
+      return {
+        prepare: function prepare() {
+          return _async_to_generator(function() {
+            var _resolvedConfig_source, appContext, resolvedConfig, hookRunners, apiOnly, routes, _ref, getBundleEntry, getServerRoutes, getHtmlTemplate, entrypoints, _, _tmp, initialRoutes, routes1, htmlTemplates, checkedEntries, entry, normalizedConfig, createBuilderForModern, builder;
+            return _ts_generator(this, function(_state) {
+              switch (_state.label) {
+                case 0:
+                  appContext = api.useAppContext();
+                  resolvedConfig = api.useResolvedConfigContext();
+                  hookRunners = api.useHookRunners();
+                  try {
+                    if (checkIsBuildCommands()) {
+                      fs.emptydirSync(appContext.internalDirectory);
+                    }
+                  } catch (e) {
+                  }
+                  return [
+                    4,
+                    isApiOnly(appContext.appDirectory, (_resolvedConfig_source = resolvedConfig.source) === null || _resolvedConfig_source === void 0 ? void 0 : _resolvedConfig_source.entriesDir, appContext.apiDirectory)
+                  ];
+                case 1:
+                  apiOnly = _state.sent();
+                  return [
+                    4,
+                    hookRunners.addRuntimeExports()
+                  ];
+                case 2:
+                  _state.sent();
+                  if (!apiOnly)
+                    return [
+                      3,
+                      4
+                    ];
+                  return [
+                    4,
+                    hookRunners.modifyServerRoutes({
+                      routes: []
+                    })
+                  ];
+                case 3:
+                  routes = _state.sent().routes;
+                  debug("server routes: %o", routes);
+                  appContext = _object_spread_props(_object_spread({}, api.useAppContext()), {
+                    apiOnly,
+                    serverRoutes: routes
+                  });
+                  api.setAppContext(appContext);
+                  return [
+                    2
+                  ];
+                case 4:
+                  return [
+                    4,
+                    Promise.all([
+                      import("./getBundleEntry.js"),
+                      import("./getServerRoutes.js"),
+                      import("./getHtmlTemplate.js")
+                    ])
+                  ];
+                case 5:
+                  _ref = _sliced_to_array.apply(void 0, [
+                    _state.sent(),
+                    3
+                  ]), getBundleEntry = _ref[0].getBundleEntry, getServerRoutes = _ref[1].getServerRoutes, getHtmlTemplate = _ref[2].getHtmlTemplate;
+                  _ = hookRunners.modifyEntrypoints;
+                  _tmp = {};
+                  return [
+                    4,
+                    getBundleEntry(hookRunners, appContext, resolvedConfig)
+                  ];
+                case 6:
+                  return [
+                    4,
+                    _.apply(hookRunners, [
+                      (_tmp.entrypoints = _state.sent(), _tmp)
+                    ])
+                  ];
+                case 7:
+                  entrypoints = _state.sent().entrypoints;
+                  debug("entrypoints: %o", entrypoints);
+                  initialRoutes = getServerRoutes(entrypoints, {
+                    appContext,
+                    config: resolvedConfig
+                  });
+                  return [
+                    4,
+                    hookRunners.modifyServerRoutes({
+                      routes: initialRoutes
+                    })
+                  ];
+                case 8:
+                  routes1 = _state.sent().routes;
+                  debug("server routes: %o", routes1);
+                  appContext = _object_spread_props(_object_spread({}, api.useAppContext()), {
+                    entrypoints,
+                    serverRoutes: routes1
+                  });
+                  api.setAppContext(appContext);
+                  nestedRouteEntries = entrypoints.map(function(point) {
+                    return point.nestedRoutesEntry;
+                  }).filter(Boolean);
+                  pagesDir = entrypoints.map(function(point) {
+                    return point.entry;
+                  }).filter(function(entry2) {
+                    return entry2 && !path.extname(entry2);
+                  }).concat(nestedRouteEntries);
+                  return [
+                    4,
+                    getHtmlTemplate(entrypoints, api, {
+                      appContext,
+                      config: resolvedConfig
+                    })
+                  ];
+                case 9:
+                  htmlTemplates = _state.sent();
+                  debug("html templates: %o", htmlTemplates);
+                  return [
+                    4,
+                    hookRunners.addDefineTypes()
+                  ];
+                case 10:
+                  _state.sent();
+                  debug("add Define Types");
+                  checkedEntries = entrypoints.map(function(point) {
+                    return point.entryName;
+                  });
+                  if (!isDevCommand())
+                    return [
+                      3,
+                      12
+                    ];
+                  entry = minimist(getArgv()).entry;
+                  return [
+                    4,
+                    getSelectedEntries(typeof entry === "string" ? entry.split(",") : entry, entrypoints)
+                  ];
+                case 11:
+                  checkedEntries = _state.sent();
+                  _state.label = 12;
+                case 12:
+                  appContext = _object_spread_props(_object_spread({}, api.useAppContext()), {
+                    entrypoints,
+                    checkedEntries,
+                    apiOnly,
+                    serverRoutes: routes1,
+                    htmlTemplates
+                  });
+                  api.setAppContext(appContext);
+                  if (!checkIsBuildCommands())
+                    return [
+                      3,
+                      16
+                    ];
+                  return [
+                    4,
+                    hookRunners.generateEntryCode({
+                      entrypoints
+                    })
+                  ];
+                case 13:
+                  _state.sent();
+                  normalizedConfig = api.useResolvedConfigContext();
+                  return [
+                    4,
+                    createBuilderGenerator(bundler)
+                  ];
+                case 14:
+                  createBuilderForModern = _state.sent();
+                  return [
+                    4,
+                    createBuilderForModern({
+                      normalizedConfig,
+                      appContext
+                    })
+                  ];
+                case 15:
+                  builder = _state.sent();
+                  builder.onBeforeBuild(function() {
+                    var _ref2 = _async_to_generator(function(param2) {
+                      var bundlerConfigs, isFirstCompile, hookRunners2;
+                      return _ts_generator(this, function(_state2) {
+                        switch (_state2.label) {
+                          case 0:
+                            bundlerConfigs = param2.bundlerConfigs, isFirstCompile = param2.isFirstCompile;
+                            if (!isFirstCompile) {
+                              return [
+                                2
+                              ];
+                            }
+                            hookRunners2 = api.useHookRunners();
+                            return [
+                              4,
+                              generateRoutes(appContext)
+                            ];
+                          case 1:
+                            _state2.sent();
+                            return [
+                              4,
+                              hookRunners2.beforeBuild({
+                                bundlerConfigs
+                              })
+                            ];
+                          case 2:
+                            _state2.sent();
+                            return [
+                              2
+                            ];
+                        }
+                      });
+                    });
+                    return function(_2) {
+                      return _ref2.apply(this, arguments);
+                    };
+                  }());
+                  builder.onAfterBuild(function() {
+                    var _ref2 = _async_to_generator(function(param2) {
+                      var stats, hookRunners2;
+                      return _ts_generator(this, function(_state2) {
+                        switch (_state2.label) {
+                          case 0:
+                            stats = param2.stats;
+                            hookRunners2 = api.useHookRunners();
+                            return [
+                              4,
+                              hookRunners2.afterBuild({
+                                stats
+                              })
+                            ];
+                          case 1:
+                            _state2.sent();
+                            return [
+                              4,
+                              emitResolvedConfig(appContext.appDirectory, normalizedConfig)
+                            ];
+                          case 2:
+                            _state2.sent();
+                            return [
+                              2
+                            ];
+                        }
+                      });
+                    });
+                    return function(_2) {
+                      return _ref2.apply(this, arguments);
+                    };
+                  }());
+                  builder.onDevCompileDone(function() {
+                    var _ref2 = _async_to_generator(function(param2) {
+                      var isFirstCompile, hookRunners2;
+                      return _ts_generator(this, function(_state2) {
+                        isFirstCompile = param2.isFirstCompile;
+                        hookRunners2 = api.useHookRunners();
+                        hookRunners2.afterDev({
+                          isFirstCompile
+                        });
+                        if (isFirstCompile) {
+                          printInstructions(hookRunners2, appContext, normalizedConfig);
+                        }
+                        return [
+                          2
+                        ];
+                      });
+                    });
+                    return function(_2) {
+                      return _ref2.apply(this, arguments);
+                    };
+                  }());
+                  builder.onBeforeCreateCompiler(function() {
+                    var _ref2 = _async_to_generator(function(param2) {
+                      var bundlerConfigs, hookRunners2;
+                      return _ts_generator(this, function(_state2) {
+                        switch (_state2.label) {
+                          case 0:
+                            bundlerConfigs = param2.bundlerConfigs;
+                            hookRunners2 = api.useHookRunners();
+                            return [
+                              4,
+                              hookRunners2.beforeCreateCompiler({
+                                bundlerConfigs
+                              })
+                            ];
+                          case 1:
+                            _state2.sent();
+                            return [
+                              2
+                            ];
+                        }
+                      });
+                    });
+                    return function(_2) {
+                      return _ref2.apply(this, arguments);
+                    };
+                  }());
+                  builder.onAfterCreateCompiler(function() {
+                    var _ref2 = _async_to_generator(function(param2) {
+                      var compiler, hookRunners2;
+                      return _ts_generator(this, function(_state2) {
+                        switch (_state2.label) {
+                          case 0:
+                            compiler = param2.compiler;
+                            hookRunners2 = api.useHookRunners();
+                            return [
+                              4,
+                              hookRunners2.afterCreateCompiler({
+                                compiler
+                              })
+                            ];
+                          case 1:
+                            _state2.sent();
+                            return [
+                              2
+                            ];
+                        }
+                      });
+                    });
+                    return function(_2) {
+                      return _ref2.apply(this, arguments);
+                    };
+                  }());
+                  builder.addPlugins(resolvedConfig.builderPlugins);
+                  appContext = _object_spread_props(_object_spread({}, api.useAppContext()), {
+                    builder
+                  });
+                  api.setAppContext(appContext);
+                  _state.label = 16;
+                case 16:
+                  return [
+                    2
+                  ];
+              }
+            });
+          })();
+        },
+        watchFiles: function watchFiles() {
+          return {
+            files: pagesDir,
+            isPrivate: true
+          };
+        },
+        resolvedConfig: function resolvedConfig(param2) {
+          var resolved = param2.resolved;
+          var appContext = api.useAppContext();
+          var config = initialNormalizedConfig(resolved, appContext, bundler);
+          return {
+            resolved: config
+          };
+        }
+      };
+    }
+  };
+}
+;
+export {
+  analyze_default as default
+};

package/dist/esm/plugins/analyze/isDefaultExportFunction.js

@@ -0,0 +1,49 @@
+import fs from "fs";
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+import * as t from "@babel/types";
+var isFunction = function(node) {
+  return t.isFunctionDeclaration(node) || t.isFunctionExpression(node) || t.isArrowFunctionExpression(node);
+};
+var isDefaultExportFunction = function(file) {
+  if (!file || !fs.existsSync(file)) {
+    return false;
+  }
+  var ast = parse(fs.readFileSync(file, "utf8"), {
+    sourceType: "unambiguous",
+    plugins: [
+      "jsx",
+      "typescript",
+      "classProperties",
+      "dynamicImport",
+      "exportDefaultFrom",
+      "exportNamespaceFrom",
+      "decorators-legacy",
+      "functionBind",
+      "classPrivateMethods",
+      [
+        "pipelineOperator",
+        {
+          proposal: "minimal"
+        }
+      ],
+      "optionalChaining",
+      "optionalCatchBinding",
+      "objectRestSpread",
+      "numericSeparator"
+    ]
+  });
+  var isExportFunction = false;
+  traverse(ast, {
+    ExportDefaultDeclaration: function(path) {
+      var declaration = path.node.declaration;
+      if (isFunction(declaration)) {
+        isExportFunction = true;
+      }
+    }
+  });
+  return isExportFunction;
+};
+export {
+  isDefaultExportFunction
+};

package/dist/esm/plugins/analyze/templates.js

@@ -0,0 +1,6 @@
+var html = function(partials) {
+  return "\n<!DOCTYPE html>\n<html>\n<head>\n\n  ".concat(partials.top.join("\n"), "\n\n  ").concat(partials.head.join("\n"), '\n\n</head>\n\n<body>\n  <div id="<%= mountId %>"><!--<?- html ?>--></div>\n  ').concat(partials.body.join("\n"), "\n  <!--<?- chunksMap.js ?>-->\n  <!--<?- SSRDataScript ?>-->\n  <!--<?- bottomTemplate ?>-->\n</body>\n\n</html>\n");
+};
+export {
+  html
+};

package/dist/esm/plugins/analyze/utils.js

@@ -0,0 +1,101 @@
+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 fs from "fs";
+import path from "path";
+import { JS_EXTENSIONS, getCommand, normalizeToPosixPath } from "@modern-js/utils";
+import { parse } from "es-module-lexer";
+import { transform } from "esbuild";
+var walkDirectory = function(dir) {
+  return fs.readdirSync(dir).reduce(function(previous, filename) {
+    var filePath = path.join(dir, filename);
+    if (fs.statSync(filePath).isDirectory()) {
+      return _to_consumable_array(previous).concat(_to_consumable_array(walkDirectory(filePath)));
+    } else {
+      return _to_consumable_array(previous).concat([
+        filePath
+      ]);
+    }
+  }, []);
+};
+var replaceWithAlias = function(base, filePath, alias) {
+  if (filePath.includes(base)) {
+    return normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
+  } else {
+    return filePath;
+  }
+};
+var parseModule = function() {
+  var _ref = _async_to_generator(function(param) {
+    var source, filename, content, result;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          source = param.source, filename = param.filename;
+          content = source;
+          if (!JS_EXTENSIONS.some(function(ext) {
+            return filename.endsWith(ext);
+          }))
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            transform(content, {
+              loader: path.extname(filename).slice(1),
+              format: "esm"
+            })
+          ];
+        case 1:
+          result = _state.sent();
+          content = result.code;
+          _state.label = 2;
+        case 2:
+          return [
+            4,
+            parse(content)
+          ];
+        case 3:
+          return [
+            2,
+            _state.sent()
+          ];
+      }
+    });
+  });
+  return function parseModule2(_) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var getServerCombinedModueFile = function(internalDirectory, entryName) {
+  return path.join(internalDirectory, entryName, "server-loader-combined.js");
+};
+var checkIsBuildCommands = function() {
+  var buildCommands = [
+    "dev",
+    "start",
+    "build",
+    "inspect",
+    "deploy",
+    "dev-worker"
+  ];
+  var command = getCommand();
+  return buildCommands.includes(command);
+};
+var isSubDirOrEqual = function(parent, child) {
+  if (parent === child) {
+    return true;
+  }
+  var relative = path.relative(parent, child);
+  var isSubdir = relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+  return Boolean(isSubdir);
+};
+export {
+  checkIsBuildCommands,
+  getServerCombinedModueFile,
+  isSubDirOrEqual,
+  parseModule,
+  replaceWithAlias,
+  walkDirectory
+};