@modern-js/plugin-v2 2.65.4 → 2.65.6-alpha.0

package/dist/esm/server/api.js

@@ -0,0 +1,76 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_without_properties } from "@swc/helpers/_/_object_without_properties";
+import { createDebugger } from "@modern-js/utils";
+import { assign } from "@modern-js/utils/lodash";
+var debug = createDebugger("plugin-server-v2");
+function initPluginAPI(param) {
+  var context = param.context, pluginManager = param.pluginManager;
+  var hooks = context.hooks, extendsHooks = context.extendsHooks, plugins = context.plugins;
+  function getServerContext() {
+    if (context) {
+      var hooks2 = context.hooks, extendsHooks2 = context.extendsHooks, config = context.config, pluginAPI2 = context.pluginAPI, serverContext = _object_without_properties(context, [
+        "hooks",
+        "extendsHooks",
+        "config",
+        "pluginAPI"
+      ]);
+      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;
+  }
+  var extendsPluginApi = {};
+  plugins.forEach(function(plugin) {
+    var _registryApi = plugin._registryApi;
+    if (_registryApi) {
+      var apis = _registryApi(getServerContext, updateServerContext);
+      Object.keys(apis).forEach(function(apiName) {
+        extendsPluginApi[apiName] = apis[apiName];
+      });
+    }
+  });
+  if (extendsHooks) {
+    Object.keys(extendsHooks).forEach(function(hookName) {
+      extendsPluginApi[hookName] = extendsHooks[hookName].tap;
+    });
+  }
+  function updateServerContext(updateContext) {
+    context = assign(context, updateContext);
+  }
+  var pluginAPI = _object_spread({
+    isPluginExists: pluginManager.isPluginExists,
+    getServerContext,
+    getConfig,
+    getHooks,
+    updateServerContext,
+    modifyConfig: hooks.modifyConfig.tap,
+    onPrepare: hooks.onPrepare.tap,
+    onReset: hooks.onReset.tap
+  }, extendsPluginApi);
+  return new Proxy(pluginAPI, {
+    get: function get(target, prop) {
+      if (prop === "then") {
+        return void 0;
+      }
+      if (prop in target) {
+        return target[prop];
+      }
+      return function() {
+        debug("api.".concat(prop.toString(), " not exist"));
+      };
+    }
+  });
+}
+export {
+  debug,
+  initPluginAPI
+};

package/dist/esm/server/context.js

@@ -0,0 +1,38 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { initHooks } from "./hooks";
+function initServerContext(params) {
+  var options = params.options, plugins = params.plugins;
+  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,
+    middlewares: []
+  };
+}
+function createServerContext(param) {
+  var serverContext = param.serverContext, config = param.config;
+  var plugins = serverContext.plugins;
+  var extendsHooks = {};
+  plugins.forEach(function(plugin) {
+    var _plugin_registryHooks = plugin.registryHooks, registryHooks = _plugin_registryHooks === void 0 ? {} : _plugin_registryHooks;
+    Object.keys(registryHooks).forEach(function(hookName) {
+      extendsHooks[hookName] = registryHooks[hookName];
+    });
+  });
+  return _object_spread_props(_object_spread({}, serverContext), {
+    hooks: _object_spread({}, initHooks(), extendsHooks),
+    extendsHooks,
+    config
+  });
+}
+export {
+  createServerContext,
+  initServerContext
+};

package/dist/esm/server/hooks.js

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

package/dist/esm/server/index.js

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

package/dist/esm/server/run/create.js

@@ -0,0 +1,89 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { createPluginManager } from "../../manager";
+import { initPluginAPI } from "../../server/api";
+import { createServerContext, initServerContext } from "../../server/context";
+var createServer = function() {
+  var init = function init2(options) {
+    pluginManager.clear();
+    initOptions = options;
+    var allPlugins = initOptions.plugins, runOptions = initOptions.options, handleSetupResult = initOptions.handleSetupResult;
+    pluginManager.addPlugins(allPlugins);
+    var plugins = pluginManager.getPlugins();
+    var context = createServerContext({
+      serverContext: initServerContext({
+        plugins,
+        options: runOptions
+      }),
+      config: initOptions.config
+    });
+    var pluginAPI = initPluginAPI({
+      context,
+      pluginManager
+    });
+    context.pluginAPI = pluginAPI;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+    try {
+      for (var _iterator = plugins[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var plugin = _step.value;
+        var _plugin_setup;
+        var setupResult = (_plugin_setup = plugin.setup) === null || _plugin_setup === void 0 ? void 0 : _plugin_setup.call(plugin, pluginAPI);
+        if (handleSetupResult) {
+          handleSetupResult(setupResult, pluginAPI);
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+    return {
+      serverContext: context
+    };
+  };
+  var run = function run2(options) {
+    return _run.apply(this, arguments);
+  };
+  var initOptions;
+  var pluginManager = createPluginManager();
+  function _run() {
+    _run = _async_to_generator(function(options) {
+      var serverContext, config;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            serverContext = init(options).serverContext;
+            return [
+              4,
+              serverContext.hooks.modifyConfig.call(serverContext.config)
+            ];
+          case 1:
+            config = _state.sent();
+            serverContext.config = config;
+            return [
+              2,
+              {
+                serverContext
+              }
+            ];
+        }
+      });
+    });
+    return _run.apply(this, arguments);
+  }
+  return {
+    run
+  };
+};
+export {
+  createServer
+};

package/dist/esm/server/run/index.js

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

package/dist/esm-node/hooks.js

@@ -103,9 +103,37 @@ function createCollectSyncHook() {
     call
   };
 }
+function createAsyncPipelineHook() {
+  const callbacks = [];
+  const tap = (cb) => {
+    callbacks.push(cb);
+  };
+  const call = async (...params) => {
+    for (const callback of callbacks) {
+      let runNext = false;
+      const next = (info) => {
+        runNext = true;
+        if (info) {
+          params[0] = info;
+        }
+      };
+      const result = await callback(...params, next);
+      if (!runNext) {
+        params[0] = result;
+        break;
+      }
+    }
+    return params[0] || [];
+  };
+  return {
+    tap,
+    call
+  };
+}
 export {
   createAsyncHook,
   createAsyncInterruptHook,
+  createAsyncPipelineHook,
   createCollectAsyncHook,
   createCollectSyncHook,
   createSyncHook

package/dist/esm-node/index.js

@@ -1,8 +1,9 @@
 import { createPluginManager } from "./manager";
-import { createSyncHook, createAsyncHook, createCollectSyncHook, createCollectAsyncHook, createAsyncInterruptHook } from "./hooks";
+import { createSyncHook, createAsyncHook, createCollectSyncHook, createCollectAsyncHook, createAsyncInterruptHook, createAsyncPipelineHook } from "./hooks";
 export {
   createAsyncHook,
   createAsyncInterruptHook,
+  createAsyncPipelineHook,
   createCollectAsyncHook,
   createCollectSyncHook,
   createPluginManager,

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

@@ -0,0 +1,69 @@
+import { createDebugger } from "@modern-js/utils";
+import { 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: hooks2, extendsHooks: extendsHooks2, config, pluginAPI: pluginAPI2, ...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 = assign(context, updateContext);
+  }
+  const pluginAPI = {
+    isPluginExists: pluginManager.isPluginExists,
+    getServerContext,
+    getConfig,
+    getHooks,
+    updateServerContext,
+    modifyConfig: hooks.modifyConfig.tap,
+    onPrepare: hooks.onPrepare.tap,
+    onReset: hooks.onReset.tap,
+    ...extendsPluginApi
+  };
+  return new Proxy(pluginAPI, {
+    get(target, prop) {
+      if (prop === "then") {
+        return void 0;
+      }
+      if (prop in target) {
+        return target[prop];
+      }
+      return () => {
+        debug(`api.${prop.toString()} not exist`);
+      };
+    }
+  });
+}
+export {
+  debug,
+  initPluginAPI
+};

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

@@ -0,0 +1,39 @@
+import { initHooks } from "./hooks";
+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,
+    middlewares: []
+  };
+}
+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.js

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

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

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

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

@@ -0,0 +1,50 @@
+import { createPluginManager } from "../../manager";
+import { initPluginAPI } from "../../server/api";
+import { createServerContext, initServerContext } from "../../server/context";
+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) {
+      var _plugin_setup;
+      const setupResult = (_plugin_setup = plugin.setup) === null || _plugin_setup === void 0 ? void 0 : _plugin_setup.call(plugin, 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.js

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

package/dist/types/hooks.d.ts

@@ -1,6 +1,7 @@
-import type { AsyncHook, AsyncInterruptHook, CollectAsyncHook, CollectSyncHook, SyncHook } from './types/hooks';
+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,6 +1,7 @@
 export { createPluginManager } from './manager';
-export { createSyncHook, createAsyncHook, createCollectSyncHook, createCollectAsyncHook, createAsyncInterruptHook, } from './hooks';
+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 { AsyncHook, CollectAsyncHook, PluginHook, PluginHookTap, } from './types/hooks';
+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/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>;
+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>;
+    }>;
+};

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,21 @@
+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;
+    };
+};
+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/hooks.d.ts

@@ -11,6 +11,10 @@ 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>>[]>;
@@ -19,5 +23,5 @@ 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>;
+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/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>>;
+    updateServerContext: (updateContext: DeepPartial<ServerContext<Extends>>) => 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>];