@modern-js/app-tools 2.63.0 → 2.63.1

package/dist/cjs/commands/dev.js

@@ -113,7 +113,7 @@ const dev = async (api, options, devServerOptions) => {
       port,
       host
     }, () => {
-      (0, import_printInstructions.printInstructions)(hookRunners, appContext, normalizedConfig);
+      (0, import_printInstructions.printInstructionsCompat)(hookRunners, appContext, normalizedConfig);
     });
   } else {
     const { server, afterListen } = await (0, import_server.createDevServer)({

package/dist/cjs/commands/serve.js

@@ -77,7 +77,7 @@ const start = async (api) => {
     runMode
   });
   app.listen(port, async () => {
-    await (0, import_printInstructions.printInstructions)(hookRunners, appContext, userConfig);
+    await (0, import_printInstructions.printInstructionsCompat)(hookRunners, appContext, userConfig);
   });
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/new/compat/hooks.js

@@ -22,6 +22,7 @@ __export(hooks_exports, {
   handleSetupResult: () => handleSetupResult
 });
 module.exports = __toCommonJS(hooks_exports);
+var import_getHtmlTemplate = require("../../plugins/analyze/getHtmlTemplate");
 var import_utils = require("./utils");
 function getHookRunners(context) {
   const { hooks } = context;
@@ -80,7 +81,13 @@ function getHookRunners(context) {
       return hooks.modifyResolvedConfig.call(params);
     },
     htmlPartials: async (params) => {
-      return hooks.modifyHtmlPartials.call(params);
+      await hooks.modifyHtmlPartials.call({
+        entrypoint: params.entrypoint,
+        partials: (0, import_getHtmlTemplate.getModifyHtmlPartials)(params.partials)
+      });
+      return {
+        partials: params.partials
+      };
     },
     commands: async (params) => {
       return hooks.addCommand.call(params);
@@ -91,7 +98,7 @@ function getHookRunners(context) {
     prepare: async () => {
       return hooks.onPrepare.call();
     },
-    filedChange: async (params) => {
+    fileChange: async (params) => {
       return hooks.onFileChanged.call(params);
     },
     beforeCreateCompiler: async (params) => {
@@ -139,8 +146,8 @@ function getHookRunners(context) {
     /**
     * @deprecated
     */
-    addRuntimeExports: async (params) => {
-      return hooks.addRuntimeExports.call(params);
+    addRuntimeExports: async () => {
+      return hooks.addRuntimeExports.call();
     }
   };
 }

package/dist/cjs/new/compat/utils.js

@@ -41,7 +41,7 @@ function transformHookRunner(hookRunnerName) {
       return "addCommand";
     case "watchFiles":
       return "addWatchFiles";
-    case "filedChange":
+    case "fileChange":
       return "onFileChanged";
     case "beforeCreateCompiler":
       return "onBeforeCreateCompiler";
@@ -75,6 +75,15 @@ function transformHookParams(hookRunnerName, params) {
       return {
         resolved: params
       };
+    case "htmlPartials":
+      return {
+        partials: {
+          top: params.partials.top.current,
+          head: params.partials.head.current,
+          body: params.partials.body.current
+        },
+        entrypoint: params.entrypoint
+      };
     default:
       return params;
   }

package/dist/cjs/new/context.js

@@ -46,7 +46,6 @@ const initAppContext = ({ appDirectory, runtimeConfigFile, options, serverConfig
     apiDirectory: import_path.default.resolve(appDirectory, apiDir),
     lambdaDirectory: import_path.default.resolve(appDirectory, apiDir, "lambda"),
     sharedDirectory: import_path.default.resolve(appDirectory, sharedDir),
-    distDirectory: distDir,
     serverPlugins: [],
     internalDirectory: import_path.default.resolve(appDirectory, tempDir || `./node_modules/.${metaName}`),
     htmlTemplates: {},

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

@@ -55,10 +55,10 @@ const ifAlreadyExists = (entrypoints, checked) => entrypoints.some((entrypoint)
   }
   return false;
 });
-const getBundleEntry = async (hookRunners, appContext, config) => {
+const getBundleEntry = async (hooks, appContext, config) => {
   const { appDirectory, packageName } = appContext;
   const { disableDefaultEntries, entries, entriesDir, mainEntryName } = config.source;
-  const defaults = disableDefaultEntries ? [] : await (0, import_getFileSystemEntry.getFileSystemEntry)(hookRunners, appContext, config);
+  const defaults = disableDefaultEntries ? [] : await (0, import_getFileSystemEntry.getFileSystemEntry)(hooks, appContext, config);
   if (entries) {
     Object.keys(entries).forEach((name) => {
       const value = entries[name];

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

@@ -39,8 +39,8 @@ var import_isDefaultExportFunction = require("./isDefaultExportFunction");
 const hasIndex = (dir) => (0, import_utils.findExists)(import_utils.JS_EXTENSIONS.map((ext) => import_path.default.resolve(dir, `${import_constants.INDEX_FILE_NAME}${ext}`)));
 const hasEntry = (dir) => (0, import_utils.findExists)(import_utils.JS_EXTENSIONS.map((ext) => import_path.default.resolve(dir, `${import_constants.ENTRY_FILE_NAME}${ext}`)));
 const hasServerEntry = (dir) => (0, import_utils.findExists)(import_utils.JS_EXTENSIONS.map((ext) => import_path.default.resolve(dir, `${import_constants.ENTRY_FILE_NAME}.server${ext}`)));
-const isBundleEntry = async (hookRunners, dir, enableCustomEntry) => {
-  const { entry } = await hookRunners.checkEntryPoint({
+const isBundleEntry = async (hooks, dir, enableCustomEntry) => {
+  const { entry } = await hooks.checkEntryPoint.call({
     path: dir,
     entry: false
   });
@@ -53,7 +53,7 @@ const isBundleEntry = async (hookRunners, dir, enableCustomEntry) => {
   }
   return hasIndex(dir);
 };
-const scanDir = async (hookRunners, dirs, enableCustomEntry) => {
+const scanDir = async (hooks, dirs, enableCustomEntry) => {
   const entries = await Promise.all(dirs.map(async (dir) => {
     const indexFile = hasIndex(dir);
     const customBootstrap = (0, import_isDefaultExportFunction.isDefaultExportFunction)(indexFile) ? indexFile : false;
@@ -70,7 +70,7 @@ const scanDir = async (hookRunners, dirs, enableCustomEntry) => {
         customBootstrap
       };
     }
-    const entryFile = (await hookRunners.checkEntryPoint({
+    const entryFile = (await hooks.checkEntryPoint.call({
       path: dir,
       entry: false
     })).entry;
@@ -104,7 +104,7 @@ const scanDir = async (hookRunners, dirs, enableCustomEntry) => {
   }
   return entries;
 };
-const getFileSystemEntry = async (hookRunners, appContext, config) => {
+const getFileSystemEntry = async (hooks, appContext, config) => {
   const { appDirectory } = appContext;
   const { source: { entriesDir, disableEntryDirs, enableCustomEntry } } = config;
   let disabledDirs = [];
@@ -114,19 +114,19 @@ const getFileSystemEntry = async (hookRunners, appContext, config) => {
   const src = (0, import_utils.ensureAbsolutePath)(appDirectory, entriesDir || "");
   if (import_fs.default.existsSync(src)) {
     if (import_fs.default.statSync(src).isDirectory()) {
-      if (await isBundleEntry(hookRunners, src, enableCustomEntry)) {
-        return scanDir(hookRunners, [
+      if (await isBundleEntry(hooks, src, enableCustomEntry)) {
+        return scanDir(hooks, [
           src
         ], enableCustomEntry);
       }
       const dirs = [];
       await Promise.all(import_fs.default.readdirSync(src).map(async (filename) => {
         const file = import_path.default.join(src, filename);
-        if (import_fs.default.statSync(file).isDirectory() && await isBundleEntry(hookRunners, file, enableCustomEntry) && !disabledDirs.includes(file)) {
+        if (import_fs.default.statSync(file).isDirectory() && await isBundleEntry(hooks, file, enableCustomEntry) && !disabledDirs.includes(file)) {
           dirs.push(file);
         }
       }));
-      return scanDir(hookRunners, dirs, enableCustomEntry);
+      return scanDir(hooks, dirs, enableCustomEntry);
     } else {
       throw Error(`source.entriesDir accept a directory.`);
     }

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

@@ -28,7 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var getHtmlTemplate_exports = {};
 __export(getHtmlTemplate_exports, {
-  getHtmlTemplate: () => getHtmlTemplate
+  getHtmlTemplate: () => getHtmlTemplate,
+  getModifyHtmlPartials: () => getModifyHtmlPartials
 });
 module.exports = __toCommonJS(getHtmlTemplate_exports);
 var import_path = __toESM(require("path"));
@@ -54,7 +55,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 = import_path.default.resolve(appDirectory, configDir || "", import_constants.HTML_PARTIALS_FOLDER);
@@ -67,24 +97,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 = import_path.default.resolve(internalDirectory, entryName, "index.html");
       import_utils.fs.outputFileSync(templatePath, templates.html(partials), "utf8");
@@ -96,13 +122,13 @@ const getHtmlTemplate = async (entrypoints, api, { appContext, config }) => {
       }
     }
   }
-  api.setAppContext({
-    ...api.useAppContext(),
-    partialsByEntrypoint
-  });
-  return htmlTemplates;
+  return {
+    partialsByEntrypoint,
+    htmlTemplates
+  };
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getHtmlTemplate
+  getHtmlTemplate,
+  getModifyHtmlPartials
 });

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

@@ -49,146 +49,144 @@ 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 ((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 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 ((0, import_utils2.checkIsBuildCommands)()) {
+          import_utils.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 (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();
+      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 ((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
         });
-        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 (0, import_builder.createBuilderGenerator)(bundler);
+        const builder = await createBuilderForModern({
+          normalizedConfig,
+          appContext
         });
-        debug(`html templates: %o`, htmlTemplates);
-        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.useAppContext(),
-          entrypoints,
-          checkedEntries,
-          apiOnly,
-          serverRoutes: routes,
-          htmlTemplates
-        };
-        api.setAppContext(appContext);
-        if ((0, import_utils2.checkIsBuildCommands)()) {
-          await hookRunners.generateEntryCode({
-            entrypoints
-          });
-          const normalizedConfig = api.useResolvedConfigContext();
-          const createBuilderForModern = await (0, import_builder.createBuilderGenerator)(bundler);
-          const builder = await createBuilderForModern({
-            normalizedConfig,
-            appContext
-          });
-          builder.onBeforeBuild(async ({ bundlerConfigs, isFirstCompile }) => {
-            if (!isFirstCompile) {
-              return;
-            }
-            const hookRunners2 = api.useHookRunners();
-            await (0, import_routes.generateRoutes)(appContext);
-            await hookRunners2.beforeBuild({
-              bundlerConfigs
-            });
+        builder.onBeforeBuild(async ({ bundlerConfigs, isFirstCompile, environments, isWatch }) => {
+          if (!isFirstCompile) {
+            return;
+          }
+          await (0, import_routes.generateRoutes)(appContext);
+          await hooks.onBeforeBuild.call({
+            isFirstCompile,
+            isWatch,
+            environments,
+            bundlerConfigs
           });
-          builder.onAfterBuild(async ({ stats }) => {
-            const hookRunners2 = api.useHookRunners();
-            await hookRunners2.afterBuild({
-              stats
-            });
-            await (0, import_config2.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) {
-              (0, import_printInstructions.printInstructions)(hookRunners2, appContext, normalizedConfig);
-            }
+          await (0, import_config2.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) {
+            (0, import_printInstructions.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 = (0, import_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 = (0, import_config.initialNormalizedConfig)(resolved, appContext, bundler);
+      return config;
+    });
   }
 });

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

@@ -45,20 +45,18 @@ var deploy_default = () => ({
   name: "@modern-js/plugin-deploy",
   setup: (api) => {
     const deployTarget = process.env.MODERNJS_DEPLOY || import_std_env.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());
+    });
   }
 });

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

@@ -50,7 +50,7 @@ var initialize_default = ({ bundler }) => ({
       appContext = {
         ...appContext,
         port,
-        distDirectory: (0, import_utils.ensureAbsolutePath)(appContext.distDirectory, ((_resolved_output_distPath = resolved.output.distPath) === null || _resolved_output_distPath === void 0 ? void 0 : _resolved_output_distPath.root) || "dist")
+        distDirectory: (0, import_utils.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 = (0, import_config.checkIsLegacyConfig)(resolved) ? (0, import_config.transformNormalizedConfig)(resolved) : resolved;

package/dist/cjs/utils/printInstructions.js

@@ -18,11 +18,19 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var printInstructions_exports = {};
 __export(printInstructions_exports, {
-  printInstructions: () => printInstructions
+  printInstructions: () => printInstructions,
+  printInstructionsCompat: () => printInstructionsCompat
 });
 module.exports = __toCommonJS(printInstructions_exports);
 var import_utils = require("@modern-js/utils");
-const printInstructions = async (hookRunners, appContext, config) => {
+const printInstructions = async (hooks, appContext, config) => {
+  const message = (0, import_utils.prettyInstructions)(appContext, config);
+  const { instructions } = await hooks.onBeforePrintInstructions.call({
+    instructions: message
+  });
+  import_utils.logger.log(instructions);
+};
+const printInstructionsCompat = async (hookRunners, appContext, config) => {
   const message = (0, import_utils.prettyInstructions)(appContext, config);
   const { instructions } = await hookRunners.beforePrintInstructions({
     instructions: message
@@ -31,5 +39,6 @@ const printInstructions = async (hookRunners, appContext, config) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  printInstructions
+  printInstructions,
+  printInstructionsCompat
 });

package/dist/cjs/utils/restart.js

@@ -23,6 +23,7 @@ __export(restart_exports, {
 module.exports = __toCommonJS(restart_exports);
 var import_cli = require("@modern-js/plugin-v2/cli");
 var import_utils = require("@modern-js/utils");
+var import_commander = require("@modern-js/utils/commander");
 async function restart(hooksRunner, filename) {
   (0, import_utils.clearConsole)();
   import_utils.logger.info(`Restart because ${import_utils.chalk.yellow(filename)} is changed...
@@ -36,7 +37,7 @@ async function restart(hooksRunner, filename) {
     hasGetError = true;
   } finally {
     if (!hasGetError) {
-      import_utils.program.parse((0, import_utils.getFullArgv)());
+      import_commander.program.parse((0, import_utils.getFullArgv)());
     }
   }
 }