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

package/dist/esm-node/utils/loadPlugins.js

@@ -1,12 +1,13 @@
 import { loadServerPlugins as loadServerPluginInstances } from "@modern-js/prod-server";
+import { compatibleRequire, createDebugger, dynamicImport, getInternalPlugins, tryResolve } from "@modern-js/utils";
+const debug = createDebugger("load-plugins");
 async function getServerPlugins(api, metaName = "modern-js") {
-  const runner = api.useHookRunners();
-  const { plugins } = await runner._internalServerPlugins({
+  const hooks = api.getHooks();
+  const { plugins } = await hooks._internalServerPlugins.call({
     plugins: []
   });
   const filtedPlugins = plugins.filter((plugin) => plugin.name.includes(metaName));
-  api.setAppContext({
-    ...api.useAppContext(),
+  api.updateAppContext({
     serverPlugins: filtedPlugins
   });
   return filtedPlugins;
@@ -16,7 +17,36 @@ async function loadServerPlugins(api, appDirectory, metaName) {
   const instances = await loadServerPluginInstances(plugins, appDirectory);
   return instances;
 }
+const resolveCliPlugin = async (p, appDirectory) => {
+  const pkg = typeof p === "string" ? p : p[0];
+  const pluginOptions = typeof p === "string" ? void 0 : p[1];
+  const path = tryResolve(pkg, appDirectory);
+  let module;
+  try {
+    module = await compatibleRequire(path);
+  } catch (e) {
+    ({ default: module } = await dynamicImport(path));
+  }
+  if (typeof module === "function") {
+    const result = module(pluginOptions);
+    return result;
+  }
+  return module;
+};
+const loadInternalPlugins = async (appDirectory, internalPlugins, autoLoad, autoLoadPlugins) => {
+  const plugins = [
+    ...autoLoadPlugins ? getInternalPlugins(appDirectory, internalPlugins) : [],
+    ...autoLoad ? getInternalPlugins(appDirectory, autoLoad) : []
+  ];
+  const loadedPlugins = await Promise.all(plugins.map((plugin) => {
+    const loadedPlugin = resolveCliPlugin(plugin, appDirectory);
+    debug(`resolve plugin %s: %s`, plugin, loadedPlugin);
+    return loadedPlugin;
+  }));
+  return loadedPlugins;
+};
 export {
   getServerPlugins,
+  loadInternalPlugins,
   loadServerPlugins
 };

package/dist/esm-node/utils/printInstructions.js

@@ -1,7 +1,7 @@
 import { logger, prettyInstructions } from "@modern-js/utils";
-const printInstructions = async (hookRunners, appContext, config) => {
+const printInstructions = async (hooks, appContext, config) => {
   const message = prettyInstructions(appContext, config);
-  const { instructions } = await hookRunners.beforePrintInstructions({
+  const { instructions } = await hooks.onBeforePrintInstructions.call({
     instructions: message
   });
   logger.log(instructions);

package/dist/esm-node/utils/restart.js

@@ -1,11 +1,12 @@
 import { cli } from "@modern-js/plugin-v2/cli";
-import { chalk, clearConsole, getFullArgv, logger, program } from "@modern-js/utils";
-async function restart(hooksRunner, filename) {
+import { chalk, clearConsole, getFullArgv, logger } from "@modern-js/utils";
+import { program } from "@modern-js/utils/commander";
+async function restart(hooks, filename) {
   clearConsole();
   logger.info(`Restart because ${chalk.yellow(filename)} is changed...
 `);
   let hasGetError = false;
-  await hooksRunner.beforeRestart();
+  await hooks.onBeforeRestart.call();
   try {
     await cli.init(cli.getPrevInitOptions());
   } catch (err) {

package/dist/types/builder/generator/adapterCopy.d.ts

@@ -1,3 +1,4 @@
 import type { RsbuildPlugin } from '@modern-js/uni-builder';
+import type { Bundler } from '../../types';
 import type { BuilderOptions } from '../shared';
-export declare const builderPluginAdapterCopy: (options: BuilderOptions<'shared'>) => RsbuildPlugin;
+export declare const builderPluginAdapterCopy: <B extends Bundler>(options: BuilderOptions<B>) => RsbuildPlugin;

package/dist/types/builder/generator/createBuilderProviderConfig.d.ts

@@ -1,2 +1,3 @@
-import type { AppNormalizedConfig, Bundler, IAppContext } from '../../types';
-export declare function createBuilderProviderConfig<B extends Bundler>(resolveConfig: AppNormalizedConfig<B>, appContext: IAppContext): Omit<AppNormalizedConfig<B>, 'plugins'>;
+import type { AppNormalizedConfig, Bundler } from '../../types';
+import type { AppToolsContext } from '../../types/new';
+export declare function createBuilderProviderConfig<B extends Bundler>(resolveConfig: AppNormalizedConfig<B>, appContext: AppToolsContext<B>): Omit<AppNormalizedConfig<B>, 'plugins'>;

package/dist/types/builder/generator/createCopyPattern.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="node" />
 import type { Rspack, RspackChain } from '@rsbuild/core';
-import type { AppNormalizedConfig, Bundler, IAppContext } from '../../types';
-export declare function createPublicPattern(appContext: IAppContext, config: AppNormalizedConfig, chain: RspackChain): {
+import type { AppNormalizedConfig, Bundler } from '../../types';
+import type { AppToolsContext } from '../../types/new';
+export declare function createPublicPattern<B extends Bundler>(appContext: AppToolsContext<B>, config: AppNormalizedConfig, chain: RspackChain): {
     info: (file: {
         sourceFilename: string;
     }) => {
@@ -13,4 +14,4 @@ export declare function createPublicPattern(appContext: IAppContext, config: App
     noErrorOnMissing: boolean;
     transform: (content: Buffer, absoluteFrom: string) => string | Buffer;
 };
-export declare function createUploadPattern<B extends Bundler>(appContext: IAppContext, config: AppNormalizedConfig<B>): Rspack.CopyRspackPluginOptions['patterns']['0'];
+export declare function createUploadPattern<B extends Bundler>(appContext: AppToolsContext<B>, config: AppNormalizedConfig<B>): Rspack.CopyRspackPluginOptions['patterns']['0'];

package/dist/types/builder/generator/getBuilderEnvironments.d.ts

@@ -1,6 +1,6 @@
-import type { IAppContext } from '@modern-js/core';
 import type { AppNormalizedConfig, Bundler } from '../../types';
-export declare function getBuilderEnvironments<B extends Bundler>(normalizedConfig: AppNormalizedConfig<'shared'>, appContext: IAppContext, tempBuilderConfig: Omit<AppNormalizedConfig<B>, 'plugins'>): {
+import type { AppToolsContext } from '../../types/new';
+export declare function getBuilderEnvironments<B extends Bundler>(normalizedConfig: AppNormalizedConfig<B>, appContext: AppToolsContext<B>, tempBuilderConfig: Omit<AppNormalizedConfig<B>, 'plugins'>): {
     environments: {
         [name: string]: import("@rsbuild/core").EnvironmentConfig;
     };

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

@@ -1 +1 @@
-export declare function createBuilderGenerator(bundler: 'webpack' | 'rspack'): Promise<typeof import("./builder-rspack/index.js").createRspackBuilderForModern>;
+export declare function createBuilderGenerator(bundler: 'webpack' | 'rspack'): Promise<typeof import("./builder-rspack/index.js").createRspackBuilderForModern | typeof import("./builder-webpack/index.js").createWebpackBuilderForModern>;

package/dist/types/builder/shared/createCopyInfo.d.ts

@@ -1,5 +1,6 @@
-import type { AppNormalizedConfig, IAppContext } from '../../types';
-export declare function createCopyInfo(appContext: IAppContext, config: AppNormalizedConfig<'shared'>): {
+import type { AppNormalizedConfig, Bundler } from '../../types';
+import type { AppToolsContext } from '../../types/new';
+export declare function createCopyInfo<B extends Bundler>(appContext: AppToolsContext<B>, config: AppNormalizedConfig<B>): {
     configDir: string;
     uploadDir: string;
     publicDir: string;

package/dist/types/builder/shared/types.d.ts

@@ -1,5 +1,6 @@
-import type { AppNormalizedConfig, Bundler, IAppContext } from '../../types';
+import type { AppNormalizedConfig, Bundler } from '../../types';
+import type { AppToolsContext } from '../../types/new';
 export type BuilderOptions<B extends Bundler> = {
     normalizedConfig: AppNormalizedConfig<B>;
-    appContext: IAppContext;
+    appContext: AppToolsContext<B>;
 };

package/dist/types/commands/build.d.ts

@@ -1,4 +1,4 @@
-import { type PluginAPI } from '@modern-js/core';
+import type { CLIPluginAPI } from '@modern-js/plugin-v2';
 import type { AppTools } from '../types';
 import type { BuildOptions } from '../utils/types';
-export declare const build: (api: PluginAPI<AppTools<'shared'>>, options?: BuildOptions) => Promise<void>;
+export declare const build: (api: CLIPluginAPI<AppTools<'shared'>>, options?: BuildOptions) => Promise<void>;

package/dist/types/commands/deploy.d.ts

@@ -1,3 +1,3 @@
-import type { PluginAPI } from '@modern-js/core';
+import type { CLIPluginAPI } from '@modern-js/plugin-v2';
 import type { AppTools } from '../types';
-export declare const deploy: (api: PluginAPI<AppTools<'shared'>>, options: any) => Promise<void>;
+export declare const deploy: (api: CLIPluginAPI<AppTools<'shared'>>, options: any) => Promise<void>;

package/dist/types/commands/dev.d.ts

@@ -1,8 +1,8 @@
-import { type PluginAPI } from '@modern-js/core';
+import type { CLIPluginAPI } from '@modern-js/plugin-v2';
 import { type ApplyPlugins } from '@modern-js/server';
 import type { AppTools } from '../types';
 import type { DevOptions } from '../utils/types';
 export interface ExtraServerOptions {
     applyPlugins?: ApplyPlugins;
 }
-export declare const dev: (api: PluginAPI<AppTools<'shared'>>, options: DevOptions, devServerOptions?: ExtraServerOptions) => Promise<void>;
+export declare const dev: (api: CLIPluginAPI<AppTools<'shared'>>, options: DevOptions, devServerOptions?: ExtraServerOptions) => Promise<void>;

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

@@ -1,10 +1,10 @@
-import type { PluginAPI } from '@modern-js/core';
+import type { CLIPluginAPI } from '@modern-js/plugin-v2';
 import { type Command } from '@modern-js/utils';
 import type { AppTools } from '../types';
-export declare const devCommand: (program: Command, api: PluginAPI<AppTools<'shared'>>) => Promise<void>;
-export declare const buildCommand: (program: Command, api: PluginAPI<AppTools<'shared'>>) => Promise<void>;
-export declare const serverCommand: (program: Command, api: PluginAPI<AppTools<'shared'>>) => void;
-export declare const deployCommand: (program: Command, api: PluginAPI<AppTools<'shared'>>) => void;
+export declare const devCommand: (program: Command, api: CLIPluginAPI<AppTools<'shared'>>) => Promise<void>;
+export declare const buildCommand: (program: Command, api: CLIPluginAPI<AppTools<'shared'>>) => Promise<void>;
+export declare const serverCommand: (program: Command, api: CLIPluginAPI<AppTools<'shared'>>) => void;
+export declare const deployCommand: (program: Command, api: CLIPluginAPI<AppTools<'shared'>>) => void;
 export declare const newCommand: (program: Command, locale: string) => void;
-export declare const inspectCommand: (program: Command, api: PluginAPI<AppTools<'shared'>>) => void;
+export declare const inspectCommand: (program: Command, api: CLIPluginAPI<AppTools<'shared'>>) => void;
 export declare const upgradeCommand: (program: Command) => void;

package/dist/types/commands/inspect.d.ts

@@ -1,4 +1,4 @@
-import type { PluginAPI } from '@modern-js/core';
+import type { CLIPluginAPI } from '@modern-js/plugin-v2';
 import type { AppTools } from '../types';
 import type { InspectOptions } from '../utils/types';
-export declare const inspect: (api: PluginAPI<AppTools<'shared'>>, options: InspectOptions) => Promise<import("@rsbuild/core").InspectConfigResult<"rspack">>;
+export declare const inspect: (api: CLIPluginAPI<AppTools<'shared'>>, options: InspectOptions) => Promise<import("@rsbuild/core").InspectConfigResult<"rspack">>;

package/dist/types/commands/serve.d.ts

@@ -1,3 +1,3 @@
-import type { PluginAPI } from '@modern-js/core';
+import type { CLIPluginAPI } from '@modern-js/plugin-v2';
 import type { AppTools } from '../types';
-export declare const start: (api: PluginAPI<AppTools<'shared'>>) => Promise<void>;
+export declare const start: (api: CLIPluginAPI<AppTools<'shared'>>) => Promise<void>;

package/dist/types/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<'shared'>>): Record<string, any>;
+export declare function handleSetupResult(setupResult: Record<string, (...args: any) => any>, api: Record<string, any>): void;

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

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

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/config/initialize/index.d.ts

@@ -1,2 +1,3 @@
-import type { AppNormalizedConfig, IAppContext } from '../../types';
-export declare function initialNormalizedConfig(config: AppNormalizedConfig<'shared'>, appContext: IAppContext, bundler: 'webpack' | 'rspack'): AppNormalizedConfig<'shared'>;
+import type { AppNormalizedConfig } from '../../types';
+import type { AppToolsContext } from '../../types/new';
+export declare function initialNormalizedConfig(config: AppNormalizedConfig<'shared'>, appContext: AppToolsContext<'shared'>, bundler: 'webpack' | 'rspack'): AppNormalizedConfig<'shared'>;

package/dist/types/config/initialize/inits.d.ts

@@ -1,4 +1,5 @@
-import type { AppNormalizedConfig, IAppContext } from '../../types';
-export declare function initHtmlConfig(config: AppNormalizedConfig<'shared'>, appContext: IAppContext): AppNormalizedConfig<'shared'>['html'];
-export declare function initSourceConfig(config: AppNormalizedConfig<'shared'>, appContext: IAppContext, bundler: 'webpack' | 'rspack'): void;
+import type { AppNormalizedConfig } from '../../types';
+import type { AppToolsContext } from '../../types/new';
+export declare function initHtmlConfig(config: AppNormalizedConfig<'shared'>, appContext: AppToolsContext<'shared'>): AppNormalizedConfig<'shared'>['html'];
+export declare function initSourceConfig(config: AppNormalizedConfig<'shared'>, appContext: AppToolsContext<'shared'>, bundler: 'webpack' | 'rspack'): void;
 export declare function createBuilderModuleScope(config: AppNormalizedConfig<'webpack'>): (string | RegExp)[] | undefined;

package/dist/types/index.d.ts

@@ -1,9 +1,12 @@
-import { appTools } from './new/index';
-export { appTools, initAppContext, type AppToolsPlugin } from './new/index';
+import type { AppTools, AppToolsOptions, CliPluginFuture } from './types';
+import { initAppContext } from './utils/initAppContext';
+export * from './defineConfig';
+export declare const appTools: (options?: AppToolsOptions) => CliPluginFuture<AppTools<'shared'>>;
+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 { defineConfig, defineLegacyConfig } from './defineConfig';
 export * from './types';
-export type { RuntimeUserConfig } from './types/config';
+export { initAppContext };
 export default appTools;

package/dist/types/plugins/analyze/getBundleEntry.d.ts

@@ -1,4 +1,4 @@
-import type { CliHooksRunner } from '@modern-js/core';
 import type { Entrypoint } from '@modern-js/types';
-import type { AppNormalizedConfig, AppTools, IAppContext } from '../../types';
-export declare const getBundleEntry: (hookRunners: CliHooksRunner<AppTools<'shared'>>, appContext: IAppContext, config: AppNormalizedConfig<'shared'>) => Promise<Entrypoint[]>;
+import type { AppNormalizedConfig } from '../../types';
+import type { AppToolsContext, AppToolsHooks } from '../../types/new';
+export declare const getBundleEntry: (hooks: AppToolsHooks<'shared'>, appContext: AppToolsContext<'shared'>, config: AppNormalizedConfig<'shared'>) => Promise<Entrypoint[]>;

package/dist/types/plugins/analyze/getFileSystemEntry.d.ts

@@ -1,5 +1,5 @@
-import type { CliHooksRunner } from '@modern-js/core';
 import type { Entrypoint } from '@modern-js/types';
-import type { AppNormalizedConfig, AppTools, IAppContext } from '../../types';
+import type { AppNormalizedConfig } from '../../types';
+import type { AppToolsContext, AppToolsHooks } from '../../types/new';
 export type { Entrypoint };
-export declare const getFileSystemEntry: (hookRunners: CliHooksRunner<AppTools<'shared'>>, appContext: IAppContext, config: AppNormalizedConfig<'shared'>) => Promise<Entrypoint[]>;
+export declare const getFileSystemEntry: (hooks: AppToolsHooks<'shared'>, appContext: AppToolsContext<'shared'>, config: AppNormalizedConfig<'shared'>) => Promise<Entrypoint[]>;

package/dist/types/plugins/analyze/getHtmlTemplate.d.ts

@@ -1,6 +1,27 @@
-import type { Entrypoint, HtmlTemplates } from '@modern-js/types';
-import type { AppNormalizedConfig, AppTools, IAppContext, PluginAPI } from '../../types';
-export declare const getHtmlTemplate: (entrypoints: Entrypoint[], api: PluginAPI<AppTools<'shared'>>, { appContext, config, }: {
-    appContext: IAppContext;
+import type { Entrypoint, HtmlPartials, HtmlTemplates } from '@modern-js/types';
+import type { AppNormalizedConfig } from '../../types';
+import type { AppToolsContext, AppToolsHooks } from '../../types/new';
+export declare const getModifyHtmlPartials: (partials: Record<keyof HtmlPartials, string[]>) => {
+    top: {
+        append: (...script: string[]) => void;
+        prepend: (...script: string[]) => void;
+        current: string[];
+    };
+    head: {
+        append: (...script: string[]) => void;
+        prepend: (...script: string[]) => void;
+        current: string[];
+    };
+    body: {
+        append: (...script: string[]) => void;
+        prepend: (...script: string[]) => void;
+        current: string[];
+    };
+};
+export declare const getHtmlTemplate: (entrypoints: Entrypoint[], hooks: AppToolsHooks<'shared'>, { appContext, config, }: {
+    appContext: AppToolsContext<'shared'>;
     config: AppNormalizedConfig<'shared'>;
-}) => Promise<HtmlTemplates>;
+}) => Promise<{
+    partialsByEntrypoint: Record<string, HtmlPartials>;
+    htmlTemplates: HtmlTemplates;
+}>;

package/dist/types/plugins/analyze/getServerRoutes.d.ts

@@ -1,7 +1,7 @@
-import type { IAppContext } from '@modern-js/core';
 import type { Entrypoint, ServerRoute } from '@modern-js/types';
 import type { AppNormalizedConfig } from '../../types';
+import type { AppToolsContext } from '../../types/new';
 export declare const getServerRoutes: (entrypoints: Entrypoint[], { appContext, config, }: {
-    appContext: IAppContext;
+    appContext: AppToolsContext<'shared'>;
     config: AppNormalizedConfig<'shared'>;
 }) => ServerRoute[];

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

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

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

@@ -1,4 +1,3 @@
-import type { CliPlugin } from '@modern-js/core';
-import type { AppTools } from '../../types';
-declare const _default: () => CliPlugin<AppTools>;
+import type { AppTools, CliPluginFuture } from '../../types';
+declare const _default: () => CliPluginFuture<AppTools<'shared'>>;
 export default _default;

package/dist/types/plugins/deploy/platforms/platform.d.ts

@@ -1,6 +1,6 @@
-import type { IAppContext, NormalizedConfig } from '@modern-js/core';
-import type { AppTools } from '../../../types';
-export type CreatePreset = (appContext: IAppContext, config: NormalizedConfig<AppTools>, needModernServer?: boolean) => DeployPreset;
+import type { AppToolsNormalizedConfig } from '../../../types';
+import type { AppToolsContext } from '../../../types/new';
+export type CreatePreset = (appContext: AppToolsContext<'shared'>, config: AppToolsNormalizedConfig, needModernServer?: boolean) => DeployPreset;
 type DeployPreset = {
     prepare?: () => Promise<void>;
     writeOutput?: () => Promise<void>;

package/dist/types/plugins/deploy/utils.d.ts

@@ -1,11 +1,11 @@
-import type { IAppContext } from '@modern-js/core';
+import type { AppToolsContext } from '../../types/new';
 export type ServerAppContext = {
     sharedDirectory: string;
     apiDirectory: string;
     lambdaDirectory: string;
     metaName: string;
 };
-export declare const serverAppContenxtTemplate: (appContext: IAppContext) => {
+export declare const serverAppContenxtTemplate: (appContext: AppToolsContext<'shared'>) => {
     sharedDirectory: string;
     apiDirectory: string;
     lambdaDirectory: string;

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/plugins/serverBuild.d.ts

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

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

@@ -1,8 +1,11 @@
 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 type { CLIPluginExtends };
 export * from './hooks';
 export * from './config';
 export * from './legacyConfig';
@@ -10,16 +13,16 @@ 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>>;
@@ -31,3 +34,4 @@ export type AppToolsOptions = {
      * */
     bundler?: 'rspack' | 'webpack' | 'experimental-rspack';
 };
+export type { AppToolsExtendAPI, AppToolsExtendContext, AppToolsExtendHooks, AppToolsContext, AppToolsHooks as AppToolsFeatureHooks, } from './new';

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

@@ -0,0 +1,157 @@
+import type { DevToolData, RegisterBuildPlatformResult } from '@modern-js/core';
+import type { AppContext, AsyncHook, CollectAsyncHook, InternalContext, PluginHook, PluginHookTap, TransformFunction } from '@modern-js/plugin-v2';
+import type { Hooks } from '@modern-js/plugin-v2/cli';
+import type { Entrypoint, HtmlPartials, HtmlTemplates, NestedRouteForCli, PageRoute, RouteLegacy, ServerPlugin, ServerRoute } from '@modern-js/types';
+import type { AppTools } from '.';
+import type { getHookRunners } from '../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 = () => Promise<DevToolData> | DevToolData;
+export type RegisterBuildPlatformFn = () => Promise<RegisterBuildPlatformResult> | RegisterBuildPlatformResult;
+export type AddRuntimeExportsFn = () => 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: AsyncHook<BeforeConfigFn>;
+    onAfterPrepare: AsyncHook<AfterPrepareFn>;
+    deploy: AsyncHook<DeplpoyFn>;
+    _internalRuntimePlugins: AsyncHook<InternalRuntimePluginsFn>;
+    _internalServerPlugins: AsyncHook<InternalServerPluginsFn>;
+    checkEntryPoint: AsyncHook<CheckEntryPointFn>;
+    modifyEntrypoints: AsyncHook<ModifyEntrypointsFn>;
+    modifyFileSystemRoutes: AsyncHook<ModifyFileSystemRoutesFn>;
+    modifyServerRoutes: AsyncHook<ModifyServerRoutesFn>;
+    generateEntryCode: AsyncHook<GenerateEntryCodeFn>;
+    onBeforeGenerateRoutes: AsyncHook<BeforeGenerateRoutesFn>;
+    /**
+     * @deprecated
+     */
+    onBeforePrintInstructions: AsyncHook<BeforePrintInstructionsFn>;
+    /**
+     * @deprecated
+     */
+    registerDev: CollectAsyncHook<RegisterDevFn>;
+    /**
+     * @deprecated
+     */
+    registerBuildPlatform: CollectAsyncHook<RegisterBuildPlatformFn>;
+    /**
+     * @deprecated
+     */
+    addRuntimeExports: AsyncHook<AddRuntimeExportsFn>;
+}
+export type AppToolsExtendContext<B extends Bundler = 'webpack'> = {
+    metaName: string;
+    internalDirectory: string;
+    sharedDirectory: string;
+    internalDirAlias: string;
+    internalSrcAlias: string;
+    apiDirectory: string;
+    lambdaDirectory: string;
+    serverConfigFile: string;
+    serverPlugins: ServerPlugin[];
+    moduleType: 'module' | 'commonjs';
+    /** Information for entry points */
+    entrypoints: Entrypoint[];
+    /** Selected entry points */
+    checkedEntries: string[];
+    /** Information for server routes */
+    serverRoutes: ServerRoute[];
+    /** Whether to use api only mode */
+    apiOnly: boolean;
+    _internalContext: InternalContext<AppTools<B>>;
+    /**
+     * Information for HTML templates by entry
+     * @private
+     */
+    partialsByEntrypoint?: Record<string, HtmlPartials>;
+    /**
+     * Information for HTML templates
+     * @private
+     */
+    htmlTemplates: HtmlTemplates;
+    /**
+     * @deprecated compat old plugin, default is app tools
+     */
+    toolsType?: string;
+};
+export type AppToolsContext<B extends Bundler = 'webpack'> = AppContext<AppTools<B>> & AppToolsExtendContext<B>;
+export type AppToolsHooks<B extends Bundler = 'webpack'> = Hooks<AppToolsUserConfig<B>, AppToolsNormalizedConfig> & AppToolsExtendHooks;

package/dist/types/utils/env.d.ts

@@ -1,2 +1,2 @@
-import type { IAppContext } from '../types';
-export declare function getAutoInjectEnv(appContext: IAppContext): Record<string, string>;
+import type { AppToolsContext } from '../types/new';
+export declare function getAutoInjectEnv(appContext: AppToolsContext<'shared'>): Record<string, string>;

package/dist/types/utils/generateWatchFiles.d.ts

@@ -1,3 +1,3 @@
-import type { IAppContext } from '../types';
+import type { AppToolsContext } from '../types/new';
 export declare const addServerConfigToDeps: (dependencies: string[], appDirectory: string, serverConfigFile: string) => Promise<void>;
-export declare function generateWatchFiles(appContext: IAppContext, configDir?: string): Promise<string[]>;
+export declare function generateWatchFiles(appContext: AppToolsContext<'shared'>, configDir?: string): Promise<string[]>;

package/dist/types/{new/context.d.ts → utils/initAppContext.d.ts}

@@ -20,7 +20,6 @@ export declare const initAppContext: ({ appDirectory, runtimeConfigFile, options
     apiDirectory: string;
     lambdaDirectory: string;
     sharedDirectory: string;
-    distDirectory: string;
     serverPlugins: never[];
     internalDirectory: string;
     htmlTemplates: {};