@modern-js/server-core 2.5.0 → 2.5.1-alpha.0

package/dist/js/modern/index.js

@@ -0,0 +1,4 @@
+export * from "./plugin";
+export * from "@modern-js/plugin";
+export * from "./loadPlugins";
+export * from "./types/config";

package/dist/js/modern/loadPlugins.js

@@ -0,0 +1,33 @@
+import {
+  compatRequire,
+  getInternalPlugins,
+  tryResolve
+} from "@modern-js/utils";
+import { createPlugin } from "./plugin";
+const resolvePlugin = (p, appDirectory) => {
+  const isPluginInstance = typeof p !== "string";
+  if (isPluginInstance) {
+    return {
+      module: createPlugin(p.setup, p)
+    };
+  }
+  const pluginPath = tryResolve(p, appDirectory);
+  const module = compatRequire(pluginPath);
+  const pluginInstance = module();
+  return {
+    module: createPlugin(pluginInstance.setup, pluginInstance)
+  };
+};
+const loadPlugins = (appDirectory, configPlugins, options) => {
+  const loadedPlugins = getInternalPlugins(
+    appDirectory,
+    options.internalPlugins
+  );
+  return [...loadedPlugins, ...configPlugins].map((plugin) => {
+    const { module } = resolvePlugin(plugin, appDirectory);
+    return module;
+  });
+};
+export {
+  loadPlugins
+};

package/dist/js/modern/plugin.js

@@ -0,0 +1,93 @@
+import {
+  createContext,
+  createAsyncManager,
+  createAsyncPipeline,
+  createAsyncWaterfall,
+  createParallelWorkflow,
+  createWaterfall
+} from "@modern-js/plugin";
+const gather = createParallelWorkflow();
+const config = createWaterfall();
+const prepare = createWaterfall();
+const preparebeforeRouteHandler = createAsyncPipeline();
+const prepareWebServer = createAsyncPipeline();
+const prepareApiServer = createAsyncPipeline();
+const onApiChange = createWaterfall();
+const repack = createWaterfall();
+const beforeDevServer = createParallelWorkflow();
+const setupCompiler = createParallelWorkflow();
+const afterDevServer = createParallelWorkflow();
+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();
+const prefetch = createParallelWorkflow();
+const renderToString = createAsyncPipeline();
+const beforeRender = createAsyncPipeline();
+const afterRender = createAsyncPipeline();
+const beforeSend = createAsyncPipeline();
+const afterSend = createParallelWorkflow();
+const reset = createParallelWorkflow();
+const AppContext = createContext({});
+const setAppContext = (value) => AppContext.set(value);
+const ConfigContext = createContext({});
+const useConfigContext = () => ConfigContext.use().value;
+const useAppContext = () => AppContext.use().value;
+const pluginAPI = {
+  useAppContext,
+  useConfigContext,
+  setAppContext
+};
+const serverHooks = {
+  gather,
+  config,
+  prepare,
+  preparebeforeRouteHandler,
+  prepareWebServer,
+  prepareApiServer,
+  repack,
+  onApiChange,
+  beforeDevServer,
+  setupCompiler,
+  afterDevServer,
+  beforeRouteSet,
+  afterRouteSet,
+  beforeProdServer,
+  afterProdServer,
+  listen,
+  beforeServerReset,
+  afterServerReset,
+  extendSSRContext,
+  extendContext,
+  handleError,
+  beforeMatch,
+  afterMatch,
+  prefetch,
+  renderToString,
+  beforeRender,
+  afterRender,
+  beforeSend,
+  afterSend,
+  reset
+};
+const createServerManager = () => createAsyncManager(serverHooks, pluginAPI);
+const serverManager = createServerManager();
+const { createPlugin } = serverManager;
+export {
+  AppContext,
+  ConfigContext,
+  createPlugin,
+  createServerManager,
+  serverManager,
+  setAppContext,
+  useAppContext,
+  useConfigContext
+};

package/dist/js/modern/types/config/index.js

@@ -0,0 +1,6 @@
+export * from "./bff";
+export * from "./html";
+export * from "./output";
+export * from "./server";
+export * from "./source";
+export * from "./tools";

package/dist/js/node/index.js

@@ -0,0 +1,20 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./plugin"), module.exports);
+__reExport(src_exports, require("@modern-js/plugin"), module.exports);
+__reExport(src_exports, require("./loadPlugins"), module.exports);
+__reExport(src_exports, require("./types/config"), module.exports);

package/dist/js/node/loadPlugins.js

@@ -0,0 +1,52 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var loadPlugins_exports = {};
+__export(loadPlugins_exports, {
+  loadPlugins: () => loadPlugins
+});
+module.exports = __toCommonJS(loadPlugins_exports);
+var import_utils = require("@modern-js/utils");
+var import_plugin = require("./plugin");
+const resolvePlugin = (p, appDirectory) => {
+  const isPluginInstance = typeof p !== "string";
+  if (isPluginInstance) {
+    return {
+      module: (0, import_plugin.createPlugin)(p.setup, p)
+    };
+  }
+  const pluginPath = (0, import_utils.tryResolve)(p, appDirectory);
+  const module2 = (0, import_utils.compatRequire)(pluginPath);
+  const pluginInstance = module2();
+  return {
+    module: (0, import_plugin.createPlugin)(pluginInstance.setup, pluginInstance)
+  };
+};
+const loadPlugins = (appDirectory, configPlugins, options) => {
+  const loadedPlugins = (0, import_utils.getInternalPlugins)(
+    appDirectory,
+    options.internalPlugins
+  );
+  return [...loadedPlugins, ...configPlugins].map((plugin) => {
+    const { module: module2 } = resolvePlugin(plugin, appDirectory);
+    return module2;
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadPlugins
+});

package/dist/js/node/plugin.js

@@ -0,0 +1,116 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+__export(plugin_exports, {
+  AppContext: () => AppContext,
+  ConfigContext: () => ConfigContext,
+  createPlugin: () => createPlugin,
+  createServerManager: () => createServerManager,
+  serverManager: () => serverManager,
+  setAppContext: () => setAppContext,
+  useAppContext: () => useAppContext,
+  useConfigContext: () => useConfigContext
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_plugin = require("@modern-js/plugin");
+const gather = (0, import_plugin.createParallelWorkflow)();
+const config = (0, import_plugin.createWaterfall)();
+const prepare = (0, import_plugin.createWaterfall)();
+const preparebeforeRouteHandler = (0, import_plugin.createAsyncPipeline)();
+const prepareWebServer = (0, import_plugin.createAsyncPipeline)();
+const prepareApiServer = (0, import_plugin.createAsyncPipeline)();
+const onApiChange = (0, import_plugin.createWaterfall)();
+const repack = (0, import_plugin.createWaterfall)();
+const beforeDevServer = (0, import_plugin.createParallelWorkflow)();
+const setupCompiler = (0, import_plugin.createParallelWorkflow)();
+const afterDevServer = (0, import_plugin.createParallelWorkflow)();
+const beforeRouteSet = (0, import_plugin.createAsyncPipeline)();
+const afterRouteSet = (0, import_plugin.createAsyncPipeline)();
+const beforeProdServer = (0, import_plugin.createParallelWorkflow)();
+const afterProdServer = (0, import_plugin.createParallelWorkflow)();
+const listen = (0, import_plugin.createParallelWorkflow)();
+const beforeServerReset = (0, import_plugin.createParallelWorkflow)();
+const afterServerReset = (0, import_plugin.createParallelWorkflow)();
+const extendSSRContext = (0, import_plugin.createAsyncWaterfall)();
+const extendContext = (0, import_plugin.createAsyncPipeline)();
+const handleError = (0, import_plugin.createParallelWorkflow)();
+const beforeMatch = (0, import_plugin.createAsyncPipeline)();
+const afterMatch = (0, import_plugin.createAsyncPipeline)();
+const prefetch = (0, import_plugin.createParallelWorkflow)();
+const renderToString = (0, import_plugin.createAsyncPipeline)();
+const beforeRender = (0, import_plugin.createAsyncPipeline)();
+const afterRender = (0, import_plugin.createAsyncPipeline)();
+const beforeSend = (0, import_plugin.createAsyncPipeline)();
+const afterSend = (0, import_plugin.createParallelWorkflow)();
+const reset = (0, import_plugin.createParallelWorkflow)();
+const AppContext = (0, import_plugin.createContext)({});
+const setAppContext = (value) => AppContext.set(value);
+const ConfigContext = (0, import_plugin.createContext)({});
+const useConfigContext = () => ConfigContext.use().value;
+const useAppContext = () => AppContext.use().value;
+const pluginAPI = {
+  useAppContext,
+  useConfigContext,
+  setAppContext
+};
+const serverHooks = {
+  gather,
+  config,
+  prepare,
+  preparebeforeRouteHandler,
+  prepareWebServer,
+  prepareApiServer,
+  repack,
+  onApiChange,
+  beforeDevServer,
+  setupCompiler,
+  afterDevServer,
+  beforeRouteSet,
+  afterRouteSet,
+  beforeProdServer,
+  afterProdServer,
+  listen,
+  beforeServerReset,
+  afterServerReset,
+  extendSSRContext,
+  extendContext,
+  handleError,
+  beforeMatch,
+  afterMatch,
+  prefetch,
+  renderToString,
+  beforeRender,
+  afterRender,
+  beforeSend,
+  afterSend,
+  reset
+};
+const createServerManager = () => (0, import_plugin.createAsyncManager)(serverHooks, pluginAPI);
+const serverManager = createServerManager();
+const { createPlugin } = serverManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppContext,
+  ConfigContext,
+  createPlugin,
+  createServerManager,
+  serverManager,
+  setAppContext,
+  useAppContext,
+  useConfigContext
+});

package/dist/js/node/types/config/bff.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bff_exports = {};
+module.exports = __toCommonJS(bff_exports);

package/dist/js/node/types/config/html.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var html_exports = {};
+module.exports = __toCommonJS(html_exports);

package/dist/js/node/types/config/index.js

@@ -0,0 +1,22 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+module.exports = __toCommonJS(config_exports);
+__reExport(config_exports, require("./bff"), module.exports);
+__reExport(config_exports, require("./html"), module.exports);
+__reExport(config_exports, require("./output"), module.exports);
+__reExport(config_exports, require("./server"), module.exports);
+__reExport(config_exports, require("./source"), module.exports);
+__reExport(config_exports, require("./tools"), module.exports);

package/dist/js/node/types/config/output.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var output_exports = {};
+module.exports = __toCommonJS(output_exports);

package/dist/js/node/types/config/server.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+module.exports = __toCommonJS(server_exports);

package/dist/js/node/types/config/share.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var share_exports = {};
+module.exports = __toCommonJS(share_exports);

package/dist/js/node/types/config/source.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var source_exports = {};
+module.exports = __toCommonJS(source_exports);

package/dist/js/node/types/config/tools.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tools_exports = {};
+module.exports = __toCommonJS(tools_exports);

package/dist/types/plugin.d.ts

@@ -2,7 +2,7 @@
 import { IncomingMessage, ServerResponse } from 'http';
 import type { Component } from 'react';
 import { CommonAPI, ToThreads, AsyncSetup, PluginOptions } from '@modern-js/plugin';
-import type { ModernServerContext, BaseSSRServerContext, AfterMatchContext, AfterRenderContext, MiddlewareContext, ISAppContext, ServerRoute } from '@modern-js/types';
+import type { ModernServerContext, BaseSSRServerContext, AfterMatchContext, AfterRenderContext, MiddlewareContext, ISAppContext, ServerRoute, HttpMethodDecider } from '@modern-js/types';
 import type { BffUserConfig, ServerOptions, UserConfig } from './types/config';
 export type WebAdapter = (ctx: MiddlewareContext) => void | Promise<void>;
 export type Adapter = (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
@@ -14,6 +14,7 @@ export type BeforeRouteHandler = (context: ModernServerContext) => Promise<void>
 export type APIServerStartInput = {
   pwd: string;
   prefix?: string;
+  httpMethodDecider?: HttpMethodDecider;
   config?: {
     middleware?: Array<any>;
   };

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

@@ -1,7 +1,9 @@
 import type { Options } from 'http-proxy-middleware';
+import type { HttpMethodDecider } from '@modern-js/types';
 export interface BffUserConfig {
   prefix?: string;
   proxy?: Record<string, Options>;
+  httpMethodDecider?: HttpMethodDecider;
   enableHandleWeb?: boolean;
 }
 export type BffNormalizedConfig = BffUserConfig;

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.5.0",
+  "version": "2.5.1-alpha.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -32,16 +32,16 @@
     "@modern-js/utils": "2.5.0"
   },
   "devDependencies": {
+    "@modern-js/types": "2.5.0",
+    "@modern-js/babel-preset-app": "2.5.0",
+    "@scripts/build": "2.5.0",
+    "@scripts/jest-config": "2.5.0",
     "@types/jest": "^27",
     "@types/node": "^14",
     "http-proxy-middleware": "^2.0.4",
     "jest": "^27",
     "ts-jest": "^27.0.4",
-    "typescript": "^4",
-    "@modern-js/types": "2.5.0",
-    "@modern-js/babel-preset-app": "2.5.0",
-    "@scripts/jest-config": "2.5.0",
-    "@scripts/build": "2.5.0"
+    "typescript": "^4"
   },
   "sideEffects": false,
   "publishConfig": {