@modern-js/plugin 2.69.5 → 3.0.0-alpha.0

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

@@ -0,0 +1,8 @@
+import { createServer } from './create';
+export declare const server: {
+    run: (options: import("./types").ServerRunOptions) => Promise<{
+        serverContext: import("../..").InternalServerContext<import("../..").ServerPluginExtends<{}, {}, {}, {}>>;
+    }>;
+};
+export { createServer };
+export type { ServerCreateOptions } from './types';

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

@@ -0,0 +1,22 @@
+import type { ServerRoute } from '@modern-js/types';
+import type { Plugin } from '../../types/plugin';
+export type ServerCreateOptions = {
+    /** server working directory, and then also dist directory */
+    pwd: string;
+    metaName?: string;
+    routes?: ServerRoute[];
+    appContext: {
+        internalDirectory?: string;
+        appDirectory?: string;
+        sharedDirectory?: string;
+        apiDirectory?: string;
+        lambdaDirectory?: string;
+        bffRuntimeFramework?: string;
+    };
+};
+export type ServerRunOptions = {
+    options: ServerCreateOptions;
+    config: Record<string, any>;
+    plugins: Plugin[];
+    handleSetupResult?: (params: any, api: Record<string, any>) => Promise<void> | void;
+};

package/dist/types/types/cli/api.d.ts

@@ -0,0 +1,49 @@
+import type { OnAfterBuildFn, OnAfterCreateCompilerFn, OnBeforeBuildFn, OnBeforeCreateCompilerFn, OnDevCompileDoneFn } from '@rsbuild/core';
+import type { Hooks } from '../../cli/hooks';
+import type { PluginHook, PluginHookTap } from '../hooks';
+import type { DeepPartial } from '../utils';
+import type { AppContext } from './context';
+import type { AddCommandFn, AddWatchFilesFn, ConfigFn, InternalRuntimePluginsFn, InternalServerPluginsFn, ModifyBundlerChainFn, ModifyConfigFn, ModifyHtmlPartialsFn, ModifyResolvedConfigFn, ModifyRsbuildConfigFn, ModifyRspackConfigFn, ModifyServerRoutesFn, OnAfterDeployFn, OnAfterDevFn, OnBeforeDeployFn, OnBeforeDevFn, OnBeforeExitFn, OnBeforeRestartFn, OnFileChangedFn, OnPrepareFn } from './hooks';
+import type { CLIPluginExtends } from './plugin';
+/**
+ * Define a generic CLI plugin API that provider can extend as needed.
+ */
+export type CLIPluginAPI<Extends extends CLIPluginExtends> = Readonly<{
+    isPluginExists: (name: string) => boolean;
+    getAppContext: () => Readonly<AppContext<Extends> & Extends['extendContext']>;
+    getConfig: () => Readonly<Extends['config']>;
+    getNormalizedConfig: () => Readonly<Extends['normalizedConfig']>;
+    getHooks: () => Readonly<Hooks<Extends['config'], Extends['normalizedConfig'], Extends['extendBuildUtils'], Extends['extendConfigUtils']> & Extends['extendHooks']>;
+    updateAppContext: (appContext: DeepPartial<AppContext<Extends> & Extends['extendContext']>) => void;
+    config: PluginHookTap<ConfigFn<DeepPartial<Extends['config']>>>;
+    modifyConfig: PluginHookTap<ModifyConfigFn<Extends['config'], Extends['extendConfigUtils']>>;
+    modifyResolvedConfig: PluginHookTap<ModifyResolvedConfigFn<Extends['normalizedConfig'], Extends['extendConfigUtils']>>;
+    modifyRsbuildConfig: PluginHookTap<ModifyRsbuildConfigFn<Extends['extendBuildUtils']>>;
+    modifyBundlerChain: PluginHookTap<ModifyBundlerChainFn<Extends['extendBuildUtils']>>;
+    /** Only works when bundler is Rspack */
+    modifyRspackConfig: PluginHookTap<ModifyRspackConfigFn<Extends['extendBuildUtils']>>;
+    modifyHtmlPartials: PluginHookTap<ModifyHtmlPartialsFn>;
+    addCommand: PluginHookTap<AddCommandFn>;
+    onPrepare: PluginHookTap<OnPrepareFn>;
+    addWatchFiles: PluginHookTap<AddWatchFilesFn>;
+    onFileChanged: PluginHookTap<OnFileChangedFn>;
+    onBeforeRestart: PluginHookTap<OnBeforeRestartFn>;
+    onBeforeCreateCompiler: PluginHookTap<OnBeforeCreateCompilerFn>;
+    onAfterCreateCompiler: PluginHookTap<OnAfterCreateCompilerFn>;
+    onDevCompileDone: PluginHookTap<OnDevCompileDoneFn>;
+    onBeforeBuild: PluginHookTap<OnBeforeBuildFn>;
+    onAfterBuild: PluginHookTap<OnAfterBuildFn>;
+    onBeforeDev: PluginHookTap<OnBeforeDevFn>;
+    onAfterDev: PluginHookTap<OnAfterDevFn>;
+    onBeforeDeploy: PluginHookTap<OnBeforeDeployFn>;
+    onAfterDeploy: PluginHookTap<OnAfterDeployFn>;
+    onBeforeExit: PluginHookTap<OnBeforeExitFn>;
+    _internalRuntimePlugins: PluginHookTap<InternalRuntimePluginsFn>;
+    _internalServerPlugins: PluginHookTap<InternalServerPluginsFn>;
+    modifyServerRoutes: PluginHookTap<ModifyServerRoutesFn>;
+} & CLIPluginExtendsAPI<Extends>>;
+export type CLIPluginExtendsAPI<Extends extends CLIPluginExtends> = {
+    [K in keyof Extends['extendHooks']]: PluginHookTap<Extends['extendHooks'][K] extends PluginHook<infer Args> ? Args extends (...args: any[]) => any ? Args : (...args: any[]) => any : (...args: any[]) => any>;
+} & Extends['extendApi'];
+export type AllKeysForCLIPluginExtendsAPI<Extends extends CLIPluginExtends> = keyof CLIPluginExtendsAPI<Extends>;
+export type AllValueForCLIPluginExtendsAPI<Extends extends CLIPluginExtends> = CLIPluginExtendsAPI<Extends>[AllKeysForCLIPluginExtendsAPI<Extends>];

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

@@ -0,0 +1,42 @@
+import type { BuilderInstance } from '@modern-js/builder';
+import type { ServerRoute } from '@modern-js/types';
+import type { Hooks } from '../../cli/hooks';
+import type { CLIPluginAPI } from './api';
+import type { CLIPlugin, CLIPluginExtends } from './plugin';
+export interface Entrypoint {
+    isMainEntry?: boolean;
+    entryName: string;
+    entry: string;
+}
+/** The public context */
+export type AppContext<Extends extends CLIPluginExtends> = {
+    metaName: string;
+    packageName: string;
+    configFile: string;
+    command: string;
+    isProd: boolean;
+    appDirectory: string;
+    srcDirectory: string;
+    distDirectory: string;
+    nodeModulesDirectory: string;
+    plugins: CLIPlugin<Extends>[];
+    bundlerType?: 'rspack';
+    builder?: BuilderInstance;
+    port?: number;
+    host?: string;
+    ip?: string;
+    serverRoutes?: ServerRoute[];
+};
+/** The inner context. */
+export type InternalContext<Extends extends CLIPluginExtends> = AppContext<Extends> & {
+    /** All hooks. */
+    hooks: Hooks<Extends['config'], Extends['normalizedConfig'], Extends['extendBuildUtils'], Extends['extendConfigUtils']> & Extends['extendHooks'];
+    /** All plugin registry hooks */
+    extendsHooks: Extends['extendHooks'];
+    /** Current App config. */
+    config: Readonly<Extends['config']>;
+    /** The normalized Rsbuild config. */
+    normalizedConfig?: Extends['normalizedConfig'];
+    pluginAPI?: CLIPluginAPI<Extends> & Record<string, (...args: any[]) => any>;
+    _internalContext?: InternalContext<Extends>;
+};

package/dist/types/types/cli/hooks.d.ts

@@ -0,0 +1,72 @@
+import type { ServerPlugin as ServerPluginConfig, ServerRoute } from '@modern-js/types';
+import type { Command } from '@modern-js/utils/commander';
+import type { ModifyBundlerChainUtils, ModifyRspackConfigUtils, RsbuildConfig, Rspack, RspackChain } from '@rsbuild/core';
+import type { TransformFunction } from '../plugin';
+import type { MaybePromise } from '../utils';
+import type { Entrypoint } from './context';
+declare module '@modern-js/utils/commander' {
+    interface Command {
+        commandsMap: Map<string, Command>;
+    }
+}
+export interface RuntimePluginConfig {
+    name: string;
+    path: string;
+    config: Record<string, any>;
+}
+export type { ServerPluginConfig };
+export type ConfigFn<Config> = () => Config | Promise<Config>;
+export type ModifyConfigFn<Config, ExtendConfigUtils> = (arg: Config, utils?: ExtendConfigUtils) => Config | Promise<Config>;
+export type ModifyResolvedConfigFn<NormalizedConfig, ExtendConfigUtils> = (arg: NormalizedConfig, utils?: ExtendConfigUtils) => NormalizedConfig | Promise<NormalizedConfig>;
+type IPartialMethod = (...script: string[]) => void;
+export interface PartialMethod {
+    append: IPartialMethod;
+    prepend: IPartialMethod;
+}
+export type ModifyHtmlPartialsFn = (params: {
+    entrypoint: Entrypoint;
+    partials: {
+        top: PartialMethod;
+        head: PartialMethod;
+        body: PartialMethod;
+    };
+}) => Promise<void> | void;
+export type AddCommandFn = (params: {
+    program: Command;
+}) => void;
+export type OnPrepareFn = () => Promise<void> | void;
+type WatchFilesReturnType = Array<string> | {
+    files: string[];
+    isPrivate: boolean;
+};
+export type AddWatchFilesFn = () => WatchFilesReturnType | Promise<WatchFilesReturnType>;
+export type OnFileChangedFn = (params: {
+    filename: string;
+    eventType: 'add' | 'change' | 'unlink';
+    isPrivate: boolean;
+}) => void;
+export type OnBeforeRestartFn = () => Promise<void> | void;
+export type OnBeforeDevFn = () => Promise<void> | void;
+export type OnAfterDevFn = (params: {
+    port: number;
+}) => Promise<void> | void;
+export type OnBeforeDeployFn = (options?: Record<string, any>) => Promise<void> | void;
+export type OnAfterDeployFn = (options?: Record<string, any>) => Promise<void> | void;
+export type OnBeforeExitFn = () => Promise<void> | void;
+export type ModifyBundlerChainFn<ExtendsUtils> = (chain: RspackChain, utils: ModifyBundlerChainUtils & ExtendsUtils) => MaybePromise<void>;
+export type ModifyRsbuildConfigUtils = {
+    /** Merge multiple Rsbuild config objects into one. */
+    mergeRsbuildConfig: (...configs: RsbuildConfig[]) => RsbuildConfig;
+};
+export type ModifyRsbuildConfigFn<ExtendsUtils> = (config: RsbuildConfig, utils: ModifyRsbuildConfigUtils & ExtendsUtils) => MaybePromise<RsbuildConfig | void>;
+export type ModifyRspackConfigFn<ExtendsUtils> = (config: Rspack.Configuration, utils: ModifyRspackConfigUtils & ExtendsUtils) => MaybePromise<Rspack.Configuration | void>;
+export type InternalRuntimePluginsFn = TransformFunction<{
+    entrypoint: Entrypoint;
+    plugins: RuntimePluginConfig[];
+}>;
+export type InternalServerPluginsFn = TransformFunction<{
+    plugins: ServerPluginConfig[];
+}>;
+export type ModifyServerRoutesFn = TransformFunction<{
+    routes: ServerRoute[];
+}>;

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

@@ -0,0 +1,4 @@
+export type { CLIPluginAPI } from './api';
+export type { AppContext, InternalContext, Entrypoint } from './context';
+export type { CLIPlugin, CLIPluginExtends } from './plugin';
+export type { RuntimePluginConfig, ServerPluginConfig } from './hooks';

package/dist/types/types/cli/plugin.d.ts

@@ -0,0 +1,17 @@
+import type { PluginHook } from '../hooks';
+import type { Plugin } from '../plugin';
+import type { CLIPluginAPI } from './api';
+import type { AppContext } from './context';
+export interface CLIPluginExtends<Config extends Record<string, any> = {}, NormalizedConfig extends Record<string, any> = {}, ExtendContext extends Record<string, any> = {}, ExtendAPI extends Record<string, any> = {}, ExtendHook extends Record<string, PluginHook<(...args: any[]) => any>> = {}, ExtendBuildUtils extends Record<string, any> = {}, ExtendConfigUtils extends Record<string, any> = {}> {
+    config?: Config;
+    normalizedConfig?: NormalizedConfig;
+    extendContext?: ExtendContext;
+    extendApi?: ExtendAPI;
+    extendHooks?: ExtendHook;
+    extendBuildUtils?: ExtendBuildUtils;
+    extendConfigUtils?: ExtendConfigUtils;
+}
+/**
+ * The type of the CLI plugin object.
+ */
+export type CLIPlugin<Extends extends CLIPluginExtends> = Plugin<CLIPluginAPI<Extends> & Extends['extendApi'], AppContext<Extends> & Extends['extendContext']>;

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

@@ -0,0 +1,27 @@
+import type { Tail, UnwrapPromise } from './utils';
+export type SyncHook<Callback extends (...args: any[]) => any> = {
+    tap: (cb: Callback) => void;
+    call: (...args: Parameters<Callback>) => ReturnType<Callback>;
+};
+export type AsyncHook<Callback extends (...args: any[]) => any> = {
+    tap: (cb: Callback) => void;
+    call: (...args: Parameters<Callback>) => Promise<UnwrapPromise<ReturnType<Callback>>>;
+};
+export type AsyncInterruptHook<Callback extends (...args: any[]) => any> = {
+    tap: (cb: Callback) => void;
+    call: (...args: Tail<Parameters<Callback>>) => Promise<UnwrapPromise<ReturnType<Callback>>>;
+};
+export type AsyncPipelineHook<Callback extends (...args: any[]) => any> = {
+    tap: (cb: Callback) => void;
+    call: (...args: Parameters<Callback>) => Promise<UnwrapPromise<ReturnType<Callback>>>;
+};
+export type CollectAsyncHook<Callback extends (...params: any[]) => any> = {
+    tap: (cb: Callback) => void;
+    call: (...params: Parameters<Callback>) => Promise<UnwrapPromise<ReturnType<Callback>>[]>;
+};
+export type CollectSyncHook<Callback extends (...params: any[]) => any> = {
+    tap: (cb: Callback) => void;
+    call: (...params: Parameters<Callback>) => ReturnType<Callback>[];
+};
+export type PluginHook<Callback extends (...args: any[]) => any> = SyncHook<Callback> | AsyncHook<Callback> | CollectSyncHook<Callback> | CollectAsyncHook<Callback> | AsyncInterruptHook<Callback> | AsyncPipelineHook<Callback>;
+export type PluginHookTap<T extends (...args: any[]) => any> = (options: T) => void;

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

@@ -0,0 +1,4 @@
+export type { Plugin, PluginManager, TransformFunction, } from './plugin';
+export type { CLIPluginAPI, AppContext, InternalContext, Entrypoint, CLIPlugin, } from './cli';
+export type { RuntimePluginAPI, RuntimeContext, InternalRuntimeContext, RuntimePlugin, } from './runtime';
+export type { AsyncHook, CollectAsyncHook, PluginHook, PluginHookTap, } from './hooks';

package/dist/types/types/plugin.d.ts

@@ -0,0 +1,46 @@
+import type { PluginHook } from './hooks';
+import type { Falsy } from './utils';
+import type { MaybePromise } from './utils';
+export type TransformFunction<T> = (arg: T) => T | Promise<T>;
+export type Plugin<PluginAPI = {}, Context = {}> = {
+    /**
+     * The name of the plugin, a unique identifier.
+     */
+    name: string;
+    /**
+     * The plugins that this plugin depends on.
+     */
+    usePlugins?: Plugin<PluginAPI, Context>[];
+    /**
+     * The plugins add new hooks to the plugin manager.
+     */
+    registryHooks?: Record<string, PluginHook<(...args: any[]) => any>>;
+    /**
+     * The plugins add new apis to the plugin manager.
+     */
+    _registryApi?: (...params: any[]) => Record<string, (...args: any[]) => any>;
+    /**
+     * The setup function of the plugin, which can be an async function.
+     * This function is called once when the plugin is initialized.
+     * @param api provides the context info, utility functions and lifecycle hooks.
+     */
+    setup?: (api: PluginAPI) => MaybePromise<void>;
+    /**
+     * Declare the names of pre-plugins, which will be executed before the current plugin.
+     */
+    pre?: string[];
+    /**
+     * Declare the names of post-plugins, which will be executed after the current plugin.
+     */
+    post?: string[];
+    /**
+     * Declare the names of required plugins, which will check if the plugin is added.
+     */
+    required?: string[];
+};
+export type PluginManager = {
+    getPlugins: () => Plugin[];
+    addPlugins: (plugins: Array<Plugin | Falsy>) => void;
+    clear: () => void;
+    isPluginExists: (name: string) => boolean;
+};

package/dist/types/types/runtime/api.d.ts

@@ -0,0 +1,22 @@
+import type { PluginHook, PluginHookTap } from '../hooks';
+import type { DeepPartial } from '../utils';
+import type { RuntimeContext } from './context';
+import type { Hooks } from './hooks';
+import type { ConfigFn, ExtendStreamSSRFn, ExtendStringSSRCollectorsFn, OnBeforeRenderFn, PickContextFn, StringSSRCollectorsInfo, WrapRootFn } from './hooks';
+import type { RuntimePluginExtends } from './plugin';
+export type RuntimePluginAPI<Extends extends RuntimePluginExtends> = Readonly<{
+    updateRuntimeContext: (updateContext: DeepPartial<RuntimeContext>) => void;
+    getHooks: () => Readonly<Hooks<Extends['config'], RuntimeContext & Extends['extendContext']> & Extends['extendHooks']>;
+    getRuntimeConfig: () => Readonly<Extends['config']>;
+    onBeforeRender: PluginHookTap<OnBeforeRenderFn<Extends['extendContext']>>;
+    wrapRoot: PluginHookTap<WrapRootFn>;
+    pickContext: PluginHookTap<PickContextFn<RuntimeContext>>;
+    config: PluginHookTap<ConfigFn<Extends['config']>>;
+    extendStringSSRCollectors: PluginHookTap<ExtendStringSSRCollectorsFn<StringSSRCollectorsInfo>>;
+    extendStreamSSR: PluginHookTap<ExtendStreamSSRFn>;
+} & RuntimePluginExtendsAPI<Extends>>;
+export type RuntimePluginExtendsAPI<Extends extends RuntimePluginExtends> = {
+    [K in keyof Extends['extendHooks']]: PluginHookTap<Extends['extendHooks'][K] extends PluginHook<infer Args> ? Args extends (...args: any[]) => any ? Args : (...args: any[]) => any : (...args: any[]) => any>;
+} & Extends['extendApi'];
+export type AllKeysForRuntimePluginExtendsAPI<Extends extends RuntimePluginExtends> = keyof RuntimePluginExtendsAPI<Extends>;
+export type AllValueForRuntimePluginExtendsAPI<Extends extends RuntimePluginExtends> = RuntimePluginExtendsAPI<Extends>[AllKeysForRuntimePluginExtendsAPI<Extends>];

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

@@ -0,0 +1,13 @@
+import type { RuntimePluginAPI } from './api';
+import type { Hooks } from './hooks';
+import type { RuntimePluginExtends } from './plugin';
+export type RuntimeContext = {};
+export type InternalRuntimeContext<Extends extends RuntimePluginExtends> = RuntimeContext & {
+    /** All hooks. */
+    hooks: Hooks<Extends['config'], RuntimeContext & Extends['extendContext']> & Extends['extendHooks'];
+    /** All plugin registry hooks */
+    extendsHooks: Extends['extendHooks'];
+    config: Extends['config'];
+    pluginAPI?: RuntimePluginAPI<Extends>;
+    _internalContext?: InternalRuntimeContext<Extends>;
+};

package/dist/types/types/runtime/hooks.d.ts

@@ -0,0 +1,39 @@
+export type HandleRequestConfig = Record<string, any>;
+export type ChunkSet = {
+    renderLevel: any;
+    ssrScripts: string;
+    jsChunk: string;
+    cssChunk: string;
+};
+export type Collector = {
+    collect?: (component: React.ReactElement) => React.ReactElement;
+    effect: () => void | Promise<void>;
+};
+import type React from 'react';
+import type { AsyncInterruptHook, CollectSyncHook, SyncHook } from '../hooks';
+export type OnBeforeRenderFn<RuntimeContext> = (context: RuntimeContext, interrupt: (info: any) => any) => Promise<any> | any;
+export type ExtendStringSSRCollectorsFn<RuntimeContext> = (context: RuntimeContext) => Collector;
+export type StringSSRCollectorsInfo = {
+    chunkSet: ChunkSet;
+};
+export interface StreamSSRExtender {
+    init?: (params: {
+        rootElement: React.ReactElement;
+        forceStream2String: boolean;
+    }) => void;
+    modifyRootElement?: (rootElement: React.ReactElement) => React.ReactElement;
+    getStyleTags?: () => string;
+    processStream?: (stream: NodeJS.ReadWriteStream) => NodeJS.ReadWriteStream;
+}
+export type ExtendStreamSSRFn = () => StreamSSRExtender;
+export type WrapRootFn = (root: React.ComponentType<any>) => React.ComponentType<any>;
+export type PickContextFn<RuntimeContext> = (context: RuntimeContext) => RuntimeContext;
+export type ConfigFn<RuntimeConfig> = () => RuntimeConfig;
+export type Hooks<RuntimeConfig, RuntimeContext> = {
+    onBeforeRender: AsyncInterruptHook<OnBeforeRenderFn<RuntimeContext>>;
+    wrapRoot: SyncHook<WrapRootFn>;
+    pickContext: SyncHook<PickContextFn<RuntimeContext>>;
+    config: CollectSyncHook<ConfigFn<RuntimeConfig>>;
+    extendStringSSRCollectors: CollectSyncHook<ExtendStringSSRCollectorsFn<StringSSRCollectorsInfo>>;
+    extendStreamSSR: CollectSyncHook<ExtendStreamSSRFn>;
+};

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

@@ -0,0 +1,4 @@
+export type { RuntimePluginAPI } from './api';
+export type { RuntimeContext, InternalRuntimeContext } from './context';
+export type { RuntimePlugin, RuntimePluginExtends } from './plugin';
+export type { Hooks } from './hooks';

package/dist/types/types/runtime/plugin.d.ts

@@ -0,0 +1,14 @@
+import type { PluginHook } from '../hooks';
+import type { Plugin } from '../plugin';
+import type { RuntimePluginAPI } from './api';
+import type { RuntimeContext } from './context';
+export interface RuntimePluginExtends<Config extends Record<string, any> = {}, ExtendContext extends Record<string, any> = {}, ExtendAPI extends Record<string, any> = {}, ExtendHook extends Record<string, PluginHook<(...args: any[]) => any>> = {}> {
+    config?: Config;
+    extendContext?: ExtendContext;
+    extendApi?: ExtendAPI;
+    extendHooks?: ExtendHook;
+}
+/**
+ * The type of the Runtime plugin object.
+ */
+export type RuntimePlugin<Extends extends RuntimePluginExtends> = Plugin<RuntimePluginAPI<Extends> & Extends['extendApi'], RuntimeContext & Extends['extendContext']>;

package/dist/types/types/server/api.d.ts

@@ -0,0 +1,19 @@
+import type { PluginHook, PluginHookTap } from '../hooks';
+import type { DeepPartial } from '../utils';
+import type { ServerContext } from './context';
+import type { Hooks, ModifyConfigFn, OnPrepareFn, OnResetFn } from './hooks';
+import type { ServerPluginExtends } from './plugin';
+export type ServerPluginAPI<Extends extends ServerPluginExtends> = Readonly<{
+    getServerContext: () => Readonly<ServerContext<Extends> & Extends['extendContext']>;
+    updateServerContext: (updateContext: DeepPartial<ServerContext<Extends> & Extends['extendContext']>) => void;
+    getHooks: () => Readonly<Hooks<Extends['config']> & Extends['extendHooks']>;
+    getServerConfig: () => Readonly<Extends['config']>;
+    modifyConfig: PluginHookTap<ModifyConfigFn<Extends['config']>>;
+    onPrepare: PluginHookTap<OnPrepareFn>;
+    onReset: PluginHookTap<OnResetFn>;
+} & ServerPluginExtendsAPI<Extends>>;
+export type ServerPluginExtendsAPI<Extends extends ServerPluginExtends> = {
+    [K in keyof Extends['extendHooks']]: PluginHookTap<Extends['extendHooks'][K] extends PluginHook<infer Args> ? Args extends (...args: any[]) => any ? Args : (...args: any[]) => any : (...args: any[]) => any>;
+} & Extends['extendApi'];
+export type AllKeysForServerPluginExtendsAPI<Extends extends ServerPluginExtends> = keyof ServerPluginExtendsAPI<Extends>;
+export type AllValueForServerPluginExtendsAPI<Extends extends ServerPluginExtends> = ServerPluginExtendsAPI<Extends>[AllKeysForServerPluginExtendsAPI<Extends>];

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

@@ -0,0 +1,28 @@
+import type { ServerRoute } from '@modern-js/types';
+import type { ServerPluginAPI } from './api';
+import type { Hooks } from './hooks';
+import type { ServerPlugin, ServerPluginExtends } from './plugin';
+export interface Middleware {
+    name: string;
+}
+export type ServerContext<Extends extends ServerPluginExtends> = {
+    middlewares: Middleware[];
+    routes: ServerRoute[];
+    appDirectory: string;
+    apiDirectory?: string;
+    lambdaDirectory?: string;
+    internalDirectory?: string;
+    sharedDirectory?: string;
+    distDirectory?: string;
+    metaName: string;
+    plugins: ServerPlugin<Extends>[];
+};
+export type InternalServerContext<Extends extends ServerPluginExtends> = ServerContext<Extends> & {
+    /** All hooks. */
+    hooks: Hooks<Extends['config']> & Extends['extendHooks'];
+    /** All plugin registry hooks */
+    extendsHooks: Extends['extendHooks'];
+    config: Extends['config'];
+    pluginAPI?: ServerPluginAPI<Extends>;
+    _internalContext?: InternalServerContext<Extends>;
+};

package/dist/types/types/server/hooks.d.ts

@@ -0,0 +1,24 @@
+import type { AsyncHook } from '../hooks';
+export type ModifyConfigFn<ServerConfig> = (arg: ServerConfig) => ServerConfig | Promise<ServerConfig>;
+export type OnPrepareFn = () => Promise<void> | void;
+export type ChangeEvent = 'add' | 'change' | 'unlink';
+export interface Change {
+    filename: string;
+    event: ChangeEvent;
+}
+export interface RepackEvent {
+    type: 'repack';
+}
+export interface FileChangeEvent {
+    type: 'file-change';
+    payload: Change[];
+}
+export type ResetEvent = RepackEvent | FileChangeEvent;
+export type OnResetFn = (params: {
+    event: ResetEvent;
+}) => Promise<void> | void;
+export type Hooks<ServerConfig> = {
+    modifyConfig: AsyncHook<ModifyConfigFn<ServerConfig>>;
+    onPrepare: AsyncHook<OnPrepareFn>;
+    onReset: AsyncHook<OnResetFn>;
+};

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

@@ -0,0 +1,4 @@
+export type { ServerPluginAPI } from './api';
+export type { ServerContext, InternalServerContext } from './context';
+export type { ServerPlugin, ServerPluginExtends } from './plugin';
+export type { Hooks, FileChangeEvent, ResetEvent } from './hooks';

package/dist/types/types/server/plugin.d.ts

@@ -0,0 +1,14 @@
+import type { PluginHook } from '../hooks';
+import type { Plugin } from '../plugin';
+import type { ServerPluginAPI } from './api';
+import type { ServerContext } from './context';
+export interface ServerPluginExtends<Config extends Record<string, any> = {}, ExtendContext extends Record<string, any> = {}, ExtendAPI extends Record<string, any> = {}, ExtendHook extends Record<string, PluginHook<(...args: any[]) => any>> = {}> {
+    config?: Config;
+    extendContext?: ExtendContext;
+    extendApi?: ExtendAPI;
+    extendHooks?: ExtendHook;
+}
+/**
+ * The type of the Server plugin object.
+ */
+export type ServerPlugin<Extends extends ServerPluginExtends> = Plugin<ServerPluginAPI<Extends> & Extends['extendApi'], ServerContext<Extends> & Extends['extendContext']>;

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

@@ -0,0 +1,7 @@
+export type Falsy = false | null | undefined;
+export type MaybePromise<T> = T | Promise<T>;
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
+export type Tail<T extends any[]> = T extends [...infer Rest, any] ? Rest : never;

package/package.json

@@ -15,33 +15,88 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.69.5",
+  "version": "3.0.0-alpha.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
+  "module": "./dist/esm-node/index.mjs",
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
       "node": {
+        "modern:source": "./src/index.ts",
         "jsnext:source": "./src/index.ts",
-        "import": "./dist/esm-node/index.js",
+        "import": "./dist/esm/index.mjs",
         "require": "./dist/cjs/index.js"
       },
-      "default": "./dist/esm/index.js"
+      "default": "./dist/esm/index.mjs"
+    },
+    "./run": {
+      "types": "./dist/types/cli/run/index.d.ts",
+      "jsnext:source": "./src/cli/run/index.ts",
+      "default": "./dist/cjs/cli/run/index.js"
+    },
+    "./cli": {
+      "types": "./dist/types/cli/index.d.ts",
+      "modern:source": "./src/cli/index.ts",
+      "jsnext:source": "./src/cli/index.ts",
+      "default": "./dist/cjs/cli/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/types/runtime/index.d.ts",
+      "modern:source": "./src/runtime/index.tsx",
+      "jsnext:source": "./src/runtime/index.tsx",
+      "node": {
+        "import": "./dist/esm/runtime/index.mjs",
+        "require": "./dist/cjs/runtime/index.js"
+      },
+      "default": "./dist/esm/runtime/index.mjs"
+    },
+    "./server": {
+      "types": "./dist/types/server/index.d.ts",
+      "modern:source": "./src/server/index.ts",
+      "jsnext:source": "./src/server/index.ts",
+      "node": {
+        "require": "./dist/cjs/server/index.js",
+        "default": "./dist/cjs/server/index.js"
+      },
+      "default": "./dist/esm/server/index.mjs"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ],
+      "run": [
+        "./dist/types/cli/run/index.d.ts"
+      ],
+      "cli": [
+        "./dist/types/cli/index.d.ts"
+      ],
+      "runtime": [
+        "./dist/types/runtime/index.d.ts"
+      ],
+      "server": [
+        "./dist/types/server/index.d.ts"
+      ]
     }
   },
   "dependencies": {
     "@swc/helpers": "^0.5.17",
-    "@modern-js/utils": "2.69.5"
+    "jiti": "1.21.7",
+    "@rsbuild/core": "1.6.15",
+    "@modern-js/runtime-utils": "3.0.0-alpha.0",
+    "@modern-js/utils": "3.0.0-alpha.0",
+    "@modern-js/types": "3.0.0-alpha.0"
   },
   "devDependencies": {
-    "@types/jest": "^29",
-    "@types/node": "^18",
-    "jest": "^29",
+    "@types/node": "^20",
+    "@types/react": "^19.2.7",
+    "@rslib/core": "0.18.5",
     "typescript": "^5",
-    "@scripts/jest-config": "2.66.0",
-    "@scripts/build": "2.66.0"
+    "@modern-js/builder": "3.0.0-alpha.0",
+    "@modern-js/rslib": "2.68.10"
   },
   "sideEffects": false,
   "publishConfig": {
@@ -49,9 +104,8 @@
     "access": "public"
   },
   "scripts": {
-    "new": "modern-lib new",
-    "dev": "modern-lib build --watch",
-    "build": "modern-lib build",
-    "test": "jest --passWithNoTests"
+    "dev": "rslib build --watch",
+    "build": "rslib build",
+    "test": "rstest"
   }
 }

package/rslib.config.mts

@@ -0,0 +1,4 @@
+import { rslibConfig } from '@modern-js/rslib';
+import { defineConfig } from '@rslib/core';
+
+export default defineConfig(rslibConfig);

package/rstest.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig } from '@rstest/core';
+
+export default defineConfig({
+  globals: true,
+});