@modern-js/plugin 2.69.7 → 3.0.0-alpha.1

package/dist/esm-node/runtime/run/create.mjs

@@ -0,0 +1,45 @@
+import { merge } from "@modern-js/runtime-utils/merge";
+import { createPluginManager } from "../../manager.mjs";
+import { initPluginAPI } from "../api.mjs";
+import { createRuntimeContext, initRuntimeContext } from "../context.mjs";
+const createRuntime = ()=>{
+    let initOptions;
+    const pluginManager = createPluginManager();
+    function init(options) {
+        pluginManager.clear();
+        initOptions = options;
+        const { plugins: allPlugins, handleSetupResult } = options;
+        pluginManager.addPlugins(allPlugins);
+        const plugins = pluginManager.getPlugins();
+        const context = createRuntimeContext({
+            runtimeContext: initRuntimeContext(),
+            config: initOptions.config,
+            plugins
+        });
+        const pluginAPI = initPluginAPI({
+            context,
+            pluginManager,
+            plugins
+        });
+        context.pluginAPI = pluginAPI;
+        for (const plugin of plugins){
+            const setupResult = plugin.setup?.(pluginAPI);
+            if (handleSetupResult) handleSetupResult(setupResult, pluginAPI);
+        }
+        return {
+            runtimeContext: context
+        };
+    }
+    function run(options) {
+        const { runtimeContext } = init(options);
+        const configs = runtimeContext.hooks.config.call().filter((config)=>Boolean(config));
+        runtimeContext.config = merge({}, ...configs, runtimeContext.config || {});
+        return {
+            runtimeContext
+        };
+    }
+    return {
+        run
+    };
+};
+export { createRuntime };

package/dist/esm-node/runtime/run/index.mjs

@@ -0,0 +1,3 @@
+import { createRuntime } from "./create.mjs";
+const runtime = createRuntime();
+export { runtime };

package/dist/esm-node/server/api.mjs

@@ -0,0 +1,59 @@
+import { createDebugger } from "@modern-js/utils";
+import { assign as lodash_assign } from "@modern-js/utils/lodash";
+const debug = createDebugger('plugin-server-v2');
+function initPluginAPI({ context, pluginManager }) {
+    const { hooks, extendsHooks, plugins } = context;
+    function getServerContext() {
+        if (context) {
+            const { hooks, extendsHooks, config, pluginAPI, ...serverContext } = context;
+            serverContext._internalContext = context;
+            return serverContext;
+        }
+        throw new Error('Cannot access context');
+    }
+    function getConfig() {
+        if (context.config) return context.config;
+        throw new Error('Cannot access config');
+    }
+    function getHooks() {
+        return context.hooks;
+    }
+    const extendsPluginApi = {};
+    plugins.forEach((plugin)=>{
+        const { _registryApi } = plugin;
+        if (_registryApi) {
+            const apis = _registryApi(getServerContext, updateServerContext);
+            Object.keys(apis).forEach((apiName)=>{
+                extendsPluginApi[apiName] = apis[apiName];
+            });
+        }
+    });
+    if (extendsHooks) Object.keys(extendsHooks).forEach((hookName)=>{
+        extendsPluginApi[hookName] = extendsHooks[hookName].tap;
+    });
+    function updateServerContext(updateContext) {
+        context = lodash_assign(context, updateContext);
+    }
+    const pluginAPI = {
+        isPluginExists: pluginManager.isPluginExists,
+        getServerContext,
+        getServerConfig: getConfig,
+        getHooks,
+        updateServerContext,
+        modifyConfig: hooks.modifyConfig.tap,
+        onPrepare: hooks.onPrepare.tap,
+        onReset: hooks.onReset.tap,
+        ...extendsPluginApi
+    };
+    if ("u" < typeof Proxy) return pluginAPI;
+    return new Proxy(pluginAPI, {
+        get (target, prop) {
+            if ('then' === prop) return;
+            if (prop in target) return target[prop];
+            return ()=>{
+                debug(`api.${prop.toString()} not exist`);
+            };
+        }
+    });
+}
+export { debug, initPluginAPI };

package/dist/esm-node/server/context.mjs

@@ -0,0 +1,38 @@
+import { initHooks } from "./hooks.mjs";
+function initServerContext(params) {
+    const { options, plugins } = params;
+    return {
+        routes: options.routes || [],
+        appDirectory: options.appContext.appDirectory || '',
+        apiDirectory: options.appContext.apiDirectory,
+        lambdaDirectory: options.appContext.lambdaDirectory,
+        internalDirectory: options.appContext.internalDirectory || '',
+        sharedDirectory: options.appContext.sharedDirectory || '',
+        distDirectory: options.pwd,
+        metaName: options.metaName || 'modern-js',
+        plugins: plugins,
+        middlewares: [],
+        bffRuntimeFramework: options.appContext.bffRuntimeFramework,
+        renderMiddlewares: []
+    };
+}
+function createServerContext({ serverContext, config }) {
+    const { plugins } = serverContext;
+    const extendsHooks = {};
+    plugins.forEach((plugin)=>{
+        const { registryHooks = {} } = plugin;
+        Object.keys(registryHooks).forEach((hookName)=>{
+            extendsHooks[hookName] = registryHooks[hookName];
+        });
+    });
+    return {
+        ...serverContext,
+        hooks: {
+            ...initHooks(),
+            ...extendsHooks
+        },
+        extendsHooks,
+        config
+    };
+}
+export { createServerContext, initServerContext };

package/dist/esm-node/server/hooks.mjs

@@ -0,0 +1,9 @@
+import { createAsyncHook } from "../hooks.mjs";
+function initHooks() {
+    return {
+        modifyConfig: createAsyncHook(),
+        onPrepare: createAsyncHook(),
+        onReset: createAsyncHook()
+    };
+}
+export { initHooks };

package/dist/esm-node/server/index.mjs

@@ -0,0 +1,5 @@
+import { initPluginAPI } from "./api.mjs";
+import { createServerContext, initServerContext } from "./context.mjs";
+import { initHooks } from "./hooks.mjs";
+import { createServer, server } from "./run/index.mjs";
+export { createServer, createServerContext, initHooks, initPluginAPI, initServerContext, server };

package/dist/esm-node/server/run/create.mjs

@@ -0,0 +1,45 @@
+import { createPluginManager } from "../../manager.mjs";
+import { initPluginAPI } from "../api.mjs";
+import { createServerContext, initServerContext } from "../context.mjs";
+const createServer = ()=>{
+    let initOptions;
+    const pluginManager = createPluginManager();
+    function init(options) {
+        pluginManager.clear();
+        initOptions = options;
+        const { plugins: allPlugins, options: runOptions, handleSetupResult } = initOptions;
+        pluginManager.addPlugins(allPlugins);
+        const plugins = pluginManager.getPlugins();
+        const context = createServerContext({
+            serverContext: initServerContext({
+                plugins,
+                options: runOptions
+            }),
+            config: initOptions.config
+        });
+        const pluginAPI = initPluginAPI({
+            context,
+            pluginManager
+        });
+        context.pluginAPI = pluginAPI;
+        for (const plugin of plugins){
+            const setupResult = plugin.setup?.(pluginAPI);
+            if (handleSetupResult) handleSetupResult(setupResult, pluginAPI);
+        }
+        return {
+            serverContext: context
+        };
+    }
+    async function run(options) {
+        const { serverContext } = init(options);
+        const config = await serverContext.hooks.modifyConfig.call(serverContext.config);
+        serverContext.config = config;
+        return {
+            serverContext
+        };
+    }
+    return {
+        run
+    };
+};
+export { createServer };

package/dist/esm-node/server/run/index.mjs

@@ -0,0 +1,3 @@
+import { createServer } from "./create.mjs";
+const server = createServer();
+export { createServer, server };

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

@@ -0,0 +1,8 @@
+import type { CLIPluginAPI } from '../types/cli/api';
+import type { InternalContext } from '../types/cli/context';
+import type { CLIPluginExtends } from '../types/cli/plugin';
+import type { PluginManager } from '../types/plugin';
+export declare function initPluginAPI<Extends extends CLIPluginExtends>({ context, pluginManager, }: {
+    context: InternalContext<Extends>;
+    pluginManager: PluginManager;
+}): CLIPluginAPI<Extends>;

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

@@ -0,0 +1,19 @@
+import type { AppContext, InternalContext } from '../types/cli/context';
+import type { CLIPlugin, CLIPluginExtends } from '../types/cli/plugin';
+interface ContextParams<Extends extends CLIPluginExtends> {
+    appContext: AppContext<Extends>;
+    config: Extends['config'];
+    normalizedConfig: Extends['normalizedConfig'];
+}
+export declare function initAppContext<Extends extends CLIPluginExtends>(params: {
+    packageName: string;
+    configFile: string;
+    command: string;
+    appDirectory: string;
+    metaName: string;
+    plugins: CLIPlugin<Extends>[];
+    srcDir?: string;
+    distDir?: string;
+}): AppContext<Extends>;
+export declare function createContext<Extends extends CLIPluginExtends>({ appContext, config, normalizedConfig, }: ContextParams<Extends>): Promise<InternalContext<Extends>>;
+export {};

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

@@ -0,0 +1,42 @@
+import type { OnAfterBuildFn, OnAfterCreateCompilerFn, OnBeforeBuildFn, OnBeforeCreateCompilerFn, OnDevCompileDoneFn } from '@rsbuild/core';
+import type { AddCommandFn, AddWatchFilesFn, ConfigFn, InternalRuntimePluginsFn, InternalServerPluginsFn, ModifyBundlerChainFn, ModifyConfigFn, ModifyHtmlPartialsFn, ModifyResolvedConfigFn, ModifyRsbuildConfigFn, ModifyRspackConfigFn, ModifyServerRoutesFn, OnAfterDeployFn, OnAfterDevFn, OnBeforeDeployFn, OnBeforeDevFn, OnBeforeExitFn, OnBeforeRestartFn, OnFileChangedFn, OnPrepareFn, RuntimePluginConfig, ServerPluginConfig } from '../types/cli/hooks';
+import type { DeepPartial } from '../types/utils';
+export type { OnAfterBuildFn, OnAfterCreateCompilerFn, OnBeforeBuildFn, OnBeforeCreateCompilerFn, OnDevCompileDoneFn, AddCommandFn, AddWatchFilesFn, ConfigFn, ModifyBundlerChainFn, ModifyConfigFn, ModifyHtmlPartialsFn, ModifyResolvedConfigFn, ModifyRsbuildConfigFn, ModifyRspackConfigFn, OnAfterDeployFn, OnBeforeDeployFn, OnBeforeDevFn, OnAfterDevFn, OnBeforeExitFn, OnBeforeRestartFn, OnFileChangedFn, OnPrepareFn, InternalRuntimePluginsFn, InternalServerPluginsFn, ModifyServerRoutesFn, RuntimePluginConfig, ServerPluginConfig, };
+export declare function initHooks<Config, NormalizedConfig, ExtendBuildUtils, ExtendConfigUtils>(): {
+    /**
+     * add config for this cli plugin
+     */
+    config: import("..").CollectAsyncHook<ConfigFn<DeepPartial<Config>>>;
+    /**
+     * @private
+     * modify config for this cli plugin
+     */
+    modifyConfig: import("..").AsyncHook<ModifyConfigFn<Config, ExtendConfigUtils>>;
+    /**
+     * modify final config
+     */
+    modifyResolvedConfig: import("..").AsyncHook<ModifyResolvedConfigFn<NormalizedConfig, ExtendConfigUtils>>;
+    modifyRsbuildConfig: import("..").AsyncHook<ModifyRsbuildConfigFn<ExtendBuildUtils>>;
+    modifyBundlerChain: import("..").AsyncHook<ModifyBundlerChainFn<ExtendBuildUtils>>;
+    modifyRspackConfig: import("..").AsyncHook<ModifyRspackConfigFn<ExtendBuildUtils>>;
+    modifyHtmlPartials: import("..").AsyncHook<ModifyHtmlPartialsFn>;
+    addCommand: import("..").AsyncHook<AddCommandFn>;
+    addWatchFiles: import("..").CollectAsyncHook<AddWatchFilesFn>;
+    onPrepare: import("..").AsyncHook<OnPrepareFn>;
+    onFileChanged: import("..").AsyncHook<OnFileChangedFn>;
+    onBeforeRestart: import("..").AsyncHook<OnBeforeRestartFn>;
+    onBeforeCreateCompiler: import("..").AsyncHook<OnBeforeCreateCompilerFn>;
+    onAfterCreateCompiler: import("..").AsyncHook<OnAfterCreateCompilerFn>;
+    onDevCompileDone: import("..").AsyncHook<import("@rsbuild/core").OnAfterDevCompileFn>;
+    onBeforeBuild: import("..").AsyncHook<OnBeforeBuildFn>;
+    onAfterBuild: import("..").AsyncHook<OnAfterBuildFn>;
+    onBeforeDev: import("..").AsyncHook<OnBeforeDevFn>;
+    onAfterDev: import("..").AsyncHook<OnAfterDevFn>;
+    onBeforeDeploy: import("..").AsyncHook<OnBeforeDeployFn>;
+    onAfterDeploy: import("..").AsyncHook<OnAfterDeployFn>;
+    onBeforeExit: import("..").AsyncHook<OnBeforeExitFn>;
+    _internalRuntimePlugins: import("..").AsyncHook<InternalRuntimePluginsFn>;
+    _internalServerPlugins: import("..").AsyncHook<InternalServerPluginsFn>;
+    modifyServerRoutes: import("..").AsyncHook<ModifyServerRoutesFn>;
+};
+export type Hooks<Config, NormalizedConfig, ExtendBuildUtils, ExtendConfigUtils> = ReturnType<typeof initHooks<Config, NormalizedConfig, ExtendBuildUtils, ExtendConfigUtils>>;

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

@@ -0,0 +1,6 @@
+export { initPluginAPI } from './api';
+export { initAppContext, createContext } from './context';
+export { initHooks, type Hooks, type OnAfterBuildFn, type OnAfterCreateCompilerFn, type OnBeforeBuildFn, type OnBeforeCreateCompilerFn, type OnDevCompileDoneFn, type AddCommandFn, type AddWatchFilesFn, type ConfigFn, type ModifyBundlerChainFn, type ModifyConfigFn, type ModifyHtmlPartialsFn, type ModifyResolvedConfigFn, type ModifyRsbuildConfigFn, type ModifyRspackConfigFn, type OnAfterDeployFn, type OnBeforeDeployFn, type OnBeforeDevFn, type OnAfterDevFn, type OnBeforeExitFn, type OnBeforeRestartFn, type OnFileChangedFn, type OnPrepareFn, type InternalRuntimePluginsFn, type InternalServerPluginsFn, type ModifyServerRoutesFn, type RuntimePluginConfig, type ServerPluginConfig, } from './hooks';
+export { cli, createLoadedConfig, initAppDir, createCli } from './run';
+export { createStorybookOptions } from './run/create';
+export { mergeConfig } from './run/utils/mergeConfig';

package/dist/types/cli/run/config/createLoadedConfig.d.ts

@@ -0,0 +1,2 @@
+import type { LoadedConfig } from '../types';
+export declare function createLoadedConfig<T>(appDirectory: string, configFilePath: string, otherConfig?: T): Promise<LoadedConfig<T>>;

package/dist/types/cli/run/config/createResolvedConfig.d.ts

@@ -0,0 +1,3 @@
+import type { DeepPartial } from '../../../types/utils';
+import type { LoadedConfig } from '../types';
+export declare const createResolveConfig: <Config, NormalizedConfig>(loaded: LoadedConfig<Config>, configs: DeepPartial<Config>[]) => Promise<NormalizedConfig>;

package/dist/types/cli/run/config/loadConfig.d.ts

@@ -0,0 +1,25 @@
+export declare const getConfigFilePath: (appDirectory: string, configFilePath: string) => string;
+/**
+ *
+ * @param targetDir target dir
+ * @param overtime Unit of second
+ */
+export declare const clearFilesOverTime: (targetDir: string, overtime: number) => Promise<void>;
+/**
+ * Parse and load user config file, support extensions like .ts, mjs, js, ejs.
+ * @param appDirectory - App root directory, from which start search user config file.
+ * @param configFile - Specific absolute config file path.
+ * @returns Object contain config file path, user config object and dependency files used by config file.
+ */
+/**
+ * Load a TypeScript file dynamically using jiti
+ * @param {string} filePath - Path to the TypeScript file (absolute or relative)
+ * @returns {any} - The loaded module object
+ */
+export declare const loadTypeScriptFile: (filePath: string) => any;
+export declare const loadConfig: <T>(appDirectory: string, configFile: string) => Promise<{
+    packageName: string;
+    configFile: string;
+    config?: T;
+    pkgConfig?: T;
+}>;

package/dist/types/cli/run/create.d.ts

@@ -0,0 +1,16 @@
+import type { InternalContext } from '../../types/cli/context';
+import type { CLIPluginExtends } from '../../types/cli/plugin';
+import type { CLIRunOptions } from './types';
+export declare const createCli: <Extends extends CLIPluginExtends>() => {
+    init: (options: CLIRunOptions<Extends>) => Promise<{
+        appContext: InternalContext<Extends>;
+    }>;
+    run: (options: CLIRunOptions<Extends>) => Promise<void>;
+    getPrevInitOptions: () => CLIRunOptions<Extends>;
+};
+type UselessOptions = 'handleSetupResult' | 'command' | 'internalPlugins';
+export declare const createStorybookOptions: <Extends extends CLIPluginExtends>(options: Omit<CLIRunOptions<Extends>, UselessOptions>) => Promise<{
+    config: Awaited<Extends["normalizedConfig"]> | NonNullable<Awaited<import("../../types/utils").UnwrapPromise<Extends["normalizedConfig"]>>>;
+    getAppContext: () => Readonly<import("../../types/cli/context").AppContext<Extends> & Extends["extendContext"]>;
+}>;
+export {};

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

@@ -0,0 +1,13 @@
+import { createCli } from './create';
+export { createLoadedConfig } from './config/createLoadedConfig';
+export { initAppDir } from './utils/initAppDir';
+export { loadTypeScriptFile } from './config/loadConfig';
+export { createCli };
+export { run } from './run';
+export declare const cli: {
+    init: (options: import("./types").CLIRunOptions<import("../..").CLIPluginExtends<{}, {}, {}, {}, {}, {}, {}>>) => Promise<{
+        appContext: import("../..").InternalContext<import("../..").CLIPluginExtends<{}, {}, {}, {}, {}, {}, {}>>;
+    }>;
+    run: (options: import("./types").CLIRunOptions<import("../..").CLIPluginExtends<{}, {}, {}, {}, {}, {}, {}>>) => Promise<void>;
+    getPrevInitOptions: () => import("./types").CLIRunOptions<import("../..").CLIPluginExtends<{}, {}, {}, {}, {}, {}, {}>>;
+};

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

@@ -0,0 +1,2 @@
+import type { CLIOptions } from './types';
+export declare const run: (options: CLIOptions) => Promise<void>;

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

@@ -0,0 +1,32 @@
+import type { CLIPluginExtends } from '../../types/cli';
+import type { Plugin } from '../../types/plugin';
+export interface CLIOptions<Extends extends CLIPluginExtends = {
+    config: {};
+}> {
+    cwd?: string;
+    version?: string;
+    metaName?: string;
+    /**
+     * The initial log message when CLI started
+     */
+    initialLog?: string;
+    /**
+     * other config, overrides config file content
+     */
+    config?: Extends['config'];
+    configFile: string;
+    internalPlugins?: Plugin[];
+    handleSetupResult?: (params: any, api: Record<string, any>) => Promise<void> | void;
+}
+export type LoadedConfig<T> = {
+    packageName: string;
+    configFile: string;
+    config: T;
+    pkgConfig?: T;
+    jsConfig?: T;
+};
+export interface CLIRunOptions<Extends extends CLIPluginExtends = {
+    config: {};
+}> extends CLIOptions<Extends> {
+    command: string;
+}

package/dist/types/cli/run/utils/checkIsDuplicationPlugin.d.ts

@@ -0,0 +1 @@
+export declare function checkIsDuplicationPlugin(plugins: (string | undefined)[]): void;

package/dist/types/cli/run/utils/commander.d.ts

@@ -0,0 +1,5 @@
+import { type Command, program } from '@modern-js/utils';
+export declare const setProgramVersion: (version?: string) => void;
+export declare function initCommandsMap(): void;
+export type { Command };
+export { program };

package/dist/types/cli/run/utils/createFileWatcher.d.ts

@@ -0,0 +1,3 @@
+import type { InternalContext } from '../../../types';
+import type { CLIPluginExtends } from '../../../types/cli/plugin';
+export declare const createFileWatcher: <Extends extends CLIPluginExtends>(appContext: InternalContext<Extends>) => Promise<import("@modern-js/utils").FSWatcher | undefined>;

package/dist/types/cli/run/utils/debug.d.ts

@@ -0,0 +1 @@
+export declare const debug: import("@modern-js/utils/compiled/debug").Debugger;

package/dist/types/cli/run/utils/initAppDir.d.ts

@@ -0,0 +1 @@
+export declare const initAppDir: (currentDir?: string) => Promise<string>;

package/dist/types/cli/run/utils/mergeConfig.d.ts

@@ -0,0 +1,2 @@
+import type { DeepPartial } from '../../../types/utils';
+export declare const mergeConfig: <Config, NormalizedConfig>(configs: Array<DeepPartial<Config>>) => NormalizedConfig;

package/dist/types/hooks.d.ts

@@ -0,0 +1,7 @@
+import type { AsyncHook, AsyncInterruptHook, AsyncPipelineHook, CollectAsyncHook, CollectSyncHook, SyncHook } from './types/hooks';
+export declare function createAsyncInterruptHook<Callback extends (...args: any[]) => any>(): AsyncInterruptHook<Callback>;
+export declare function createSyncHook<Callback extends (...args: any[]) => any>(): SyncHook<Callback>;
+export declare function createAsyncHook<Callback extends (...args: any[]) => any>(): AsyncHook<Callback>;
+export declare function createCollectAsyncHook<Callback extends (...params: any[]) => any>(): CollectAsyncHook<Callback>;
+export declare function createCollectSyncHook<Callback extends (...params: any[]) => any>(): CollectSyncHook<Callback>;
+export declare function createAsyncPipelineHook<Callback extends (...args: any[]) => any>(): AsyncPipelineHook<Callback>;

package/dist/types/index.d.ts

@@ -1,4 +1,7 @@
-export * from './farrow-pipeline';
-export * from './waterfall';
-export * from './workflow';
-export * from './manager';
+export { createPluginManager } from './manager';
+export { createSyncHook, createAsyncHook, createCollectSyncHook, createCollectAsyncHook, createAsyncInterruptHook, createAsyncPipelineHook, } from './hooks';
+export type { Plugin, PluginManager, TransformFunction, } from './types/plugin';
+export type { CLIPluginAPI, AppContext, InternalContext, Entrypoint, CLIPlugin, CLIPluginExtends, RuntimePluginConfig, ServerPluginConfig, } from './types/cli';
+export type { RuntimePluginAPI, RuntimeContext, InternalRuntimeContext, RuntimePlugin, RuntimePluginExtends, } from './types/runtime';
+export type { ServerPluginAPI, ServerContext, InternalServerContext, ServerPlugin, ServerPluginExtends, ResetEvent, FileChangeEvent, } from './types/server';
+export type { SyncHook, AsyncHook, AsyncInterruptHook, CollectAsyncHook, CollectSyncHook, PluginHook, PluginHookTap, AsyncPipelineHook, } from './types/hooks';

package/dist/types/manager.d.ts

@@ -0,0 +1,5 @@
+/**
+ * NOTE: This file will be used in both Node.js and runtime environments. Please avoid importing Node.js-specific APIs.
+ */
+import type { PluginManager } from './types/plugin';
+export declare function createPluginManager(): PluginManager;

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

@@ -0,0 +1,9 @@
+import type { PluginManager } from '../types/plugin';
+import type { RuntimePluginAPI } from '../types/runtime/api';
+import type { InternalRuntimeContext } from '../types/runtime/context';
+import type { RuntimePlugin, RuntimePluginExtends } from '../types/runtime/plugin';
+export declare function initPluginAPI<Extends extends RuntimePluginExtends>({ context, plugins, }: {
+    context: InternalRuntimeContext<Extends>;
+    pluginManager: PluginManager;
+    plugins: RuntimePlugin<Extends>[];
+}): RuntimePluginAPI<Extends>;

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

@@ -0,0 +1,11 @@
+import type { InternalRuntimeContext, RuntimeContext } from '../types/runtime/context';
+import type { RuntimePlugin, RuntimePluginExtends } from '../types/runtime/plugin';
+export interface RuntimeConfig<Extends extends RuntimePluginExtends> {
+    plugins?: RuntimePlugin<Extends>[];
+}
+export declare function initRuntimeContext(): RuntimeContext;
+export declare function createRuntimeContext<Extends extends RuntimePluginExtends>({ runtimeContext, config, plugins, }: {
+    runtimeContext: RuntimeContext & Extends['extendContext'];
+    config: Extends['config'];
+    plugins: RuntimePlugin<Extends>[];
+}): InternalRuntimeContext<Extends>;

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

@@ -0,0 +1,2 @@
+import type { Hooks } from '../types/runtime/hooks';
+export declare function initHooks<RuntimeConfig, RuntimeContext>(): Hooks<RuntimeConfig, RuntimeContext>;

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

@@ -0,0 +1,5 @@
+export { initPluginAPI } from './api';
+export { initRuntimeContext, createRuntimeContext } from './context';
+export { initHooks } from './hooks';
+export { runtime } from './run';
+export type { RuntimePluginAPI, RuntimeContext, InternalRuntimeContext, RuntimePlugin, RuntimePluginExtends, Hooks, } from '../types/runtime';

package/dist/types/runtime/run/create.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimePluginExtends } from '../../types/runtime/plugin';
+import type { RuntimeRunOptions } from './types';
+export declare const createRuntime: <Extends extends RuntimePluginExtends>() => {
+    run: (options: RuntimeRunOptions) => {
+        runtimeContext: import("..").InternalRuntimeContext<Extends>;
+    };
+};

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

@@ -0,0 +1,5 @@
+export declare const runtime: {
+    run: (options: import("./types").RuntimeRunOptions) => {
+        runtimeContext: import("..").InternalRuntimeContext<import("..").RuntimePluginExtends<{}, {}, {}, {}>>;
+    };
+};

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

@@ -0,0 +1,6 @@
+import type { Plugin } from '../../types/plugin';
+export type RuntimeRunOptions = {
+    config: Record<string, any>;
+    plugins: Plugin[];
+    handleSetupResult?: (params: any, api: Record<string, any>) => Promise<void> | void;
+};

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

@@ -0,0 +1,9 @@
+import type { PluginManager } from '../types/plugin';
+import type { ServerPluginAPI } from '../types/server/api';
+import type { InternalServerContext } from '../types/server/context';
+import type { ServerPluginExtends } from '../types/server/plugin';
+export declare const debug: import("@modern-js/utils/compiled/debug").Debugger;
+export declare function initPluginAPI<Extends extends ServerPluginExtends>({ context, pluginManager, }: {
+    context: InternalServerContext<Extends>;
+    pluginManager: PluginManager;
+}): ServerPluginAPI<Extends>;

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

@@ -0,0 +1,13 @@
+import type { InternalServerContext, ServerContext } from '../types/server/context';
+import type { ServerPlugin, ServerPluginExtends } from '../types/server/plugin';
+import type { ServerCreateOptions } from './run/types';
+interface ContextParams<Extends extends ServerPluginExtends> {
+    serverContext: ServerContext<Extends>;
+    config: Extends['config'];
+}
+export declare function initServerContext<Extends extends ServerPluginExtends>(params: {
+    options: ServerCreateOptions;
+    plugins: ServerPlugin<Extends>[];
+}): ServerContext<Extends> & Extends['extendContext'];
+export declare function createServerContext<Extends extends ServerPluginExtends>({ serverContext, config, }: ContextParams<Extends>): InternalServerContext<Extends>;
+export {};

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

@@ -0,0 +1,9 @@
+import type { ModifyConfigFn, OnPrepareFn, OnResetFn } from '../types/server/hooks';
+import type { DeepPartial } from '../types/utils';
+export type { OnResetFn, OnPrepareFn, ModifyConfigFn };
+export declare function initHooks<Config>(): {
+    modifyConfig: import("..").AsyncHook<ModifyConfigFn<DeepPartial<Config>>>;
+    onPrepare: import("..").AsyncHook<OnPrepareFn>;
+    onReset: import("..").AsyncHook<OnResetFn>;
+};
+export type Hooks<Config> = ReturnType<typeof initHooks<Config>>;

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

@@ -0,0 +1,4 @@
+export { initPluginAPI } from './api';
+export { initServerContext, createServerContext } from './context';
+export { initHooks, type Hooks, type OnPrepareFn, type ModifyConfigFn, type OnResetFn, } from './hooks';
+export { server, createServer, type ServerCreateOptions } from './run';

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

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