@modern-js/plugin-v2 0.0.0-nightly-20250119160327 → 0.0.0-nightly-20250120160316

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

@@ -0,0 +1,72 @@
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { merge } from "@modern-js/runtime-utils/merge";
+import { createPluginManager } from "../../manager";
+import { initPluginAPI } from "../../runtime/api";
+import { createRuntimeContext, initRuntimeContext } from "../../runtime/context";
+var createRuntime = function() {
+  var init = function init2(options) {
+    pluginManager.clear();
+    initOptions = options;
+    var allPlugins = options.plugins, handleSetupResult = options.handleSetupResult;
+    pluginManager.addPlugins(allPlugins);
+    var plugins = pluginManager.getPlugins();
+    var context = createRuntimeContext({
+      runtimeContext: initRuntimeContext(),
+      config: initOptions.config,
+      plugins
+    });
+    var pluginAPI = initPluginAPI({
+      context,
+      pluginManager,
+      plugins
+    });
+    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 {
+      runtimeContext: context
+    };
+  };
+  var run = function run2(options) {
+    var runtimeContext = init(options).runtimeContext;
+    var configs = runtimeContext.hooks.modifyRuntimeConfig.call(runtimeContext.config).filter(function(config) {
+      return Boolean(config);
+    });
+    runtimeContext.config = merge.apply(void 0, [
+      {}
+    ].concat(_to_consumable_array(configs)));
+    return {
+      runtimeContext
+    };
+  };
+  var initOptions;
+  var pluginManager = createPluginManager();
+  return {
+    run
+  };
+};
+export {
+  createRuntime
+};

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

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

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

@@ -1,4 +1,4 @@
-import { logger } from "@modern-js/utils";
+import { createDebugger, logger } from "@modern-js/utils";
 import { program } from "@modern-js/utils/commander";
 import { createPluginManager } from "../../manager";
 import { initPluginAPI } from "../api";
@@ -10,6 +10,7 @@ import { initCommandsMap, setProgramVersion } from "./utils/commander";
 import { createFileWatcher } from "./utils/createFileWatcher";
 import { initAppDir } from "./utils/initAppDir";
 import { loadEnv } from "./utils/loadEnv";
+const debug = createDebugger("plugin-v2");
 const createCli = () => {
   let initOptions;
   const pluginManager = createPluginManager();
@@ -30,6 +31,7 @@ const createCli = () => {
     checkIsDuplicationPlugin(allPlugins.map((plugin) => plugin.name), loaded.config.autoLoadPlugins);
     pluginManager.addPlugins(allPlugins);
     const plugins = await pluginManager.getPlugins();
+    debug("CLI Plugins:", plugins.map((p) => p.name));
     const context = await createContext({
       appContext: initAppContext({
         packageName: loaded.packageName,

package/dist/esm-node/hooks.js

@@ -1,3 +1,49 @@
+function createAsyncInterruptHook() {
+  const callbacks = [];
+  const tap = (cb) => {
+    callbacks.push(cb);
+  };
+  const call = async (...params) => {
+    let interrupted = false;
+    let interruptResult;
+    const interrupt = (info) => {
+      interrupted = true;
+      interruptResult = info;
+    };
+    for (const callback of callbacks) {
+      if (interrupted)
+        break;
+      const result = await callback(...params, interrupt);
+      if (result !== void 0) {
+        params[0] = result;
+      }
+    }
+    return interrupted ? interruptResult : params[0] || [];
+  };
+  return {
+    tap,
+    call
+  };
+}
+function createSyncHook() {
+  const callbacks = [];
+  const tap = (cb) => {
+    callbacks.push(cb);
+  };
+  const call = (...params) => {
+    for (const callback of callbacks) {
+      const result = callback(...params);
+      if (result !== void 0) {
+        params[0] = result;
+      }
+    }
+    return params[0];
+  };
+  return {
+    tap,
+    call
+  };
+}
 function createAsyncHook() {
   const callbacks = [];
   const tap = (cb) => {
@@ -37,7 +83,30 @@ function createCollectAsyncHook() {
     call
   };
 }
+function createCollectSyncHook() {
+  const callbacks = [];
+  const tap = (cb) => {
+    callbacks.push(cb);
+  };
+  const call = (...params) => {
+    const results = [];
+    for (const callback of callbacks) {
+      const result = callback(params);
+      if (result !== void 0) {
+        results.push(result);
+      }
+    }
+    return results;
+  };
+  return {
+    tap,
+    call
+  };
+}
 export {
   createAsyncHook,
-  createCollectAsyncHook
+  createAsyncInterruptHook,
+  createCollectAsyncHook,
+  createCollectSyncHook,
+  createSyncHook
 };

package/dist/esm-node/index.js

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

package/dist/esm-node/manager.js

@@ -1,5 +1,4 @@
-import { isFunction, logger } from "@modern-js/utils";
-import { debug } from "./cli/run/utils/debug";
+const isFunction = (obj) => typeof obj === "function";
 function validatePlugin(plugin) {
   const type = typeof plugin;
   if (type !== "object" || plugin === null) {
@@ -47,7 +46,7 @@ function createPluginManager() {
     validatePlugin(newPlugin);
     const { name, usePlugins = [], pre = [], post = [] } = newPlugin;
     if (plugins.has(name)) {
-      logger.warn(`Plugin ${name} already exists.`);
+      console.warn(`Plugin ${name} already exists.`);
       return;
     }
     plugins.set(name, newPlugin);
@@ -112,7 +111,6 @@ function createPluginManager() {
       visit(name);
     });
     result = result.filter((result2) => result2);
-    debug("CLI Plugins:", result.map((p) => p.name));
     return result;
   };
   const clear = () => {

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

@@ -0,0 +1,55 @@
+import { merge } from "@modern-js/runtime-utils/merge";
+function initPluginAPI({ context, plugins }) {
+  const { hooks, extendsHooks } = context;
+  function getRuntimeContext() {
+    if (context) {
+      const { hooks: hooks2, extendsHooks: extendsHooks2, config, pluginAPI, ...runtimeContext } = context;
+      runtimeContext._internalContext = context;
+      return runtimeContext;
+    }
+    throw new Error("Cannot access context");
+  }
+  function updateRuntimeContext(updateContext) {
+    context = merge(context, updateContext);
+  }
+  function getHooks() {
+    return {
+      ...hooks,
+      ...extendsHooks
+    };
+  }
+  function getRuntimeConfig() {
+    if (context.config) {
+      return context.config;
+    }
+    throw new Error("Cannot access config");
+  }
+  const extendsPluginApi = {};
+  plugins.forEach((plugin) => {
+    const { _registryApi } = plugin;
+    if (_registryApi) {
+      const apis = _registryApi(getRuntimeContext, updateRuntimeContext);
+      Object.keys(apis).forEach((apiName) => {
+        extendsPluginApi[apiName] = apis[apiName];
+      });
+    }
+  });
+  if (extendsHooks) {
+    Object.keys(extendsHooks).forEach((hookName) => {
+      extendsPluginApi[hookName] = extendsHooks[hookName].tap;
+    });
+  }
+  return {
+    updateRuntimeContext,
+    getHooks,
+    getRuntimeConfig,
+    modifyRuntimeConfig: hooks.modifyRuntimeConfig.tap,
+    onBeforeRender: hooks.onBeforeRender.tap,
+    wrapRoot: hooks.wrapRoot.tap,
+    pickContext: hooks.pickContext.tap,
+    ...extendsPluginApi
+  };
+}
+export {
+  initPluginAPI
+};

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

@@ -0,0 +1,26 @@
+import { initHooks } from "./hooks";
+function initRuntimeContext() {
+  return {};
+}
+function createRuntimeContext({ runtimeContext, config, plugins }) {
+  const extendsHooks = {};
+  plugins.forEach((plugin) => {
+    const { registryHooks = {} } = plugin;
+    Object.keys(registryHooks).forEach((hookName) => {
+      extendsHooks[hookName] = registryHooks[hookName];
+    });
+  });
+  return {
+    ...runtimeContext,
+    hooks: {
+      ...initHooks(),
+      ...extendsHooks
+    },
+    extendsHooks,
+    config
+  };
+}
+export {
+  createRuntimeContext,
+  initRuntimeContext
+};

package/dist/esm-node/runtime/hooks.js

@@ -0,0 +1,12 @@
+import { createAsyncInterruptHook, createCollectSyncHook, createSyncHook } from "../hooks";
+function initHooks() {
+  return {
+    onBeforeRender: createAsyncInterruptHook(),
+    wrapRoot: createSyncHook(),
+    pickContext: createSyncHook(),
+    modifyRuntimeConfig: createCollectSyncHook()
+  };
+}
+export {
+  initHooks
+};

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

@@ -0,0 +1,11 @@
+import { initPluginAPI } from "./api";
+import { initRuntimeContext, createRuntimeContext } from "./context";
+import { initHooks } from "./hooks";
+import { runtime } from "./run";
+export {
+  createRuntimeContext,
+  initHooks,
+  initPluginAPI,
+  initRuntimeContext,
+  runtime
+};

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

@@ -0,0 +1,50 @@
+import { merge } from "@modern-js/runtime-utils/merge";
+import { createPluginManager } from "../../manager";
+import { initPluginAPI } from "../../runtime/api";
+import { createRuntimeContext, initRuntimeContext } from "../../runtime/context";
+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) {
+      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 {
+      runtimeContext: context
+    };
+  }
+  function run(options) {
+    const { runtimeContext } = init(options);
+    const configs = runtimeContext.hooks.modifyRuntimeConfig.call(runtimeContext.config).filter((config) => Boolean(config));
+    runtimeContext.config = merge({}, ...configs);
+    return {
+      runtimeContext
+    };
+  }
+  return {
+    run
+  };
+};
+export {
+  createRuntime
+};

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

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

package/dist/types/hooks.d.ts

@@ -1,3 +1,6 @@
-import type { AsyncHook, CollectAsyncHook } from './types/hooks';
+import type { AsyncHook, AsyncInterruptHook, 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>;

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 export { createPluginManager } from './manager';
-export { createAsyncHook, createCollectAsyncHook } from './hooks';
+export { createSyncHook, createAsyncHook, createCollectSyncHook, createCollectAsyncHook, createAsyncInterruptHook, } from './hooks';
 export type { Plugin, PluginManager, TransformFunction, } from './types/plugin';
 export type { CLIPluginAPI, AppContext, InternalContext, Entrypoint, CLIPlugin, CLIPluginExtends, } from './types/cli';
+export type { RuntimePluginAPI, RuntimeContext, InternalRuntimeContext, RuntimePlugin, RuntimePluginExtends, } from './types/runtime';
 export type { AsyncHook, CollectAsyncHook, PluginHook, PluginHookTap, } from './types/hooks';

package/dist/types/manager.d.ts

@@ -1,2 +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/types/hooks.d.ts

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

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

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

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

@@ -18,7 +18,7 @@ export type Plugin<PluginAPI = {}, Context = {}> = {
     /**
      * The plugins add new apis to the plugin manager.
      */
-    _registryApi?: (getAppContext: () => Context, updateAppContext: (context: Context) => void) => Record<string, (...args: any[]) => any>;
+    _registryApi?: (...params: any[]) => Record<string, (...args: any[]) => any>;
     /**
      * The setup function of the plugin, which can be an async function.
      * This function is called once when the plugin is initialized.

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

@@ -0,0 +1,15 @@
+import type { PluginHookTap } from '../hooks';
+import type { DeepPartial } from '../utils';
+import type { RuntimeContext } from './context';
+import type { Hooks } from './hooks';
+import type { ModifyRuntimeConfigFn, OnBeforeRenderFn, PickContextFn, WrapRootFn } from './hooks';
+import type { RuntimePluginExtends } from './plugin';
+export type RuntimePluginAPI<Extends extends RuntimePluginExtends> = Readonly<{
+    updateRuntimeContext: (updateContext: DeepPartial<RuntimeContext>) => void;
+    getHooks: () => Readonly<Hooks<Extends['config'], RuntimeContext & Extends['extendContext']> & Extends['extendHooks']>;
+    getRuntimeConfig: () => Readonly<Extends['config']>;
+    onBeforeRender: PluginHookTap<OnBeforeRenderFn<Extends['extendContext']>>;
+    wrapRoot: PluginHookTap<WrapRootFn>;
+    pickContext: PluginHookTap<PickContextFn<RuntimeContext>>;
+    modifyRuntimeConfig: PluginHookTap<ModifyRuntimeConfigFn<Extends['config']>>;
+}>;

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

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

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

@@ -0,0 +1,12 @@
+import type React from 'react';
+import type { AsyncInterruptHook, CollectSyncHook, SyncHook } from '../hooks';
+export type OnBeforeRenderFn<RuntimeContext> = (context: RuntimeContext, interrupt: (info: any) => any) => Promise<any> | any;
+export type WrapRootFn = (root: React.ComponentType<any>) => React.ComponentType<any>;
+export type PickContextFn<RuntimeContext> = (context: RuntimeContext) => RuntimeContext;
+export type ModifyRuntimeConfigFn<RuntimeConfig> = (config: RuntimeConfig) => RuntimeConfig;
+export type Hooks<RuntimeConfig, RuntimeContext> = {
+    onBeforeRender: AsyncInterruptHook<OnBeforeRenderFn<RuntimeContext>>;
+    wrapRoot: SyncHook<WrapRootFn>;
+    pickContext: SyncHook<PickContextFn<RuntimeContext>>;
+    modifyRuntimeConfig: CollectSyncHook<ModifyRuntimeConfigFn<RuntimeConfig>>;
+};

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

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

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

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

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

@@ -4,3 +4,4 @@ export type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
 };
 export type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
+export type Tail<T extends any[]> = T extends [...infer Rest, any] ? Rest : never;