@modern-js/app-tools 2.69.4 → 3.0.0-alpha.0

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

@@ -1,214 +1,227 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var analyze_exports = {};
-__export(analyze_exports, {
-  default: () => analyze_default
-});
-module.exports = __toCommonJS(analyze_exports);
-var path = __toESM(require("path"));
-var import_utils = require("@modern-js/utils");
-var import_builder = require("../../builder");
-var import_config = require("../../config");
-var import_config2 = require("../../utils/config");
-var import_getSelectedEntries = require("../../utils/getSelectedEntries");
-var import_printInstructions = require("../../utils/printInstructions");
-var import_routes = require("../../utils/routes");
-var import_utils2 = require("./utils");
-const debug = (0, import_utils.createDebugger)("plugin-analyze");
-var analyze_default = ({ bundler }) => ({
-  name: "@modern-js/plugin-analyze",
-  post: [
-    "@modern-js/runtime"
-  ],
-  setup: (api) => {
-    let pagesDir = [];
-    let nestedRouteEntries = [];
-    api.onPrepare(async () => {
-      var _resolvedConfig_source;
-      let appContext = api.getAppContext();
-      const resolvedConfig = api.getNormalizedConfig();
-      const hooks = api.getHooks();
-      try {
-        if ((0, import_utils2.checkIsBuildCommands)()) {
-          import_utils.fs.emptydirSync(appContext.internalDirectory);
-        }
-      } catch {
-      }
-      const apiOnly = await (0, import_utils.isApiOnly)(appContext.appDirectory, (_resolvedConfig_source = resolvedConfig.source) === null || _resolvedConfig_source === void 0 ? void 0 : _resolvedConfig_source.entriesDir, appContext.apiDirectory);
-      await hooks.addRuntimeExports.call();
-      const [{ getProdServerRoutes }] = await Promise.all([
-        import("./getServerRoutes.js")
-      ]);
-      if (apiOnly) {
-        const routes2 = [];
-        if ((0, import_utils2.checkIsServeCommand)()) {
-          routes2.push(...getProdServerRoutes(appContext.distDirectory));
-        } else {
-          const { routes: modifiedRoutes } = await hooks.modifyServerRoutes.call({
-            routes: []
-          });
-          routes2.push(...modifiedRoutes);
-        }
-        debug(`server routes: %o`, routes2);
-        api.updateAppContext({
-          apiOnly,
-          serverRoutes: routes2
-        });
-        return;
-      }
-      const [{ getBundleEntry }, { getServerRoutes }, { getHtmlTemplate }] = await Promise.all([
-        import("./getBundleEntry.js"),
-        import("./getServerRoutes.js"),
-        import("./getHtmlTemplate.js")
-      ]);
-      const { entrypoints } = await hooks.modifyEntrypoints.call({
-        entrypoints: await getBundleEntry(hooks, appContext, resolvedConfig)
-      });
-      debug(`entrypoints: %o`, entrypoints);
-      const routes = [];
-      if ((0, import_utils2.checkIsServeCommand)()) {
-        routes.push(...getProdServerRoutes(appContext.distDirectory));
-      } else {
-        const initialRoutes = getServerRoutes(entrypoints, {
-          appContext,
-          config: resolvedConfig
-        });
-        const { routes: modifiedRoutes } = await hooks.modifyServerRoutes.call({
-          routes: initialRoutes
-        });
-        routes.push(...modifiedRoutes);
-      }
-      debug(`server routes: %o`, routes);
-      appContext = {
-        ...api.getAppContext(),
-        entrypoints,
-        serverRoutes: routes
-      };
-      api.updateAppContext(appContext);
-      nestedRouteEntries = entrypoints.map((point) => point.nestedRoutesEntry).filter(Boolean);
-      pagesDir = entrypoints.map((point) => point.entry).filter((entry) => entry && !path.extname(entry)).concat(nestedRouteEntries);
-      const { partialsByEntrypoint, htmlTemplates } = await getHtmlTemplate(entrypoints, hooks, {
-        appContext,
-        config: resolvedConfig
-      });
-      debug(`html templates: %o`, htmlTemplates);
-      api.updateAppContext({
-        partialsByEntrypoint
-      });
-      let checkedEntries = entrypoints.map((point) => point.entryName);
-      if ((0, import_utils.isDevCommand)()) {
-        const { entry } = (0, import_utils.minimist)((0, import_utils.getArgv)());
-        checkedEntries = await (0, import_getSelectedEntries.getSelectedEntries)(typeof entry === "string" ? entry.split(",") : entry, entrypoints);
-      }
-      appContext = {
-        ...api.getAppContext(),
-        entrypoints,
-        checkedEntries,
-        apiOnly,
-        serverRoutes: routes,
-        htmlTemplates
-      };
-      api.updateAppContext(appContext);
-      if ((0, import_utils2.checkIsBuildCommands)()) {
-        await hooks.generateEntryCode.call({
-          entrypoints
-        });
-        const normalizedConfig = api.getNormalizedConfig();
-        const createBuilderForModern = await (0, import_builder.createBuilderGenerator)(bundler);
-        const builder = await createBuilderForModern({
-          normalizedConfig,
-          appContext
-        });
-        builder.onBeforeBuild(async ({ bundlerConfigs, isFirstCompile, environments, isWatch }) => {
-          if (!isFirstCompile) {
-            return;
-          }
-          await (0, import_routes.generateRoutes)(appContext);
-          await hooks.onBeforeBuild.call({
-            isFirstCompile,
-            isWatch,
-            environments,
-            bundlerConfigs
-          });
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
         });
-        builder.onAfterBuild(async ({ stats, environments, isFirstCompile, isWatch }) => {
-          await hooks.onAfterBuild.call({
-            stats,
-            environments,
-            isFirstCompile,
-            isWatch
-          });
-          await (0, import_config2.emitResolvedConfig)(appContext.appDirectory, normalizedConfig);
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
         });
-        builder.onDevCompileDone(async ({ isFirstCompile, stats, environments }) => {
-          hooks.onDevCompileDone.call({
-            isFirstCompile,
-            stats,
-            environments
-          });
-          if (isFirstCompile) {
-            (0, import_printInstructions.printInstructions)(hooks, appContext, normalizedConfig);
-          }
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
         });
-        builder.onBeforeCreateCompiler(async ({ bundlerConfigs, environments }) => {
-          await hooks.onBeforeCreateCompiler.call({
-            environments,
-            bundlerConfigs
-          });
-        });
-        builder.onAfterCreateCompiler(async ({ compiler, environments }) => {
-          await hooks.onAfterCreateCompiler.call({
-            environments,
-            compiler
-          });
-        });
-        builder.onAfterStartDevServer(async ({ port }) => {
-          await hooks.onAfterDev.call({
-            port
-          });
-        });
-        builder.addPlugins(resolvedConfig.builderPlugins);
-        api.updateAppContext({
-          builder
-        });
-      }
-    });
-    api.addWatchFiles(() => {
-      return {
-        files: pagesDir,
-        isPrivate: true
-      };
-    });
-    api.modifyResolvedConfig((resolved) => {
-      const appContext = api.getAppContext();
-      const config = (0, import_config.initialNormalizedConfig)(resolved, appContext, bundler);
-      return config;
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>analyze
+});
+const external_path_namespaceObject = require("path");
+const utils_namespaceObject = require("@modern-js/utils");
+const index_js_namespaceObject = require("../../builder/index.js");
+const external_config_index_js_namespaceObject = require("../../config/index.js");
+const config_js_namespaceObject = require("../../utils/config.js");
+const getSelectedEntries_js_namespaceObject = require("../../utils/getSelectedEntries.js");
+const printInstructions_js_namespaceObject = require("../../utils/printInstructions.js");
+const routes_js_namespaceObject = require("../../utils/routes.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const debug = (0, utils_namespaceObject.createDebugger)('plugin-analyze');
+const analyze = ()=>({
+        name: '@modern-js/plugin-analyze',
+        post: [
+            '@modern-js/runtime'
+        ],
+        setup: (api)=>{
+            let pagesDir = [];
+            let nestedRouteEntries = [];
+            const routesConfigFiles = [];
+            api.onPrepare(async ()=>{
+                let appContext = api.getAppContext();
+                const resolvedConfig = api.getNormalizedConfig();
+                const hooks = api.getHooks();
+                try {
+                    if ((0, external_utils_js_namespaceObject.checkIsBuildCommands)()) utils_namespaceObject.fs.emptydirSync(appContext.internalDirectory);
+                } catch  {}
+                const apiOnly = await (0, utils_namespaceObject.isApiOnly)(appContext.appDirectory, resolvedConfig.source?.entriesDir, appContext.apiDirectory);
+                const [{ getProdServerRoutes }] = await Promise.all([
+                    import("./getServerRoutes.js")
+                ]);
+                if (apiOnly) {
+                    const routes = [];
+                    if ((0, external_utils_js_namespaceObject.checkIsServeCommand)()) routes.push(...getProdServerRoutes(appContext.distDirectory));
+                    else {
+                        const { routes: modifiedRoutes } = await hooks.modifyServerRoutes.call({
+                            routes: []
+                        });
+                        routes.push(...modifiedRoutes);
+                    }
+                    debug("server routes: %o", routes);
+                    api.updateAppContext({
+                        apiOnly,
+                        serverRoutes: routes
+                    });
+                    return;
+                }
+                const [{ getBundleEntry }, { getServerRoutes }, { getHtmlTemplate }] = await Promise.all([
+                    import("./getBundleEntry.js"),
+                    import("./getServerRoutes.js"),
+                    import("./getHtmlTemplate.js")
+                ]);
+                const { entrypoints } = await hooks.modifyEntrypoints.call({
+                    entrypoints: await getBundleEntry(hooks, appContext, resolvedConfig)
+                });
+                debug("entrypoints: %o", entrypoints);
+                const routes = [];
+                if ((0, external_utils_js_namespaceObject.checkIsServeCommand)()) routes.push(...getProdServerRoutes(appContext.distDirectory));
+                else {
+                    const initialRoutes = getServerRoutes(entrypoints, {
+                        appContext,
+                        config: resolvedConfig
+                    });
+                    const { routes: modifiedRoutes } = await hooks.modifyServerRoutes.call({
+                        routes: initialRoutes
+                    });
+                    routes.push(...modifiedRoutes);
+                }
+                debug("server routes: %o", routes);
+                appContext = {
+                    ...api.getAppContext(),
+                    entrypoints,
+                    serverRoutes: routes
+                };
+                api.updateAppContext(appContext);
+                nestedRouteEntries = entrypoints.map((point)=>point.nestedRoutesEntry).filter(Boolean);
+                pagesDir = entrypoints.map((point)=>point.entry).filter((entry)=>entry && !external_path_namespaceObject.extname(entry)).concat(nestedRouteEntries);
+                const meta = (0, utils_namespaceObject.getMeta)(api.getAppContext().metaName);
+                const possibleNames = [
+                    `${meta}.routes.ts`,
+                    `${meta}.routes.mts`,
+                    `${meta}.routes.tsx`,
+                    `${meta}.routes.js`,
+                    `${meta}.routes.mjs`,
+                    `${meta}.routes.jsx`
+                ];
+                await Promise.all(entrypoints.map(async (entrypoint)=>{
+                    const { absoluteEntryDir } = entrypoint;
+                    if (!absoluteEntryDir) return;
+                    for (const filename of possibleNames){
+                        const filePath = external_path_namespaceObject.resolve(absoluteEntryDir, filename);
+                        if (await utils_namespaceObject.fs.pathExists(filePath)) {
+                            const stats = await utils_namespaceObject.fs.stat(filePath);
+                            if (stats.isFile()) routesConfigFiles.push(filePath);
+                        }
+                    }
+                }));
+                const { partialsByEntrypoint, htmlTemplates } = await getHtmlTemplate(entrypoints, hooks, {
+                    appContext,
+                    config: resolvedConfig
+                });
+                debug("html templates: %o", htmlTemplates);
+                api.updateAppContext({
+                    partialsByEntrypoint
+                });
+                let checkedEntries = entrypoints.map((point)=>point.entryName);
+                if ((0, utils_namespaceObject.isDevCommand)()) {
+                    const { entry } = (0, utils_namespaceObject.minimist)((0, utils_namespaceObject.getArgv)());
+                    checkedEntries = await (0, getSelectedEntries_js_namespaceObject.getSelectedEntries)('string' == typeof entry ? entry.split(',') : entry, entrypoints);
+                }
+                appContext = {
+                    ...api.getAppContext(),
+                    entrypoints,
+                    checkedEntries,
+                    apiOnly,
+                    serverRoutes: routes,
+                    htmlTemplates
+                };
+                api.updateAppContext(appContext);
+                if ((0, external_utils_js_namespaceObject.checkIsBuildCommands)()) {
+                    await hooks.generateEntryCode.call({
+                        entrypoints
+                    });
+                    const normalizedConfig = api.getNormalizedConfig();
+                    const createBuilderForModern = await (0, index_js_namespaceObject.createBuilderGenerator)();
+                    const builder = await createBuilderForModern({
+                        normalizedConfig: normalizedConfig,
+                        appContext: appContext
+                    });
+                    builder.onBeforeBuild(async ({ bundlerConfigs, isFirstCompile, environments, isWatch })=>{
+                        if (!isFirstCompile) return;
+                        await (0, routes_js_namespaceObject.generateRoutes)(appContext);
+                        await hooks.onBeforeBuild.call({
+                            isFirstCompile,
+                            isWatch,
+                            environments,
+                            bundlerConfigs
+                        });
+                    });
+                    builder.onAfterBuild(async ({ stats, environments, isFirstCompile, isWatch })=>{
+                        await hooks.onAfterBuild.call({
+                            stats,
+                            environments,
+                            isFirstCompile,
+                            isWatch
+                        });
+                        await (0, config_js_namespaceObject.emitResolvedConfig)(appContext.appDirectory, normalizedConfig);
+                    });
+                    builder.onDevCompileDone(async ({ isFirstCompile, stats, environments })=>{
+                        hooks.onDevCompileDone.call({
+                            isFirstCompile,
+                            stats,
+                            environments
+                        });
+                        if (isFirstCompile) (0, printInstructions_js_namespaceObject.printInstructions)(hooks, appContext, normalizedConfig);
+                    });
+                    builder.onBeforeCreateCompiler(async ({ bundlerConfigs, environments })=>{
+                        await hooks.onBeforeCreateCompiler.call({
+                            environments,
+                            bundlerConfigs
+                        });
+                    });
+                    builder.onAfterCreateCompiler(async ({ compiler, environments })=>{
+                        await hooks.onAfterCreateCompiler.call({
+                            environments,
+                            compiler
+                        });
+                    });
+                    builder.onAfterStartDevServer(async ({ port })=>{
+                        await hooks.onAfterDev.call({
+                            port
+                        });
+                    });
+                    builder.addPlugins(resolvedConfig.builderPlugins);
+                    api.updateAppContext({
+                        builder
+                    });
+                }
+            });
+            api.addWatchFiles(()=>({
+                    files: [
+                        ...pagesDir,
+                        ...routesConfigFiles
+                    ],
+                    isPrivate: true
+                }));
+            api.modifyResolvedConfig((resolved)=>{
+                const appContext = api.getAppContext();
+                const config = (0, external_config_index_js_namespaceObject.initialNormalizedConfig)(resolved, appContext);
+                return config;
+            });
+        }
     });
-  }
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

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

@@ -1,81 +1,86 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var isDefaultExportFunction_exports = {};
-__export(isDefaultExportFunction_exports, {
-  isDefaultExportFunction: () => isDefaultExportFunction
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    isDefaultExportFunction: ()=>isDefaultExportFunction
 });
-module.exports = __toCommonJS(isDefaultExportFunction_exports);
-var import_fs = __toESM(require("fs"));
-var import_parser = require("@babel/parser");
-var import_traverse = __toESM(require("@babel/traverse"));
-var t = __toESM(require("@babel/types"));
-const isFunction = (node) => t.isFunctionDeclaration(node) || t.isFunctionExpression(node) || t.isArrowFunctionExpression(node);
-const isDefaultExportFunction = (file) => {
-  if (!file || !import_fs.default.existsSync(file)) {
-    return false;
-  }
-  const ast = (0, import_parser.parse)(import_fs.default.readFileSync(file, "utf8"), {
-    sourceType: "unambiguous",
-    plugins: [
-      "jsx",
-      "typescript",
-      "classProperties",
-      "dynamicImport",
-      "exportDefaultFrom",
-      "exportNamespaceFrom",
-      "decorators-legacy",
-      "functionBind",
-      "classPrivateMethods",
-      [
-        "pipelineOperator",
-        {
-          proposal: "minimal"
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+const parser_namespaceObject = require("@babel/parser");
+const traverse_namespaceObject = require("@babel/traverse");
+var traverse_default = /*#__PURE__*/ __webpack_require__.n(traverse_namespaceObject);
+const types_namespaceObject = require("@babel/types");
+const isFunction = (node)=>types_namespaceObject.isFunctionDeclaration(node) || types_namespaceObject.isFunctionExpression(node) || types_namespaceObject.isArrowFunctionExpression(node);
+const isDefaultExportFunction = (file)=>{
+    if (!file || !external_fs_default().existsSync(file)) return false;
+    const ast = (0, parser_namespaceObject.parse)(external_fs_default().readFileSync(file, 'utf8'), {
+        sourceType: 'unambiguous',
+        plugins: [
+            'jsx',
+            "typescript",
+            'classProperties',
+            'dynamicImport',
+            'exportDefaultFrom',
+            'exportNamespaceFrom',
+            'decorators-legacy',
+            'functionBind',
+            'classPrivateMethods',
+            [
+                'pipelineOperator',
+                {
+                    proposal: 'minimal'
+                }
+            ],
+            'optionalChaining',
+            'optionalCatchBinding',
+            'objectRestSpread',
+            'numericSeparator'
+        ]
+    });
+    let isExportFunction = false;
+    traverse_default()(ast, {
+        ExportDefaultDeclaration: (path)=>{
+            const { declaration } = path.node;
+            if (isFunction(declaration)) isExportFunction = true;
         }
-      ],
-      "optionalChaining",
-      "optionalCatchBinding",
-      "objectRestSpread",
-      "numericSeparator"
-    ]
-  });
-  let isExportFunction = false;
-  (0, import_traverse.default)(ast, {
-    ExportDefaultDeclaration: (path) => {
-      const { declaration } = path.node;
-      if (isFunction(declaration)) {
-        isExportFunction = true;
-      }
-    }
-  });
-  return isExportFunction;
+    });
+    return isExportFunction;
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  isDefaultExportFunction
+exports.isDefaultExportFunction = __webpack_exports__.isDefaultExportFunction;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isDefaultExportFunction"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });