@modern-js/app-tools 2.62.1 → 2.63.0

package/dist/esm-node/new/run.js

@@ -0,0 +1,43 @@
+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";
+async function run({ cwd, initialLog, version, internalPlugins, packageJsonConfig, configFile }) {
+  const command = process.argv[2];
+  const cliParams = minimist(process.argv.slice(2));
+  const SUPPORT_CONFIG_PARAM_COMMANDS = [
+    "dev",
+    "build",
+    "deploy",
+    "start",
+    "serve",
+    "inspect",
+    "upgrade"
+  ];
+  let customConfigFile;
+  if (SUPPORT_CONFIG_PARAM_COMMANDS.includes(command)) {
+    customConfigFile = cliParams.config || cliParams.c;
+  }
+  if (command === "new") {
+    customConfigFile = cliParams["config-file"];
+  }
+  const appDirectory = await initAppDir(cwd);
+  const finalConfigFile = customConfigFile || getConfigFile(configFile);
+  const autoLoadPlugins = await getIsAutoLoadPlugins(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,
+    initialLog: initialLog || `Modern.js Framework v${version}`,
+    configFile: finalConfigFile,
+    packageJsonConfig: packageJsonConfig || PACKAGE_JSON_CONFIG_NAME,
+    internalPlugins: plugins,
+    handleSetupResult
+  });
+}
+export {
+  run
+};

package/dist/esm-node/new/utils/index.js

@@ -0,0 +1,10 @@
+import { createLoadedConfig } from "@modern-js/plugin-v2/cli";
+async function getIsAutoLoadPlugins(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
+};

package/dist/esm-node/old.js

@@ -0,0 +1,140 @@
+import path from "path";
+import { getLocaleLanguage } from "@modern-js/plugin-i18n/language-detector";
+import { castArray } from "@modern-js/uni-builder";
+import { cleanRequireCache, deprecatedCommands, emptyDir, getArgv, getCommand } from "@modern-js/utils";
+import { hooks } from "./hooks";
+import { i18n } from "./locale";
+import analyzePlugin from "./plugins/analyze";
+import deployPlugin from "./plugins/deploy";
+import initializePlugin from "./plugins/initialize";
+import serverBuildPlugin from "./plugins/serverBuild";
+import { buildCommand, deployCommand, devCommand, inspectCommand, newCommand, serverCommand, upgradeCommand } from "./commands";
+import { generateWatchFiles } from "./utils/generateWatchFiles";
+import { restart } from "./utils/restart";
+import { dev } from "./commands/dev";
+import { mergeConfig } from "@modern-js/core";
+export * from "./defineConfig";
+export * from "./types";
+const appTools = (options = {
+  // default webpack to be compatible with original projects
+  bundler: "webpack"
+}) => ({
+  name: "@modern-js/app-tools-old",
+  post: [
+    "@modern-js/plugin-initialize",
+    "@modern-js/plugin-analyze",
+    "@modern-js/plugin-ssr",
+    "@modern-js/plugin-document",
+    "@modern-js/plugin-state",
+    "@modern-js/plugin-router",
+    "@modern-js/plugin-router-v5",
+    "@modern-js/plugin-polyfill"
+  ],
+  registerHook: hooks,
+  usePlugins: [
+    initializePlugin({
+      bundler: (options === null || options === void 0 ? void 0 : options.bundler) && [
+        "rspack",
+        "experimental-rspack"
+      ].includes(options.bundler) ? "rspack" : "webpack"
+    }),
+    analyzePlugin({
+      bundler: (options === null || options === void 0 ? void 0 : options.bundler) && [
+        "rspack",
+        "experimental-rspack"
+      ].includes(options.bundler) ? "rspack" : "webpack"
+    }),
+    serverBuildPlugin(),
+    deployPlugin()
+  ],
+  setup: (api) => {
+    const appContext = api.useAppContext();
+    api.setAppContext({
+      ...appContext,
+      toolsType: "app-tools"
+    });
+    const locale = getLocaleLanguage();
+    i18n.changeLanguage({
+      locale
+    });
+    return {
+      async beforeConfig() {
+        var _userConfig_output;
+        const userConfig = api.useConfigContext();
+        const appContext2 = api.useAppContext();
+        if ((_userConfig_output = userConfig.output) === null || _userConfig_output === void 0 ? void 0 : _userConfig_output.tempDir) {
+          api.setAppContext({
+            ...appContext2,
+            internalDirectory: path.resolve(appContext2.appDirectory, userConfig.output.tempDir)
+          });
+        }
+      },
+      async commands({ program }) {
+        await devCommand(program, api);
+        await buildCommand(program, api);
+        serverCommand(program, api);
+        deployCommand(program, api);
+        newCommand(program, locale);
+        inspectCommand(program, api);
+        upgradeCommand(program);
+        deprecatedCommands(program);
+      },
+      async prepare() {
+        const command = getCommand();
+        if (command === "deploy") {
+          const isSkipBuild = [
+            "-s",
+            "--skip-build"
+          ].some((tag) => {
+            return getArgv().includes(tag);
+          });
+          if (isSkipBuild) {
+            return;
+          }
+        }
+        if (command === "dev" || command === "start" || command === "build" || command === "deploy") {
+          const resolvedConfig = api.useResolvedConfigContext();
+          if (resolvedConfig.output.cleanDistPath) {
+            const appContext2 = api.useAppContext();
+            await emptyDir(appContext2.distDirectory);
+          }
+        }
+      },
+      async watchFiles() {
+        const appContext2 = api.useAppContext();
+        const config = api.useResolvedConfigContext();
+        const files = await generateWatchFiles(appContext2, config.source.configDir);
+        const watchFiles = castArray(config.dev.watchFiles);
+        watchFiles.forEach(({ type, paths }) => {
+          if (type === "reload-server") {
+            files.push(...Array.isArray(paths) ? paths : [
+              paths
+            ]);
+          }
+        });
+        return files;
+      },
+      // 这里会被 core/initWatcher 监听的文件变动触发，如果是 src 目录下的文件变动，则不做 restart
+      async fileChange(e) {
+        const { filename, eventType, isPrivate } = e;
+        if (!isPrivate && (eventType === "change" || eventType === "unlink")) {
+          const { closeServer } = await import("./utils/createServer.js");
+          await closeServer();
+          await restart(api.useHookRunners(), filename);
+        }
+      },
+      async beforeRestart() {
+        cleanRequireCache([
+          require.resolve("./plugins/analyze")
+        ]);
+      }
+    };
+  }
+});
+var old_default = appTools;
+export {
+  appTools,
+  old_default as default,
+  dev,
+  mergeConfig
+};

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.distDirectory, ((_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/utils/restart.js

@@ -1,4 +1,4 @@
-import { cli } from "@modern-js/core";
+import { cli } from "@modern-js/plugin-v2/cli";
 import { chalk, clearConsole, getFullArgv, logger, program } from "@modern-js/utils";
 async function restart(hooksRunner, filename) {
   clearConsole();

package/dist/types/config/default.d.ts

@@ -1,3 +1,4 @@
-import type { AppLegacyUserConfig, AppUserConfig, IAppContext } from '../types';
-export declare function createDefaultConfig(appContext: IAppContext): AppUserConfig<'webpack'> | AppUserConfig<'rspack'>;
-export declare function createLegacyDefaultConfig(appContext: IAppContext): AppLegacyUserConfig;
+import type { AppLegacyUserConfig, AppUserConfig } from '../types';
+import type { AppToolsContext } from '../types/new';
+export declare function createDefaultConfig(appContext: AppToolsContext<'shared'>): AppUserConfig<'webpack'> | AppUserConfig<'rspack'>;
+export declare function createLegacyDefaultConfig(appContext: AppToolsContext<'shared'>): AppLegacyUserConfig;

package/dist/types/index.d.ts

@@ -1,20 +1,10 @@
-import type { CliPlugin } from '@modern-js/core';
-import type { AppTools } from './types';
+import { appTools } from './new/index';
+export { appTools };
+export { initAppContext } from './new/index';
+export { defineConfig, defineLegacyConfig } from './defineConfig';
+export { mergeConfig } from '@modern-js/core';
+export type { RuntimeUserConfig } from './types/config';
 export { dev } from './commands/dev';
 export type { DevOptions } from './utils/types';
-export { mergeConfig } from '@modern-js/core';
-export * from './defineConfig';
 export * from './types';
-export type { RuntimeUserConfig } from './types/config';
-export type AppToolsOptions = {
-    /**
-     * Specify which bundler to use for the build.
-     * @default `webpack`
-     * */
-    bundler?: 'rspack' | 'webpack' | 'experimental-rspack';
-};
-/**
- * The core package of the framework, providing CLI commands, build capabilities, configuration parsing and more.
- */
-export declare const appTools: (options?: AppToolsOptions) => CliPlugin<AppTools<'shared'>>;
 export default appTools;

package/dist/types/new/compat/hooks.d.ts

@@ -0,0 +1,7 @@
+import type { InternalContext } from '@modern-js/plugin-v2';
+import type { AppTools } from '../../types';
+/**
+ * old plugin useHookRunners function result
+ */
+export declare function getHookRunners(context: InternalContext<AppTools>): Record<string, any>;
+export declare function handleSetupResult(setupResult: Record<string, (...args: any) => any>, api: Record<string, any>): void;

package/dist/types/new/compat/index.d.ts

@@ -0,0 +1,2 @@
+import type { AppTools, CliPluginFuture } from '../../types';
+export declare const compatPlugin: () => CliPluginFuture<AppTools>;

package/dist/types/new/compat/utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Maps old plugin hook function names to new plugin API names
+ */
+export declare function transformHookRunner(hookRunnerName: string): string;
+export declare function transformHookParams(hookRunnerName: string, params: any): any;
+export declare function transformHookResult(hookRunnerName: string, result: any): any;

package/dist/types/new/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const PACKAGE_JSON_CONFIG_NAME = "modernConfig";
+export declare const DEFAULT_CONFIG_FILE = "modern.config";
+export declare const DEFAULT_SERVER_CONFIG_FILE = "modern.server-runtime.config";
+export declare const DEFAULT_RUNTIME_CONFIG_FILE = "modern.runtime";

package/dist/types/new/context.d.ts

@@ -0,0 +1,33 @@
+export declare const initAppContext: ({ appDirectory, runtimeConfigFile, options, serverConfigFile, tempDir, }: {
+    appDirectory: string;
+    runtimeConfigFile: string | false;
+    options?: {
+        metaName?: string | undefined;
+        srcDir?: string | undefined;
+        apiDir?: string | undefined;
+        distDir?: string | undefined;
+        sharedDir?: string | undefined;
+    } | undefined;
+    serverConfigFile: string;
+    tempDir?: string | undefined;
+}) => {
+    metaName: string;
+    runtimeConfigFile: string | false;
+    serverConfigFile: string;
+    ip: any;
+    port: number;
+    moduleType: any;
+    apiDirectory: string;
+    lambdaDirectory: string;
+    sharedDirectory: string;
+    distDirectory: string;
+    serverPlugins: never[];
+    internalDirectory: string;
+    htmlTemplates: {};
+    serverRoutes: never[];
+    entrypoints: never[];
+    checkedEntries: never[];
+    apiOnly: boolean;
+    internalDirAlias: string;
+    internalSrcAlias: string;
+};

package/dist/types/new/getConfigFile.d.ts

@@ -0,0 +1 @@
+export declare const getConfigFile: (configFile?: string) => string | false;

package/dist/types/new/index.d.ts

@@ -0,0 +1,6 @@
+import { type AppToolsOptions } from '../old';
+import type { AppTools, CliPluginFuture } from '../types';
+import { initAppContext } from './context';
+export * from '../defineConfig';
+export { initAppContext };
+export declare const appTools: (options?: AppToolsOptions) => CliPluginFuture<AppTools<'shared'>>;

package/dist/types/new/loadPlugins.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from '@modern-js/plugin-v2';
+import type { InternalPlugins } from '@modern-js/types';
+/**
+ * Load internal plugins which in @modern-js scope and user's custom plugins.
+ * @param appDirectory - Application root directory.
+ * @param internalPlugins - Internal plugins.
+ * @returns Plugin Objects has been required.
+ */
+export declare const loadInternalPlugins: (appDirectory: string, internalPlugins?: InternalPlugins, autoLoad?: InternalPlugins, autoLoadPlugins?: boolean) => Promise<Plugin[]>;

package/dist/types/new/run.d.ts

@@ -0,0 +1,13 @@
+import type { InternalPlugins } from '@modern-js/types';
+export interface RunOptions {
+    cwd?: string;
+    configFile?: string;
+    packageJsonConfig?: string;
+    internalPlugins?: {
+        cli?: InternalPlugins;
+        autoLoad?: InternalPlugins;
+    };
+    initialLog?: string;
+    version: string;
+}
+export declare function run({ cwd, initialLog, version, internalPlugins, packageJsonConfig, configFile, }: RunOptions): Promise<void>;

package/dist/types/new/utils/index.d.ts

@@ -0,0 +1 @@
+export declare function getIsAutoLoadPlugins(appDirectory: string, configFile?: string, packageJsonConfig?: string): Promise<boolean>;

package/dist/types/old.d.ts

@@ -0,0 +1,13 @@
+import type { CliPlugin } from '@modern-js/core';
+import type { AppTools, AppToolsOptions } from './types';
+export { dev } from './commands/dev';
+export type { DevOptions } from './utils/types';
+export { mergeConfig } from '@modern-js/core';
+export * from './defineConfig';
+export * from './types';
+export type { RuntimeUserConfig } from './types/config';
+/**
+ * The core package of the framework, providing CLI commands, build capabilities, configuration parsing and more.
+ */
+export declare const appTools: (options?: AppToolsOptions) => CliPlugin<AppTools<'shared'>>;
+export default appTools;

package/dist/types/plugins/initialize/index.d.ts

@@ -1,5 +1,5 @@
-import type { AppTools, CliPlugin } from '../../types';
+import type { AppTools, CliPluginFuture } from '../../types';
 declare const _default: ({ bundler, }: {
     bundler: 'rspack' | 'webpack';
-}) => CliPlugin<AppTools<'shared'>>;
+}) => CliPluginFuture<AppTools<'shared'>>;
 export default _default;

package/dist/types/types/index.d.ts

@@ -1,7 +1,9 @@
 import type { NormalizedConfig, UserConfig } from '@modern-js/core';
+import type { CLIPlugin, CLIPluginExtends } from '@modern-js/plugin-v2';
 import type { AppToolsNormalizedConfig, AppToolsUserConfig } from './config';
 import type { AppToolsHooks } from './hooks';
 import type { AppToolsLegacyNormalizedConfig, AppToolsLegacyUserConfig } from './legacyConfig';
+import type { AppToolsExtendAPI, AppToolsExtendContext, AppToolsExtendHooks } from './new';
 import type { Bundler } from './utils';
 export * from './hooks';
 export * from './config';
@@ -10,17 +12,24 @@ export type { webpack, Rspack } from '@modern-js/uni-builder';
 export type { Bundler } from './utils';
 export type { ServerUserConfig, ServerNormalizedConfig, BffUserConfig, BffNormalizedConfig, SSR, SSRByEntries, Resource, Params, RequestHandlerConfig, LoaderContext, OnError, OnTiming, RequestHandlerOptions, RequestHandler, } from '@modern-js/server-core';
 export type { IAppContext, PluginAPI, CliPlugin, NormalizedConfig, UserConfig, } from '@modern-js/core';
-export type AppTools<B extends Bundler = 'webpack'> = {
-    hooks: AppToolsHooks<B>;
+export type AppTools<B extends Bundler = 'webpack'> = Required<CLIPluginExtends<AppToolsUserConfig<B>, AppToolsNormalizedConfig, AppToolsExtendContext<B>, AppToolsExtendAPI<B>, AppToolsExtendHooks>> & {
     userConfig: AppToolsUserConfig<B>;
-    normalizedConfig: AppToolsNormalizedConfig<AppToolsUserConfig<'shared'>>;
+    hooks: AppToolsHooks<B>;
 };
 export type LegacyAppTools = {
     hooks: AppToolsHooks;
     userConfig: AppToolsLegacyUserConfig;
     normalizedConfig: AppToolsLegacyNormalizedConfig;
 };
+export type CliPluginFuture<Extends extends CLIPluginExtends> = CLIPlugin<Extends>;
 export type AppNormalizedConfig<B extends Bundler = 'webpack'> = NormalizedConfig<AppTools<B>>;
 export type AppLegacyNormalizedConfig = NormalizedConfig<LegacyAppTools>;
 export type AppUserConfig<B extends Bundler = 'webpack'> = UserConfig<AppTools<B>>;
 export type AppLegacyUserConfig = UserConfig<LegacyAppTools>;
+export type AppToolsOptions = {
+    /**
+     * Specify which bundler to use for the build.
+     * @default `webpack`
+     * */
+    bundler?: 'rspack' | 'webpack' | 'experimental-rspack';
+};

package/dist/types/types/new.d.ts

@@ -0,0 +1,145 @@
+import type { DevToolData, RegisterBuildPlatformResult } from '@modern-js/core';
+import type { AppContext, InternalContext, PluginHook, PluginHookTap, TransformFunction } from '@modern-js/plugin-v2';
+import type { Entrypoint, NestedRouteForCli, PageRoute, RouteLegacy, ServerPlugin, ServerRoute } from '@modern-js/types';
+import type { AppTools } from '.';
+import type { getHookRunners } from '../new/compat/hooks';
+import type { AppToolsNormalizedConfig, AppToolsUserConfig } from './config';
+import type { RuntimePlugin } from './hooks';
+import type { Bundler } from './utils';
+export type BeforeConfigFn = () => Promise<void> | void;
+export type AfterPrepareFn = () => Promise<void> | void;
+export type InternalRuntimePluginsFn = TransformFunction<{
+    entrypoint: Entrypoint;
+    plugins: RuntimePlugin[];
+}>;
+export type InternalServerPluginsFn = TransformFunction<{
+    plugins: ServerPlugin[];
+}>;
+export type CheckEntryPointFn = TransformFunction<{
+    path: string;
+    entry: false | string;
+}>;
+export type ModifyEntrypointsFn = TransformFunction<{
+    entrypoints: Entrypoint[];
+}>;
+export type ModifyFileSystemRoutesFn = TransformFunction<{
+    entrypoint: Entrypoint;
+    routes: RouteLegacy[] | (NestedRouteForCli | PageRoute)[];
+}>;
+export type ModifyServerRoutesFn = TransformFunction<{
+    routes: ServerRoute[];
+}>;
+export type DeplpoyFn = () => Promise<void> | void;
+export type GenerateEntryCodeFn = (params: {
+    entrypoints: Entrypoint[];
+}) => Promise<void> | void;
+export type BeforeGenerateRoutesFn = TransformFunction<{
+    entrypoint: Entrypoint;
+    code: string;
+}>;
+export type BeforePrintInstructionsFn = TransformFunction<{
+    instructions: string;
+}>;
+export type RegisterDevFn = (params: {
+    name: string;
+    entry: string;
+    type: string;
+    config: any;
+}) => Promise<DevToolData> | DevToolData;
+export type RegisterBuildPlatformFn = (params: {
+    name: string;
+    entry: string;
+    type: string;
+    config: any;
+}) => Promise<RegisterBuildPlatformResult> | RegisterBuildPlatformResult;
+export type AddRuntimeExportsFn = (params: {
+    entrypoint: Entrypoint;
+    exports: string[];
+}) => Promise<void> | void;
+export interface AppToolsExtendAPI<B extends Bundler = 'webpack'> {
+    onBeforeConfig: PluginHookTap<BeforeConfigFn>;
+    onAfterPrepare: PluginHookTap<AfterPrepareFn>;
+    deploy: PluginHookTap<DeplpoyFn>;
+    _internalRuntimePlugins: PluginHookTap<InternalRuntimePluginsFn>;
+    _internalServerPlugins: PluginHookTap<InternalServerPluginsFn>;
+    checkEntryPoint: PluginHookTap<CheckEntryPointFn>;
+    modifyEntrypoints: PluginHookTap<ModifyEntrypointsFn>;
+    modifyFileSystemRoutes: PluginHookTap<ModifyFileSystemRoutesFn>;
+    modifyServerRoutes: PluginHookTap<ModifyServerRoutesFn>;
+    generateEntryCode: PluginHookTap<GenerateEntryCodeFn>;
+    onBeforeGenerateRoutes: PluginHookTap<BeforeGenerateRoutesFn>;
+    /**
+     * @deprecated
+     */
+    onBeforePrintInstructions: PluginHookTap<BeforePrintInstructionsFn>;
+    /**
+     * @deprecated
+     */
+    registerDev: PluginHookTap<RegisterDevFn>;
+    /**
+     * @deprecated
+     */
+    registerBuildPlatform: PluginHookTap<RegisterBuildPlatformFn>;
+    /**
+     * @deprecated
+     */
+    addRuntimeExports: PluginHookTap<AddRuntimeExportsFn>;
+    /**
+     * @deprecated use getAppContext instead
+     */
+    useAppContext: () => AppToolsContext<B>;
+    /**
+     * @deprecated use getConfig instead
+     */
+    useConfigContext: () => AppToolsUserConfig<B>;
+    /**
+     * @deprecated use getNormalizedConfig instead
+     */
+    useResolvedConfigContext: () => AppToolsNormalizedConfig<AppToolsUserConfig<B>>;
+    /**
+     * @deprecated use api.xx instead
+     */
+    useHookRunners: () => ReturnType<typeof getHookRunners>;
+}
+export interface AppToolsExtendHooks extends Record<string, PluginHook<(...args: any[]) => any>> {
+    onBeforeConfig: PluginHook<BeforeConfigFn>;
+    onAfterPrepare: PluginHook<AfterPrepareFn>;
+    deploy: PluginHook<DeplpoyFn>;
+    _internalRuntimePlugins: PluginHook<InternalRuntimePluginsFn>;
+    _internalServerPlugins: PluginHook<InternalServerPluginsFn>;
+    checkEntryPoint: PluginHook<CheckEntryPointFn>;
+    modifyEntrypoints: PluginHook<ModifyEntrypointsFn>;
+    modifyFileSystemRoutes: PluginHook<ModifyFileSystemRoutesFn>;
+    modifyServerRoutes: PluginHook<ModifyServerRoutesFn>;
+    generateEntryCode: PluginHook<GenerateEntryCodeFn>;
+    onBeforeGenerateRoutes: PluginHook<BeforeGenerateRoutesFn>;
+    /**
+     * @deprecated
+     */
+    onBeforePrintInstructions: PluginHook<BeforePrintInstructionsFn>;
+    /**
+     * @deprecated
+     */
+    registerDev: PluginHook<RegisterDevFn>;
+    /**
+     * @deprecated
+     */
+    registerBuildPlatform: PluginHook<RegisterBuildPlatformFn>;
+    /**
+     * @deprecated
+     */
+    addRuntimeExports: PluginHook<AddRuntimeExportsFn>;
+}
+export type AppToolsExtendContext<B extends Bundler = 'webpack'> = {
+    metaName: string;
+    internalDirectory: string;
+    sharedDirectory: string;
+    internalDirAlias: string;
+    internalSrcAlias: string;
+    apiDirectory: string;
+    lambdaDirectory: string;
+    serverPlugins: ServerPlugin[];
+    moduleType: 'module' | 'commonjs';
+    _internalContext: InternalContext<AppTools<B>>;
+};
+export type AppToolsContext<B extends Bundler = 'webpack'> = AppContext<AppTools<B>> & AppToolsExtendContext<B>;