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

package/dist/esm-node/plugins/analyze/getHtmlTemplate.js

@@ -21,7 +21,36 @@ const findPartials = (dir, entryName, position) => {
   }
   return null;
 };
-const getHtmlTemplate = async (entrypoints, api, { appContext, config }) => {
+const getModifyHtmlPartials = (partials) => {
+  const append = (type, ...script) => {
+    script.forEach((item) => {
+      partials[type].push(item);
+    });
+  };
+  const prepend = (type, ...script) => {
+    script.forEach((item) => {
+      partials[type].unshift(item);
+    });
+  };
+  return {
+    top: {
+      append: (...script) => append("top", ...script),
+      prepend: (...script) => prepend("top", ...script),
+      current: partials.top
+    },
+    head: {
+      append: (...script) => append("head", ...script),
+      prepend: (...script) => prepend("head", ...script),
+      current: partials.head
+    },
+    body: {
+      append: (...script) => append("body", ...script),
+      prepend: (...script) => prepend("body", ...script),
+      current: partials.body
+    }
+  };
+};
+const getHtmlTemplate = async (entrypoints, hooks, { appContext, config }) => {
   const { appDirectory, internalDirectory } = appContext;
   const { source: { configDir } } = config;
   const htmlDir = path.resolve(appDirectory, configDir || "", HTML_PARTIALS_FOLDER);
@@ -34,24 +63,20 @@ const getHtmlTemplate = async (entrypoints, api, { appContext, config }) => {
     if (customIndexTemplate) {
       htmlTemplates[entryName] = customIndexTemplate.file;
     } else {
-      const hookRunners = api.useHookRunners();
-      const { partials } = await hookRunners.htmlPartials({
+      const getPartialInitValue = (position) => {
+        const partial = findPartials(htmlDir, name, position);
+        return partial ? [
+          partial.content
+        ] : [];
+      };
+      const partials = {
+        top: getPartialInitValue("top"),
+        head: getPartialInitValue("head"),
+        body: getPartialInitValue("body")
+      };
+      await hooks.modifyHtmlPartials.call({
         entrypoint,
-        partials: [
-          "top",
-          "head",
-          "body"
-        ].reduce((previous, position) => {
-          const found = findPartials(htmlDir, name, position);
-          previous[position] = found ? [
-            found.content
-          ] : [];
-          return previous;
-        }, {
-          top: [],
-          head: [],
-          body: []
-        })
+        partials: getModifyHtmlPartials(partials)
       });
       const templatePath = path.resolve(internalDirectory, entryName, "index.html");
       fs.outputFileSync(templatePath, templates.html(partials), "utf8");
@@ -63,12 +88,12 @@ const getHtmlTemplate = async (entrypoints, api, { appContext, config }) => {
       }
     }
   }
-  api.setAppContext({
-    ...api.useAppContext(),
-    partialsByEntrypoint
-  });
-  return htmlTemplates;
+  return {
+    partialsByEntrypoint,
+    htmlTemplates
+  };
 };
 export {
-  getHtmlTemplate
+  getHtmlTemplate,
+  getModifyHtmlPartials
 };

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

@@ -16,147 +16,145 @@ var analyze_default = ({ bundler }) => ({
   setup: (api) => {
     let pagesDir = [];
     let nestedRouteEntries = [];
-    return {
-      async prepare() {
-        var _resolvedConfig_source;
-        let appContext = api.useAppContext();
-        const resolvedConfig = api.useResolvedConfigContext();
-        const hookRunners = api.useHookRunners();
-        try {
-          if (checkIsBuildCommands()) {
-            fs.emptydirSync(appContext.internalDirectory);
-          }
-        } catch {
-        }
-        const apiOnly = await isApiOnly(appContext.appDirectory, (_resolvedConfig_source = resolvedConfig.source) === null || _resolvedConfig_source === void 0 ? void 0 : _resolvedConfig_source.entriesDir, appContext.apiDirectory);
-        await hookRunners.addRuntimeExports();
-        if (apiOnly) {
-          const { routes: routes2 } = await hookRunners.modifyServerRoutes({
-            routes: []
-          });
-          debug(`server routes: %o`, routes2);
-          appContext = {
-            ...api.useAppContext(),
-            apiOnly,
-            serverRoutes: routes2
-          };
-          api.setAppContext(appContext);
-          return;
+    api.onPrepare(async () => {
+      var _resolvedConfig_source;
+      let appContext = api.getAppContext();
+      const resolvedConfig = api.getNormalizedConfig();
+      const hooks = api.getHooks();
+      try {
+        if (checkIsBuildCommands()) {
+          fs.emptydirSync(appContext.internalDirectory);
         }
-        const [{ getBundleEntry }, { getServerRoutes }, { getHtmlTemplate }] = await Promise.all([
-          import("./getBundleEntry.js"),
-          import("./getServerRoutes.js"),
-          import("./getHtmlTemplate.js")
-        ]);
-        const { entrypoints } = await hookRunners.modifyEntrypoints({
-          entrypoints: await getBundleEntry(hookRunners, appContext, resolvedConfig)
+      } catch {
+      }
+      const apiOnly = await isApiOnly(appContext.appDirectory, (_resolvedConfig_source = resolvedConfig.source) === null || _resolvedConfig_source === void 0 ? void 0 : _resolvedConfig_source.entriesDir, appContext.apiDirectory);
+      await hooks.addRuntimeExports.call();
+      if (apiOnly) {
+        const { routes: routes2 } = await hooks.modifyServerRoutes.call({
+          routes: []
         });
-        debug(`entrypoints: %o`, entrypoints);
-        const initialRoutes = getServerRoutes(entrypoints, {
-          appContext,
-          config: resolvedConfig
+        debug(`server routes: %o`, routes2);
+        api.updateAppContext({
+          apiOnly,
+          serverRoutes: routes2
         });
-        const { routes } = await hookRunners.modifyServerRoutes({
-          routes: initialRoutes
+        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 initialRoutes = getServerRoutes(entrypoints, {
+        appContext,
+        config: resolvedConfig
+      });
+      const { routes } = await hooks.modifyServerRoutes.call({
+        routes: initialRoutes
+      });
+      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 (isDevCommand()) {
+        const { entry } = minimist(getArgv());
+        checkedEntries = await getSelectedEntries(typeof entry === "string" ? entry.split(",") : entry, entrypoints);
+      }
+      appContext = {
+        ...api.getAppContext(),
+        entrypoints,
+        checkedEntries,
+        apiOnly,
+        serverRoutes: routes,
+        htmlTemplates
+      };
+      api.updateAppContext(appContext);
+      if (checkIsBuildCommands()) {
+        await hooks.generateEntryCode.call({
+          entrypoints
         });
-        debug(`server routes: %o`, routes);
-        appContext = {
-          ...api.useAppContext(),
-          entrypoints,
-          serverRoutes: routes
-        };
-        api.setAppContext(appContext);
-        nestedRouteEntries = entrypoints.map((point) => point.nestedRoutesEntry).filter(Boolean);
-        pagesDir = entrypoints.map((point) => point.entry).filter((entry) => entry && !path.extname(entry)).concat(nestedRouteEntries);
-        const htmlTemplates = await getHtmlTemplate(entrypoints, api, {
-          appContext,
-          config: resolvedConfig
+        const normalizedConfig = api.getNormalizedConfig();
+        const createBuilderForModern = await createBuilderGenerator(bundler);
+        const builder = await createBuilderForModern({
+          normalizedConfig,
+          appContext
         });
-        debug(`html templates: %o`, htmlTemplates);
-        let checkedEntries = entrypoints.map((point) => point.entryName);
-        if (isDevCommand()) {
-          const { entry } = minimist(getArgv());
-          checkedEntries = await getSelectedEntries(typeof entry === "string" ? entry.split(",") : entry, entrypoints);
-        }
-        appContext = {
-          ...api.useAppContext(),
-          entrypoints,
-          checkedEntries,
-          apiOnly,
-          serverRoutes: routes,
-          htmlTemplates
-        };
-        api.setAppContext(appContext);
-        if (checkIsBuildCommands()) {
-          await hookRunners.generateEntryCode({
-            entrypoints
-          });
-          const normalizedConfig = api.useResolvedConfigContext();
-          const createBuilderForModern = await createBuilderGenerator(bundler);
-          const builder = await createBuilderForModern({
-            normalizedConfig,
-            appContext
-          });
-          builder.onBeforeBuild(async ({ bundlerConfigs, isFirstCompile }) => {
-            if (!isFirstCompile) {
-              return;
-            }
-            const hookRunners2 = api.useHookRunners();
-            await generateRoutes(appContext);
-            await hookRunners2.beforeBuild({
-              bundlerConfigs
-            });
+        builder.onBeforeBuild(async ({ bundlerConfigs, isFirstCompile, environments, isWatch }) => {
+          if (!isFirstCompile) {
+            return;
+          }
+          await generateRoutes(appContext);
+          await hooks.onBeforeBuild.call({
+            isFirstCompile,
+            isWatch,
+            environments,
+            bundlerConfigs
           });
-          builder.onAfterBuild(async ({ stats }) => {
-            const hookRunners2 = api.useHookRunners();
-            await hookRunners2.afterBuild({
-              stats
-            });
-            await emitResolvedConfig(appContext.appDirectory, normalizedConfig);
+        });
+        builder.onAfterBuild(async ({ stats, environments, isFirstCompile, isWatch }) => {
+          await hooks.onAfterBuild.call({
+            stats,
+            environments,
+            isFirstCompile,
+            isWatch
           });
-          builder.onDevCompileDone(async ({ isFirstCompile }) => {
-            const hookRunners2 = api.useHookRunners();
-            hookRunners2.afterDev({
-              isFirstCompile
-            });
-            if (isFirstCompile) {
-              printInstructions(hookRunners2, appContext, normalizedConfig);
-            }
+          await emitResolvedConfig(appContext.appDirectory, normalizedConfig);
+        });
+        builder.onDevCompileDone(async ({ isFirstCompile }) => {
+          hooks.onAfterDev.call({
+            isFirstCompile
           });
-          builder.onBeforeCreateCompiler(async ({ bundlerConfigs }) => {
-            const hookRunners2 = api.useHookRunners();
-            await hookRunners2.beforeCreateCompiler({
-              bundlerConfigs
-            });
+          if (isFirstCompile) {
+            printInstructions(hooks, appContext, normalizedConfig);
+          }
+        });
+        builder.onBeforeCreateCompiler(async ({ bundlerConfigs, environments }) => {
+          await hooks.onBeforeCreateCompiler.call({
+            environments,
+            bundlerConfigs
           });
-          builder.onAfterCreateCompiler(async ({ compiler }) => {
-            const hookRunners2 = api.useHookRunners();
-            await hookRunners2.afterCreateCompiler({
-              compiler
-            });
+        });
+        builder.onAfterCreateCompiler(async ({ compiler, environments }) => {
+          await hooks.onAfterCreateCompiler.call({
+            environments,
+            compiler
           });
-          builder.addPlugins(resolvedConfig.builderPlugins);
-          appContext = {
-            ...api.useAppContext(),
-            builder
-          };
-          api.setAppContext(appContext);
-        }
-      },
-      watchFiles() {
-        return {
-          files: pagesDir,
-          isPrivate: true
-        };
-      },
-      resolvedConfig({ resolved }) {
-        const appContext = api.useAppContext();
-        const config = initialNormalizedConfig(resolved, appContext, bundler);
-        return {
-          resolved: config
-        };
+        });
+        builder.addPlugins(resolvedConfig.builderPlugins);
+        api.updateAppContext({
+          builder
+        });
       }
-    };
+    });
+    api.addWatchFiles(() => {
+      return {
+        files: pagesDir,
+        isPrivate: true
+      };
+    });
+    api.modifyResolvedConfig((resolved) => {
+      const appContext = api.getAppContext();
+      const config = initialNormalizedConfig(resolved, appContext, bundler);
+      return config;
+    });
   }
 });
 export {

package/dist/esm-node/plugins/deploy/index.js

@@ -22,21 +22,19 @@ var deploy_default = () => ({
   name: "@modern-js/plugin-deploy",
   setup: (api) => {
     const deployTarget = process.env.MODERNJS_DEPLOY || provider || "node";
-    return {
-      async deploy() {
-        const appContext = api.useAppContext();
-        const { metaName } = appContext;
-        if (metaName !== "modern-js" && !process.env.MODERNJS_DEPLOY) {
-          return;
-        }
-        const modernConfig = api.useResolvedConfigContext();
-        const deployPreset = await getDeployPreset(appContext, modernConfig, deployTarget);
-        (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.prepare) && await (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.prepare());
-        (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.writeOutput) && await (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.writeOutput());
-        (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.genEntry) && await (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.genEntry());
-        (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.end) && await (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.end());
+    api.deploy(async () => {
+      const appContext = api.getAppContext();
+      const { metaName } = appContext;
+      if (metaName !== "modern-js" && !process.env.MODERNJS_DEPLOY) {
+        return;
       }
-    };
+      const modernConfig = api.getNormalizedConfig();
+      const deployPreset = await getDeployPreset(appContext, modernConfig, deployTarget);
+      (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.prepare) && await (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.prepare());
+      (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.writeOutput) && await (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.writeOutput());
+      (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.genEntry) && await (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.genEntry());
+      (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.end) && await (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.end());
+    });
   }
 });
 export {

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

@@ -11,60 +11,54 @@ var initialize_default = ({ bundler }) => ({
     "@modern-js/plugin-polyfill"
   ],
   setup(api) {
-    const config = () => {
-      const appContext = api.useAppContext();
-      const userConfig = api.useConfigContext();
-      api.setAppContext({
-        ...appContext,
+    api.config(() => {
+      const appContext = api.getAppContext();
+      const userConfig = api.getConfig();
+      api.updateAppContext({
         bundlerType: bundler
       });
       return checkIsLegacyConfig(userConfig) ? createLegacyDefaultConfig(appContext) : createDefaultConfig(appContext);
-    };
-    return {
-      config,
-      async resolvedConfig({ resolved }) {
-        var _resolved_output_distPath;
-        let appContext = api.useAppContext();
-        const userConfig = api.useConfigContext();
-        const port = await getServerPort(resolved);
-        appContext = {
-          ...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);
-        const normalizedConfig = checkIsLegacyConfig(resolved) ? transformNormalizedConfig(resolved) : resolved;
-        resolved._raw = userConfig;
-        resolved.server = {
-          ...normalizedConfig.server || {},
-          port
-        };
-        var _normalizedConfig_autoLoadPlugins;
-        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 {
-          resolved
-        };
+    });
+    api.modifyResolvedConfig(async (resolved) => {
+      var _resolved_output_distPath;
+      let appContext = api.getAppContext();
+      const userConfig = api.getConfig();
+      const port = await getServerPort(resolved);
+      appContext = {
+        ...appContext,
+        port,
+        distDirectory: ensureAbsolutePath(appContext.appDirectory, ((_resolved_output_distPath = resolved.output.distPath) === null || _resolved_output_distPath === void 0 ? void 0 : _resolved_output_distPath.root) || "dist")
+      };
+      api.updateAppContext(appContext);
+      const normalizedConfig = checkIsLegacyConfig(resolved) ? transformNormalizedConfig(resolved) : resolved;
+      resolved._raw = userConfig;
+      resolved.server = {
+        ...normalizedConfig.server || {},
+        port
+      };
+      var _normalizedConfig_autoLoadPlugins;
+      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 resolved;
+    });
   }
 });
 function stabilizeConfig(resolve, config, keys) {

package/dist/esm-node/plugins/serverBuild.js

@@ -17,40 +17,38 @@ function checkHasConfig(appDir, metaName = "modern-js") {
 var serverBuild_default = () => ({
   name: "@modern-js/server-build",
   setup(api) {
-    return {
-      async afterBuild() {
-        const { appDirectory, distDirectory, metaName } = api.useAppContext();
-        if (!checkHasCache(appDirectory) && !checkHasConfig(appDirectory, metaName)) {
-          return;
-        }
-        const modernConfig = api.useResolvedConfigContext();
-        const distDir = path.resolve(distDirectory);
-        const serverDir = path.resolve(appDirectory, SERVER_DIR);
-        const sharedDir = path.resolve(appDirectory, SHARED_DIR);
-        const tsconfigPath = path.resolve(appDirectory, TS_CONFIG_FILENAME);
-        const sourceDirs = [];
-        if (fs.existsSync(serverDir)) {
-          sourceDirs.push(serverDir);
-          if (fs.existsSync(sharedDir)) {
-            sourceDirs.push(sharedDir);
-          }
-        }
-        const { server } = modernConfig;
-        const { alias } = modernConfig.source;
-        const { babel } = modernConfig.tools;
-        if (sourceDirs.length > 0) {
-          await compile(appDirectory, {
-            server,
-            alias,
-            babelConfig: babel
-          }, {
-            sourceDirs,
-            distDir,
-            tsconfigPath
-          });
+    api.onAfterBuild(async () => {
+      const { appDirectory, distDirectory, metaName } = api.getAppContext();
+      if (!checkHasCache(appDirectory) && !checkHasConfig(appDirectory, metaName)) {
+        return;
+      }
+      const modernConfig = api.getNormalizedConfig();
+      const distDir = path.resolve(distDirectory);
+      const serverDir = path.resolve(appDirectory, SERVER_DIR);
+      const sharedDir = path.resolve(appDirectory, SHARED_DIR);
+      const tsconfigPath = path.resolve(appDirectory, TS_CONFIG_FILENAME);
+      const sourceDirs = [];
+      if (fs.existsSync(serverDir)) {
+        sourceDirs.push(serverDir);
+        if (fs.existsSync(sharedDir)) {
+          sourceDirs.push(sharedDir);
         }
       }
-    };
+      const { server } = modernConfig;
+      const { alias } = modernConfig.source;
+      const { babel } = modernConfig.tools;
+      if (sourceDirs.length > 0) {
+        await compile(appDirectory, {
+          server,
+          alias,
+          babelConfig: babel
+        }, {
+          sourceDirs,
+          distDir,
+          tsconfigPath
+        });
+      }
+    });
   }
 });
 export {

package/dist/esm-node/{new/run.js → run/index.js}

@@ -1,11 +1,11 @@
 import { initAppDir } from "@modern-js/plugin-v2/cli";
 import { run as CLIPluginRun } from "@modern-js/plugin-v2/run";
 import { minimist } from "@modern-js/utils";
-import { handleSetupResult } from "./compat/hooks";
-import { PACKAGE_JSON_CONFIG_NAME } from "./constants";
-import { getConfigFile } from "./getConfigFile";
-import { loadInternalPlugins } from "./loadPlugins";
-import { getIsAutoLoadPlugins } from "./utils";
+import { handleSetupResult } from "../compat/hooks";
+import { PACKAGE_JSON_CONFIG_NAME } from "../constants";
+import { getConfigFile } from "../utils/getConfigFile";
+import { isAutoLoadPlugins } from "../utils/isAutoLoadPlugins";
+import { loadInternalPlugins } from "../utils/loadPlugins";
 async function run({ cwd, initialLog, version, internalPlugins, packageJsonConfig, configFile }) {
   const command = process.argv[2];
   const cliParams = minimist(process.argv.slice(2));
@@ -27,7 +27,7 @@ async function run({ cwd, initialLog, version, internalPlugins, packageJsonConfi
   }
   const appDirectory = await initAppDir(cwd);
   const finalConfigFile = customConfigFile || getConfigFile(configFile);
-  const autoLoadPlugins = await getIsAutoLoadPlugins(appDirectory, finalConfigFile);
+  const autoLoadPlugins = await isAutoLoadPlugins(appDirectory, finalConfigFile);
   const plugins = await loadInternalPlugins(appDirectory, internalPlugins === null || internalPlugins === void 0 ? void 0 : internalPlugins.cli, internalPlugins === null || internalPlugins === void 0 ? void 0 : internalPlugins.autoLoad, autoLoadPlugins);
   await CLIPluginRun({
     cwd,

package/dist/esm-node/{new → utils}/getConfigFile.js

@@ -1,6 +1,6 @@
 import path from "path";
 import { CONFIG_FILE_EXTENSIONS, findExists } from "@modern-js/utils";
-import { DEFAULT_CONFIG_FILE } from "./constants";
+import { DEFAULT_CONFIG_FILE } from "../constants";
 const getConfigFile = (configFile) => findExists(CONFIG_FILE_EXTENSIONS.map((extension) => path.resolve(process.cwd(), `${configFile || DEFAULT_CONFIG_FILE}${extension}`)));
 export {
   getConfigFile

package/dist/esm-node/{new/context.js → utils/initAppContext.js}

@@ -1,18 +1,18 @@
 import path from "path";
-import { address } from "@modern-js/utils";
+import { fs, address } from "@modern-js/utils";
 const initAppContext = ({ appDirectory, runtimeConfigFile, options, serverConfigFile, tempDir }) => {
   const { metaName = "modern-js", apiDir = "api", distDir = "", sharedDir = "shared" } = options || {};
+  const pkgPath = path.resolve(appDirectory, "./package.json");
   return {
     metaName,
     runtimeConfigFile,
     serverConfigFile,
     ip: address.ip(),
     port: 0,
-    moduleType: require(path.resolve(appDirectory, "./package.json")).type || "commonjs",
+    moduleType: fs.existsSync(pkgPath) ? require(pkgPath).type || "commonjs" : "commonjs",
     apiDirectory: path.resolve(appDirectory, apiDir),
     lambdaDirectory: path.resolve(appDirectory, apiDir, "lambda"),
     sharedDirectory: path.resolve(appDirectory, sharedDir),
-    distDirectory: distDir,
     serverPlugins: [],
     internalDirectory: path.resolve(appDirectory, tempDir || `./node_modules/.${metaName}`),
     htmlTemplates: {},

package/dist/esm-node/{new/utils/index.js → utils/isAutoLoadPlugins.js}

@@ -1,10 +1,10 @@
 import { createLoadedConfig } from "@modern-js/plugin-v2/cli";
-async function getIsAutoLoadPlugins(appDirectory, configFile = "modern.config.ts", packageJsonConfig = "ModernConfig") {
+async function isAutoLoadPlugins(appDirectory, configFile = "modern.config.ts", packageJsonConfig = "ModernConfig") {
   var _loaded_config;
   const loaded = await createLoadedConfig(appDirectory, configFile, packageJsonConfig);
   const autoLoadPlugins = (_loaded_config = loaded.config) === null || _loaded_config === void 0 ? void 0 : _loaded_config.autoLoadPlugins;
   return autoLoadPlugins || false;
 }
 export {
-  getIsAutoLoadPlugins
+  isAutoLoadPlugins
 };