@modern-js/server-core 1.21.2-beta.1 → 1.21.2-beta.2

package/dist/js/modern/index.js

@@ -0,0 +1,3 @@
+export * from "./plugin";
+export * from '@modern-js/plugin';
+export * from "./loadPlugins";

package/dist/js/modern/loadPlugins.js

@@ -0,0 +1,47 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import { compatRequire, tryResolve } from '@modern-js/utils';
+import { createPlugin } from "./plugin";
+export const loadPlugins = (plugins, appDirectory) => {
+  const resolvePlugin = p => {
+    const isPluginInstance = typeof p !== 'string' && !Array.isArray(p);
+
+    if (isPluginInstance) {
+      return {
+        module: createPlugin(p.setup, p)
+      };
+    }
+
+    const [pkg, options] = typeof p === 'string' ? [p, undefined] : p;
+    const pluginPath = tryResolve(pkg, appDirectory);
+    let module = compatRequire(pluginPath);
+    const useNewSyntax = typeof module === 'function';
+
+    if (useNewSyntax) {
+      const plugin = module(options);
+      module = createPlugin(plugin.setup, plugin);
+    }
+
+    return {
+      pkg,
+      path: pluginPath,
+      module
+    };
+  };
+
+  return plugins.map(plugin => {
+    const {
+      pkg,
+      path,
+      module
+    } = resolvePlugin(plugin);
+    return _objectSpread(_objectSpread({}, module), {}, {
+      pluginPath: path,
+      pkg
+    });
+  });
+};

package/dist/js/modern/plugin.js

@@ -0,0 +1,95 @@
+import { createContext, createAsyncManager, createAsyncPipeline, createAsyncWaterfall, createParallelWorkflow, createWaterfall } from '@modern-js/plugin';
+// collect all middleware register in server plugins
+const gather = createParallelWorkflow();
+// config
+const config = createWaterfall();
+const prepare = createWaterfall();
+const create = createAsyncPipeline();
+const prepareWebServer = createAsyncPipeline();
+const prepareApiServer = createAsyncPipeline();
+const onApiChange = createWaterfall();
+const beforeDevServer = createParallelWorkflow();
+const setupCompiler = createParallelWorkflow();
+const afterDevServer = createParallelWorkflow(); // TODO FIXME
+
+const beforeRouteSet = createAsyncPipeline();
+const afterRouteSet = createAsyncPipeline();
+const beforeProdServer = createParallelWorkflow();
+const afterProdServer = createParallelWorkflow();
+const listen = createParallelWorkflow();
+const beforeServerReset = createParallelWorkflow();
+const afterServerReset = createParallelWorkflow();
+const extendSSRContext = createAsyncWaterfall();
+const extendContext = createAsyncPipeline();
+const handleError = createParallelWorkflow();
+const beforeMatch = createAsyncPipeline();
+const afterMatch = createAsyncPipeline(); // TODO FIXME
+
+const prefetch = createParallelWorkflow(); // TODO FIXME
+
+const renderToString = createAsyncPipeline();
+const beforeRender = createAsyncPipeline();
+const afterRender = createAsyncPipeline();
+const beforeSend = createAsyncPipeline();
+const afterSend = createParallelWorkflow();
+const reset = createParallelWorkflow();
+export const AppContext = createContext({});
+export const setAppContext = value => AppContext.set(value);
+export const ConfigContext = createContext({});
+/**
+ * Get original content of user config.
+ */
+
+export const useConfigContext = () => ConfigContext.use().value;
+/**
+ * Get app context, including directories, plugins and some static infos.
+ */
+
+export const useAppContext = () => AppContext.use().value;
+const pluginAPI = {
+  useAppContext,
+  useConfigContext,
+  setAppContext
+};
+const serverHooks = {
+  // server hook
+  gather,
+  config,
+  prepare,
+  create,
+  prepareWebServer,
+  prepareApiServer,
+  onApiChange,
+  beforeDevServer,
+  setupCompiler,
+  afterDevServer,
+  beforeRouteSet,
+  afterRouteSet,
+  beforeProdServer,
+  afterProdServer,
+  listen,
+  beforeServerReset,
+  afterServerReset,
+  // request hook
+  extendSSRContext,
+  extendContext,
+  handleError,
+  beforeMatch,
+  afterMatch,
+  prefetch,
+  renderToString,
+  beforeRender,
+  afterRender,
+  beforeSend,
+  afterSend,
+  reset
+};
+/** All hooks of server plugin. */
+
+export const createServerManager = () => createAsyncManager(serverHooks, pluginAPI);
+export const serverManager = createServerManager();
+/** Plugin options of a server plugin. */
+
+export const {
+  createPlugin
+} = serverManager;

package/dist/js/node/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _plugin = require("./plugin");
+
+Object.keys(_plugin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _plugin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _plugin[key];
+    }
+  });
+});
+
+var _plugin2 = require("@modern-js/plugin");
+
+Object.keys(_plugin2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _plugin2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _plugin2[key];
+    }
+  });
+});
+
+var _loadPlugins = require("./loadPlugins");
+
+Object.keys(_loadPlugins).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _loadPlugins[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _loadPlugins[key];
+    }
+  });
+});

package/dist/js/node/loadPlugins.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadPlugins = void 0;
+
+var _utils = require("@modern-js/utils");
+
+var _plugin = require("./plugin");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const loadPlugins = (plugins, appDirectory) => {
+  const resolvePlugin = p => {
+    const isPluginInstance = typeof p !== 'string' && !Array.isArray(p);
+
+    if (isPluginInstance) {
+      return {
+        module: (0, _plugin.createPlugin)(p.setup, p)
+      };
+    }
+
+    const [pkg, options] = typeof p === 'string' ? [p, undefined] : p;
+    const pluginPath = (0, _utils.tryResolve)(pkg, appDirectory);
+    let module = (0, _utils.compatRequire)(pluginPath);
+    const useNewSyntax = typeof module === 'function';
+
+    if (useNewSyntax) {
+      const plugin = module(options);
+      module = (0, _plugin.createPlugin)(plugin.setup, plugin);
+    }
+
+    return {
+      pkg,
+      path: pluginPath,
+      module
+    };
+  };
+
+  return plugins.map(plugin => {
+    const {
+      pkg,
+      path,
+      module
+    } = resolvePlugin(plugin);
+    return _objectSpread(_objectSpread({}, module), {}, {
+      pluginPath: path,
+      pkg
+    });
+  });
+};
+
+exports.loadPlugins = loadPlugins;

package/dist/js/node/plugin.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useConfigContext = exports.useAppContext = exports.setAppContext = exports.serverManager = exports.createServerManager = exports.createPlugin = exports.ConfigContext = exports.AppContext = void 0;
+
+var _plugin = require("@modern-js/plugin");
+
+// collect all middleware register in server plugins
+const gather = (0, _plugin.createParallelWorkflow)();
+// config
+const config = (0, _plugin.createWaterfall)();
+const prepare = (0, _plugin.createWaterfall)();
+const create = (0, _plugin.createAsyncPipeline)();
+const prepareWebServer = (0, _plugin.createAsyncPipeline)();
+const prepareApiServer = (0, _plugin.createAsyncPipeline)();
+const onApiChange = (0, _plugin.createWaterfall)();
+const beforeDevServer = (0, _plugin.createParallelWorkflow)();
+const setupCompiler = (0, _plugin.createParallelWorkflow)();
+const afterDevServer = (0, _plugin.createParallelWorkflow)(); // TODO FIXME
+
+const beforeRouteSet = (0, _plugin.createAsyncPipeline)();
+const afterRouteSet = (0, _plugin.createAsyncPipeline)();
+const beforeProdServer = (0, _plugin.createParallelWorkflow)();
+const afterProdServer = (0, _plugin.createParallelWorkflow)();
+const listen = (0, _plugin.createParallelWorkflow)();
+const beforeServerReset = (0, _plugin.createParallelWorkflow)();
+const afterServerReset = (0, _plugin.createParallelWorkflow)();
+const extendSSRContext = (0, _plugin.createAsyncWaterfall)();
+const extendContext = (0, _plugin.createAsyncPipeline)();
+const handleError = (0, _plugin.createParallelWorkflow)();
+const beforeMatch = (0, _plugin.createAsyncPipeline)();
+const afterMatch = (0, _plugin.createAsyncPipeline)(); // TODO FIXME
+
+const prefetch = (0, _plugin.createParallelWorkflow)(); // TODO FIXME
+
+const renderToString = (0, _plugin.createAsyncPipeline)();
+const beforeRender = (0, _plugin.createAsyncPipeline)();
+const afterRender = (0, _plugin.createAsyncPipeline)();
+const beforeSend = (0, _plugin.createAsyncPipeline)();
+const afterSend = (0, _plugin.createParallelWorkflow)();
+const reset = (0, _plugin.createParallelWorkflow)();
+const AppContext = (0, _plugin.createContext)({});
+exports.AppContext = AppContext;
+
+const setAppContext = value => AppContext.set(value);
+
+exports.setAppContext = setAppContext;
+const ConfigContext = (0, _plugin.createContext)({});
+/**
+ * Get original content of user config.
+ */
+
+exports.ConfigContext = ConfigContext;
+
+const useConfigContext = () => ConfigContext.use().value;
+/**
+ * Get app context, including directories, plugins and some static infos.
+ */
+
+
+exports.useConfigContext = useConfigContext;
+
+const useAppContext = () => AppContext.use().value;
+
+exports.useAppContext = useAppContext;
+const pluginAPI = {
+  useAppContext,
+  useConfigContext,
+  setAppContext
+};
+const serverHooks = {
+  // server hook
+  gather,
+  config,
+  prepare,
+  create,
+  prepareWebServer,
+  prepareApiServer,
+  onApiChange,
+  beforeDevServer,
+  setupCompiler,
+  afterDevServer,
+  beforeRouteSet,
+  afterRouteSet,
+  beforeProdServer,
+  afterProdServer,
+  listen,
+  beforeServerReset,
+  afterServerReset,
+  // request hook
+  extendSSRContext,
+  extendContext,
+  handleError,
+  beforeMatch,
+  afterMatch,
+  prefetch,
+  renderToString,
+  beforeRender,
+  afterRender,
+  beforeSend,
+  afterSend,
+  reset
+};
+/** All hooks of server plugin. */
+
+const createServerManager = () => (0, _plugin.createAsyncManager)(serverHooks, pluginAPI);
+
+exports.createServerManager = createServerManager;
+const serverManager = createServerManager();
+/** Plugin options of a server plugin. */
+
+exports.serverManager = serverManager;
+const {
+  createPlugin
+} = serverManager;
+exports.createPlugin = createPlugin;

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './plugin';
+export * from '@modern-js/plugin';
+export * from './loadPlugins';

package/dist/types/loadPlugins.d.ts

@@ -0,0 +1,4 @@
+import { ServerPlugin } from './plugin';
+declare type Plugin = string | [string, any] | ServerPlugin;
+export declare const loadPlugins: (plugins: Plugin[], appDirectory: string) => any[];
+export {};

package/dist/types/plugin.d.ts

@@ -0,0 +1,497 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import type { Component } from 'react';
+import { CommonAPI, ToThreads, AsyncSetup, PluginOptions } from '@modern-js/plugin';
+import type { ModernServerContext, BaseSSRServerContext, Metrics, Logger } from '@modern-js/types/server';
+import type { NormalizedConfig, UserConfig } from '@modern-js/core';
+import type { ISAppContext } from '@modern-js/types';
+import type { Options } from 'http-proxy-middleware';
+/** The subset of NormalizedConfig, which really need in server */
+
+export declare type ServerOptions = {
+  output: Pick<NormalizedConfig['output'], 'path' | 'assetPrefix'>;
+  source: Pick<NormalizedConfig['source'], 'alias' | 'envVars' | 'globalVars'>;
+  tools: {
+    babel: NormalizedConfig['tools']['babel'];
+  };
+  server: NormalizedConfig['server'];
+  runtime: NormalizedConfig['runtime'];
+  bff: NormalizedConfig['bff'];
+  plugins: NormalizedConfig['plugins'];
+};
+declare type ServerInitInput = {
+  loggerOptions: any;
+  metricsOptions: any;
+};
+declare type InitExtension = {
+  logger: Logger;
+  metrics: Metrics;
+};
+export declare type Adapter = (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
+export declare type WebServerStartInput = {
+  pwd: string;
+  config: Record<string, any>;
+};
+export declare type APIServerStartInput = {
+  pwd: string;
+  prefix?: string;
+  config?: {
+    middleware?: Array<any>;
+  };
+};
+declare type Change = {
+  filename: string;
+  event: 'add' | 'change' | 'unlink';
+};
+export declare type Route = Record<string, unknown>;
+export declare type RequestResult = {
+  isfinish: boolean;
+};
+export declare type SSRServerContext = Record<string, unknown>;
+export declare type RenderContext = Record<string, unknown>;
+export declare const AppContext: import("@modern-js/plugin").Context<ISAppContext>;
+export declare const setAppContext: (value: ISAppContext) => void;
+export declare const ConfigContext: import("@modern-js/plugin").Context<UserConfig>;
+/**
+ * Get original content of user config.
+ */
+
+export declare const useConfigContext: () => UserConfig;
+/**
+ * Get app context, including directories, plugins and some static infos.
+ */
+
+export declare const useAppContext: () => ISAppContext;
+declare const pluginAPI: {
+  useAppContext: () => ISAppContext;
+  useConfigContext: () => UserConfig;
+  setAppContext: (value: ISAppContext) => void;
+};
+declare const serverHooks: {
+  gather: import("@modern-js/plugin").ParallelWorkflow<{
+    addWebMiddleware: (_input: any) => void;
+    addAPIMiddleware: (_input: any) => void;
+  }, unknown>;
+  config: import("@modern-js/plugin").Waterfall<ServerConfig>;
+  prepare: import("@modern-js/plugin").Waterfall<void>;
+  create: import("@modern-js/plugin").AsyncPipeline<ServerInitInput, InitExtension>;
+  prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, Adapter>;
+  prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+  onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+  beforeDevServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
+  afterDevServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
+  afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
+  beforeProdServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  afterProdServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  listen: import("@modern-js/plugin").ParallelWorkflow<{
+    ip: string;
+    port: number;
+  }, any[]>;
+  beforeServerReset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  afterServerReset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  extendSSRContext: import("@modern-js/plugin").AsyncWaterfall<BaseSSRServerContext>;
+  extendContext: import("@modern-js/plugin").AsyncPipeline<ModernServerContext, ModernServerContext>;
+  handleError: import("@modern-js/plugin").ParallelWorkflow<{
+    error: Error;
+  }, unknown>;
+  beforeMatch: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+  }, any>;
+  afterMatch: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+    routeAPI: any;
+  }, any>;
+  prefetch: import("@modern-js/plugin").ParallelWorkflow<{
+    context: SSRServerContext;
+  }, unknown>;
+  renderToString: import("@modern-js/plugin").AsyncPipeline<{
+    App: Component;
+    context: RenderContext;
+  }, string>;
+  beforeRender: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+  }, any>;
+  afterRender: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+    templateAPI: any;
+  }, any>;
+  beforeSend: import("@modern-js/plugin").AsyncPipeline<ModernServerContext, RequestResult>;
+  afterSend: import("@modern-js/plugin").ParallelWorkflow<{
+    context: ModernServerContext;
+  }, unknown>;
+  reset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+};
+/** All hooks of server plugin. */
+
+export declare type ServerHooks = typeof serverHooks;
+/** All hook callbacks of server plugin. */
+
+export declare type ServerHookCallbacks = ToThreads<ServerHooks>;
+/** All apis for server plugin. */
+
+export declare type PluginAPI = typeof pluginAPI & CommonAPI<ServerHooks>;
+export declare const createServerManager: () => import("@modern-js/plugin").AsyncManager<{
+  gather: import("@modern-js/plugin").ParallelWorkflow<{
+    addWebMiddleware: (_input: any) => void;
+    addAPIMiddleware: (_input: any) => void;
+  }, unknown>;
+  config: import("@modern-js/plugin").Waterfall<ServerConfig>;
+  prepare: import("@modern-js/plugin").Waterfall<void>;
+  create: import("@modern-js/plugin").AsyncPipeline<ServerInitInput, InitExtension>;
+  prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, Adapter>;
+  prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+  onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+  beforeDevServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
+  afterDevServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
+  afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
+  beforeProdServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  afterProdServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  listen: import("@modern-js/plugin").ParallelWorkflow<{
+    ip: string;
+    port: number;
+  }, any[]>;
+  beforeServerReset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  afterServerReset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  extendSSRContext: import("@modern-js/plugin").AsyncWaterfall<BaseSSRServerContext>;
+  extendContext: import("@modern-js/plugin").AsyncPipeline<ModernServerContext, ModernServerContext>;
+  handleError: import("@modern-js/plugin").ParallelWorkflow<{
+    error: Error;
+  }, unknown>;
+  beforeMatch: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+  }, any>;
+  afterMatch: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+    routeAPI: any;
+  }, any>;
+  prefetch: import("@modern-js/plugin").ParallelWorkflow<{
+    context: SSRServerContext;
+  }, unknown>;
+  renderToString: import("@modern-js/plugin").AsyncPipeline<{
+    App: Component;
+    context: RenderContext;
+  }, string>;
+  beforeRender: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+  }, any>;
+  afterRender: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+    templateAPI: any;
+  }, any>;
+  beforeSend: import("@modern-js/plugin").AsyncPipeline<ModernServerContext, RequestResult>;
+  afterSend: import("@modern-js/plugin").ParallelWorkflow<{
+    context: ModernServerContext;
+  }, unknown>;
+  reset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+}, {
+  useAppContext: () => ISAppContext;
+  useConfigContext: () => UserConfig;
+  setAppContext: (value: ISAppContext) => void;
+}>;
+export declare const serverManager: import("@modern-js/plugin").AsyncManager<{
+  gather: import("@modern-js/plugin").ParallelWorkflow<{
+    addWebMiddleware: (_input: any) => void;
+    addAPIMiddleware: (_input: any) => void;
+  }, unknown>;
+  config: import("@modern-js/plugin").Waterfall<ServerConfig>;
+  prepare: import("@modern-js/plugin").Waterfall<void>;
+  create: import("@modern-js/plugin").AsyncPipeline<ServerInitInput, InitExtension>;
+  prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, Adapter>;
+  prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+  onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+  beforeDevServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
+  afterDevServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
+  afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
+  beforeProdServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  afterProdServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  listen: import("@modern-js/plugin").ParallelWorkflow<{
+    ip: string;
+    port: number;
+  }, any[]>;
+  beforeServerReset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  afterServerReset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  extendSSRContext: import("@modern-js/plugin").AsyncWaterfall<BaseSSRServerContext>;
+  extendContext: import("@modern-js/plugin").AsyncPipeline<ModernServerContext, ModernServerContext>;
+  handleError: import("@modern-js/plugin").ParallelWorkflow<{
+    error: Error;
+  }, unknown>;
+  beforeMatch: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+  }, any>;
+  afterMatch: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+    routeAPI: any;
+  }, any>;
+  prefetch: import("@modern-js/plugin").ParallelWorkflow<{
+    context: SSRServerContext;
+  }, unknown>;
+  renderToString: import("@modern-js/plugin").AsyncPipeline<{
+    App: Component;
+    context: RenderContext;
+  }, string>;
+  beforeRender: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+  }, any>;
+  afterRender: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+    templateAPI: any;
+  }, any>;
+  beforeSend: import("@modern-js/plugin").AsyncPipeline<ModernServerContext, RequestResult>;
+  afterSend: import("@modern-js/plugin").ParallelWorkflow<{
+    context: ModernServerContext;
+  }, unknown>;
+  reset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+}, {
+  useAppContext: () => ISAppContext;
+  useConfigContext: () => UserConfig;
+  setAppContext: (value: ISAppContext) => void;
+}>;
+/** Plugin options of a server plugin. */
+
+export declare type ServerPlugin = PluginOptions<ServerHooks, AsyncSetup<ServerHooks, PluginAPI>>;
+export declare type ServerConfig = {
+  bff?: Partial<{
+    proxy: Record<string, Options>;
+  }>;
+  plugins?: ServerPlugin[];
+};
+export declare const createPlugin: (setup?: AsyncSetup<{
+  gather: import("@modern-js/plugin").ParallelWorkflow<{
+    addWebMiddleware: (_input: any) => void;
+    addAPIMiddleware: (_input: any) => void;
+  }, unknown>;
+  config: import("@modern-js/plugin").Waterfall<ServerConfig>;
+  prepare: import("@modern-js/plugin").Waterfall<void>;
+  create: import("@modern-js/plugin").AsyncPipeline<ServerInitInput, InitExtension>;
+  prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, Adapter>;
+  prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+  onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+  beforeDevServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
+  afterDevServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
+  afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
+  beforeProdServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  afterProdServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  listen: import("@modern-js/plugin").ParallelWorkflow<{
+    ip: string;
+    port: number;
+  }, any[]>;
+  beforeServerReset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  afterServerReset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  extendSSRContext: import("@modern-js/plugin").AsyncWaterfall<BaseSSRServerContext>;
+  extendContext: import("@modern-js/plugin").AsyncPipeline<ModernServerContext, ModernServerContext>;
+  handleError: import("@modern-js/plugin").ParallelWorkflow<{
+    error: Error;
+  }, unknown>;
+  beforeMatch: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+  }, any>;
+  afterMatch: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+    routeAPI: any;
+  }, any>;
+  prefetch: import("@modern-js/plugin").ParallelWorkflow<{
+    context: SSRServerContext;
+  }, unknown>;
+  renderToString: import("@modern-js/plugin").AsyncPipeline<{
+    App: Component;
+    context: RenderContext;
+  }, string>;
+  beforeRender: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+  }, any>;
+  afterRender: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+    templateAPI: any;
+  }, any>;
+  beforeSend: import("@modern-js/plugin").AsyncPipeline<ModernServerContext, RequestResult>;
+  afterSend: import("@modern-js/plugin").ParallelWorkflow<{
+    context: ModernServerContext;
+  }, unknown>;
+  reset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+}, {
+  useAppContext: () => ISAppContext;
+  useConfigContext: () => UserConfig;
+  setAppContext: (value: ISAppContext) => void;
+}> | undefined, options?: PluginOptions<{
+  gather: import("@modern-js/plugin").ParallelWorkflow<{
+    addWebMiddleware: (_input: any) => void;
+    addAPIMiddleware: (_input: any) => void;
+  }, unknown>;
+  config: import("@modern-js/plugin").Waterfall<ServerConfig>;
+  prepare: import("@modern-js/plugin").Waterfall<void>;
+  create: import("@modern-js/plugin").AsyncPipeline<ServerInitInput, InitExtension>;
+  prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, Adapter>;
+  prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+  onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+  beforeDevServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
+  afterDevServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
+  afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
+  beforeProdServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  afterProdServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  listen: import("@modern-js/plugin").ParallelWorkflow<{
+    ip: string;
+    port: number;
+  }, any[]>;
+  beforeServerReset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  afterServerReset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  extendSSRContext: import("@modern-js/plugin").AsyncWaterfall<BaseSSRServerContext>;
+  extendContext: import("@modern-js/plugin").AsyncPipeline<ModernServerContext, ModernServerContext>;
+  handleError: import("@modern-js/plugin").ParallelWorkflow<{
+    error: Error;
+  }, unknown>;
+  beforeMatch: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+  }, any>;
+  afterMatch: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+    routeAPI: any;
+  }, any>;
+  prefetch: import("@modern-js/plugin").ParallelWorkflow<{
+    context: SSRServerContext;
+  }, unknown>;
+  renderToString: import("@modern-js/plugin").AsyncPipeline<{
+    App: Component;
+    context: RenderContext;
+  }, string>;
+  beforeRender: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+  }, any>;
+  afterRender: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+    templateAPI: any;
+  }, any>;
+  beforeSend: import("@modern-js/plugin").AsyncPipeline<ModernServerContext, RequestResult>;
+  afterSend: import("@modern-js/plugin").ParallelWorkflow<{
+    context: ModernServerContext;
+  }, unknown>;
+  reset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+}, AsyncSetup<{
+  gather: import("@modern-js/plugin").ParallelWorkflow<{
+    addWebMiddleware: (_input: any) => void;
+    addAPIMiddleware: (_input: any) => void;
+  }, unknown>;
+  config: import("@modern-js/plugin").Waterfall<ServerConfig>;
+  prepare: import("@modern-js/plugin").Waterfall<void>;
+  create: import("@modern-js/plugin").AsyncPipeline<ServerInitInput, InitExtension>;
+  prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, Adapter>;
+  prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+  onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+  beforeDevServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
+  afterDevServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
+  afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
+  beforeProdServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  afterProdServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  listen: import("@modern-js/plugin").ParallelWorkflow<{
+    ip: string;
+    port: number;
+  }, any[]>;
+  beforeServerReset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  afterServerReset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  extendSSRContext: import("@modern-js/plugin").AsyncWaterfall<BaseSSRServerContext>;
+  extendContext: import("@modern-js/plugin").AsyncPipeline<ModernServerContext, ModernServerContext>;
+  handleError: import("@modern-js/plugin").ParallelWorkflow<{
+    error: Error;
+  }, unknown>;
+  beforeMatch: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+  }, any>;
+  afterMatch: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+    routeAPI: any;
+  }, any>;
+  prefetch: import("@modern-js/plugin").ParallelWorkflow<{
+    context: SSRServerContext;
+  }, unknown>;
+  renderToString: import("@modern-js/plugin").AsyncPipeline<{
+    App: Component;
+    context: RenderContext;
+  }, string>;
+  beforeRender: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+  }, any>;
+  afterRender: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+    templateAPI: any;
+  }, any>;
+  beforeSend: import("@modern-js/plugin").AsyncPipeline<ModernServerContext, RequestResult>;
+  afterSend: import("@modern-js/plugin").ParallelWorkflow<{
+    context: ModernServerContext;
+  }, unknown>;
+  reset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+}, {
+  useAppContext: () => ISAppContext;
+  useConfigContext: () => UserConfig;
+  setAppContext: (value: ISAppContext) => void;
+}>> | undefined) => import("@modern-js/plugin").AsyncPlugin<{
+  gather: import("@modern-js/plugin").ParallelWorkflow<{
+    addWebMiddleware: (_input: any) => void;
+    addAPIMiddleware: (_input: any) => void;
+  }, unknown>;
+  config: import("@modern-js/plugin").Waterfall<ServerConfig>;
+  prepare: import("@modern-js/plugin").Waterfall<void>;
+  create: import("@modern-js/plugin").AsyncPipeline<ServerInitInput, InitExtension>;
+  prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, Adapter>;
+  prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+  onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+  beforeDevServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
+  afterDevServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
+  afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
+  beforeProdServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  afterProdServer: import("@modern-js/plugin").ParallelWorkflow<ServerOptions, any>;
+  listen: import("@modern-js/plugin").ParallelWorkflow<{
+    ip: string;
+    port: number;
+  }, any[]>;
+  beforeServerReset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  afterServerReset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  extendSSRContext: import("@modern-js/plugin").AsyncWaterfall<BaseSSRServerContext>;
+  extendContext: import("@modern-js/plugin").AsyncPipeline<ModernServerContext, ModernServerContext>;
+  handleError: import("@modern-js/plugin").ParallelWorkflow<{
+    error: Error;
+  }, unknown>;
+  beforeMatch: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+  }, any>;
+  afterMatch: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+    routeAPI: any;
+  }, any>;
+  prefetch: import("@modern-js/plugin").ParallelWorkflow<{
+    context: SSRServerContext;
+  }, unknown>;
+  renderToString: import("@modern-js/plugin").AsyncPipeline<{
+    App: Component;
+    context: RenderContext;
+  }, string>;
+  beforeRender: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+  }, any>;
+  afterRender: import("@modern-js/plugin").AsyncPipeline<{
+    context: ModernServerContext;
+    templateAPI: any;
+  }, any>;
+  beforeSend: import("@modern-js/plugin").AsyncPipeline<ModernServerContext, RequestResult>;
+  afterSend: import("@modern-js/plugin").ParallelWorkflow<{
+    context: ModernServerContext;
+  }, unknown>;
+  reset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+}, {
+  useAppContext: () => ISAppContext;
+  useConfigContext: () => UserConfig;
+  setAppContext: (value: ISAppContext) => void;
+}>;
+export {};

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "1.21.2-beta.1",
+  "version": "1.21.2-beta.2",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",