@modern-js/plugin-v2 0.0.0-next-20241113090110

package/dist/esm-node/cli/run/utils/mergeConfig.js

@@ -0,0 +1,38 @@
+import { ensureArray, isOverriddenConfigKey } from "@modern-js/utils";
+import { isFunction, mergeWith } from "@modern-js/utils/lodash";
+const mergeConfig = (configs) => mergeWith({}, ...configs, (target, source, key) => {
+  if (key === "designSystem" || key === "tailwindcss" && typeof source === "object") {
+    return mergeWith({}, target !== null && target !== void 0 ? target : {}, source !== null && source !== void 0 ? source : {});
+  }
+  if (isOverriddenConfigKey(key)) {
+    return source !== null && source !== void 0 ? source : target;
+  }
+  if (Array.isArray(target) || Array.isArray(source)) {
+    if (target === void 0) {
+      return source;
+    }
+    if (source === void 0) {
+      return target;
+    }
+    return [
+      ...ensureArray(target),
+      ...ensureArray(source)
+    ];
+  }
+  if (isFunction(target) || isFunction(source)) {
+    if (source === void 0) {
+      return target;
+    }
+    if (target === void 0) {
+      return source;
+    }
+    return [
+      target,
+      source
+    ];
+  }
+  return void 0;
+});
+export {
+  mergeConfig
+};

package/dist/esm-node/hooks.js

@@ -0,0 +1,44 @@
+function createAsyncHook() {
+  const callbacks = [];
+  const tap = (cb) => {
+    callbacks.push(cb);
+  };
+  const call = async (...params) => {
+    for (const callback of callbacks) {
+      const result = await callback(...params);
+      if (result !== void 0) {
+        params[0] = result;
+      }
+    }
+    return params[0] || [];
+  };
+  return {
+    tap,
+    call
+  };
+}
+function createCollectAsyncHook() {
+  const callbacks = [];
+  const tap = (cb) => {
+    callbacks.push(cb);
+  };
+  const call = async (...params) => {
+    const results = [];
+    for (const callback of callbacks) {
+      const result = await callback(...params);
+      if (result !== void 0) {
+        params[0] = result;
+        results.push(result);
+      }
+    }
+    return results;
+  };
+  return {
+    tap,
+    call
+  };
+}
+export {
+  createAsyncHook,
+  createCollectAsyncHook
+};

package/dist/esm-node/index.js

@@ -0,0 +1,9 @@
+import { createPluginManager } from "./manager";
+import { createAsyncHook, createCollectAsyncHook } from "./hooks";
+export * from "./cli";
+export * from "./types";
+export {
+  createAsyncHook,
+  createCollectAsyncHook,
+  createPluginManager
+};

package/dist/esm-node/manager.js

@@ -0,0 +1,117 @@
+import { createDebugger, isFunction, logger } from "@modern-js/utils";
+const debug = createDebugger("plugin-v2");
+function validatePlugin(plugin) {
+  const type = typeof plugin;
+  if (type !== "object" || plugin === null) {
+    throw new Error(`Expect CLI Plugin instance to be an object, but got ${type}.`);
+  }
+  if (isFunction(plugin.setup)) {
+    return;
+  }
+  throw new Error(`Expect CLI Plugin plugin.setup to be a function, but got ${type}.`);
+}
+function createPluginManager() {
+  const plugins = /* @__PURE__ */ new Map();
+  const dependencies = /* @__PURE__ */ new Map();
+  const addDependency = (plugin, dependency, type) => {
+    if (!dependencies.has(dependency)) {
+      dependencies.set(dependency, {
+        pre: /* @__PURE__ */ new Map(),
+        post: /* @__PURE__ */ new Map()
+      });
+    }
+    if (type === "pre") {
+      dependencies.get(plugin).pre.set(dependency, {
+        name: dependency,
+        isUse: false
+      });
+    } else if (type === "post") {
+      dependencies.get(plugin).post.set(dependency, {
+        name: dependency
+      });
+    } else if (type === "use") {
+      if (!dependencies.get(plugin).post.has(dependency)) {
+        dependencies.get(plugin).pre.set(dependency, {
+          name: dependency,
+          isUse: true
+        });
+      }
+    }
+  };
+  const addPlugin = (newPlugin) => {
+    if (!newPlugin) {
+      return;
+    }
+    validatePlugin(newPlugin);
+    const { name, usePlugins = [], pre = [], post = [] } = newPlugin;
+    if (plugins.has(name)) {
+      logger.warn(`Plugin ${name} already exists.`);
+      return;
+    }
+    plugins.set(name, newPlugin);
+    dependencies.set(name, {
+      pre: /* @__PURE__ */ new Map(),
+      post: /* @__PURE__ */ new Map()
+    });
+    pre.forEach((dep) => {
+      addDependency(name, dep, "pre");
+    });
+    post.forEach((dep) => {
+      addDependency(name, dep, "post");
+    });
+    usePlugins.forEach((plugin) => {
+      if (!plugins.has(plugin.name)) {
+        addPlugin(plugin);
+      }
+      addDependency(name, plugin.name, "use");
+    });
+  };
+  const addPlugins = (newPlugins) => {
+    for (const newPlugin of newPlugins) {
+      addPlugin(newPlugin);
+    }
+  };
+  const getPlugins = () => {
+    const visited = /* @__PURE__ */ new Set();
+    const temp = /* @__PURE__ */ new Set();
+    let result = [];
+    const visit = (name) => {
+      if (temp.has(name)) {
+        throw new Error(`Circular dependency detected: ${name}`);
+      }
+      if (!visited.has(name)) {
+        temp.add(name);
+        const { pre } = dependencies.get(name);
+        Array.from(pre.values()).filter((dep) => !dep.isUse).forEach((dep) => visit(dep.name));
+        Array.from(pre.values()).filter((dep) => dep.isUse).forEach((dep) => visit(dep.name));
+        temp.delete(name);
+        visited.add(name);
+        result.push(plugins.get(name));
+      }
+    };
+    plugins.forEach((_, name) => {
+      const { post } = dependencies.get(name);
+      post.forEach((dep) => {
+        if (!dependencies.get(dep.name).pre.has(name)) {
+          dependencies.get(dep.name).pre.set(name, {
+            name,
+            isUse: false
+          });
+        }
+      });
+    });
+    plugins.forEach((_, name) => {
+      visit(name);
+    });
+    result = result.filter((result2) => result2);
+    debug("CLI Plugins:", result.map((p) => p.name));
+    return result;
+  };
+  return {
+    getPlugins,
+    addPlugins
+  };
+}
+export {
+  createPluginManager
+};

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

@@ -0,0 +1,2 @@
+export * from "./cli";
+export * from "./hooks";

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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+export { initPluginAPI } from './api';
+export { initAppContext } from './context';
+export { initHooks } from './hooks';
+export { cli } from './run';
+export { initAppDir } from './run/utils/initAppDir';
+export { createLoadedConfig } from '../cli/run/config/createLoadedConfig';

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

@@ -0,0 +1,6 @@
+import type { LoadedConfig } from '../types';
+/**
+ * Assign the pkg config into the user config.
+ */
+export declare function assignPkgConfig<T>(userConfig: T, pkgConfig: T): {} & T;
+export declare function createLoadedConfig<T>(appDirectory: string, configFilePath: string, packageJsonConfig?: string, loadedConfig?: T): Promise<LoadedConfig<T>>;

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

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

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

@@ -0,0 +1,25 @@
+/**
+ * Get user config from package.json.
+ * @param appDirectory - App root directory.
+ * @returns modernConfig or undefined
+ */
+export declare const getPackageConfig: <T>(appDirectory: string, packageJsonConfig: string) => T | undefined;
+export declare const getConfigFilePath: (appDirectory: string, configFilePath: string) => string;
+/**
+ *
+ * @param targetDir target dir
+ * @param overtime Unit of second
+ */
+export declare const clearFilesOverTime: (targetDir: string, overtime: number) => Promise<void>;
+/**
+ * Parse and load user config file, support extensions like .ts, mjs, js, ejs.
+ * @param appDirectory - App root directory, from which start search user config file.
+ * @param configFile - Specific absolute config file path.
+ * @returns Object contain config file path, user config object and dependency files used by config file.
+ */
+export declare const loadConfig: <T>(appDirectory: string, configFile: string, packageJsonConfig?: string, loadedConfig?: T) => Promise<{
+    packageName: string;
+    configFile: string;
+    config?: T;
+    pkgConfig?: T;
+}>;

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

@@ -0,0 +1,7 @@
+import type { CLIRunOptions } from './types';
+export declare const createCli: <Config, NormalizedConfig, ExtendsHooksKey extends string>() => {
+    init: (options: CLIRunOptions<Config>) => Promise<{
+        appContext: import("../..").InternalContext<Config, NormalizedConfig, ExtendsHooksKey>;
+    }>;
+    run: (options: CLIRunOptions<Config>) => Promise<void>;
+};

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

@@ -0,0 +1,6 @@
+export declare const cli: {
+    init: (options: import("./types").CLIRunOptions<unknown>) => Promise<{
+        appContext: import("../..").InternalContext<unknown, unknown, string>;
+    }>;
+    run: (options: import("./types").CLIRunOptions<unknown>) => Promise<void>;
+};

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

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

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

@@ -0,0 +1,29 @@
+import type { Plugin } from '../../types/plugin';
+export interface CLIOptions<Config> {
+    cwd?: string;
+    version?: string;
+    metaName?: string;
+    /**
+     * The initial log message when CLI started
+     */
+    initialLog?: string;
+    configFile: string;
+    /**
+     * @deprecated
+     * `package.json` config field, will be removed in the future, expect use configFile instead
+     */
+    packageJsonConfig?: string;
+    loadedConfig?: Config;
+    internalPlugins?: Plugin[];
+    handleSetupResult?: (params: any, api: Record<string, any>) => Promise<void> | void;
+}
+export type LoadedConfig<T> = {
+    packageName: string;
+    configFile: string;
+    config: T;
+    pkgConfig?: T;
+    jsConfig?: T;
+};
+export interface CLIRunOptions<Config> extends CLIOptions<Config> {
+    command: string;
+}

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

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

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

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

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

@@ -0,0 +1,2 @@
+import type { InternalContext } from '../../../types';
+export declare const createFileWatcher: <Config, NormalizedConfig, ExtendsHooksKey extends string>(appContext: InternalContext<Config, NormalizedConfig, ExtendsHooksKey>) => Promise<import("@modern-js/utils").FSWatcher | undefined>;

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

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

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

@@ -0,0 +1 @@
+export declare const loadEnv: (appDirectory: string, mode?: string) => void;

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

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

package/dist/types/hooks.d.ts

@@ -0,0 +1,3 @@
+import type { AsyncHook, CollectAsyncHook } from './types/hooks';
+export declare function createAsyncHook<Callback extends (...args: any[]) => any>(): AsyncHook<Callback>;
+export declare function createCollectAsyncHook<Callback extends (...args: any[]) => any>(): CollectAsyncHook<Callback>;

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export { createPluginManager } from './manager';
+export { createAsyncHook, createCollectAsyncHook } from './hooks';
+export * from './cli';
+export * from './types';

package/dist/types/manager.d.ts

@@ -0,0 +1,2 @@
+import type { PluginManager } from './types/plugin';
+export declare function createPluginManager(): PluginManager;

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

@@ -0,0 +1,42 @@
+import type { ModifyBundlerChainFn, ModifyRsbuildConfigFn, ModifyRspackConfigFn, ModifyWebpackChainFn, ModifyWebpackConfigFn, OnAfterBuildFn, OnAfterCreateCompilerFn, OnBeforeBuildFn, OnBeforeCreateCompilerFn } from '@rsbuild/core';
+import type { Hooks } from '../../cli/hooks';
+import type { PluginHook, PluginHookTap } from '../hooks';
+import type { DeepPartial } from '../utils';
+import type { AppContext } from './context';
+import type { AddCommandFn, AddWatchFilesFn, ConfigFn, ModifyConfigFn, ModifyHtmlPartialsFn, ModifyResolvedConfigFn, OnAfterDeployFn, OnAfterDevFn, OnBeforeDeployFn, OnBeforeDevFn, OnBeforeExitFn, OnBeforeRestartFn, OnFileChangedFn, OnPrepareFn } from './hooks';
+/**
+ * Define a generic CLI plugin API that provider can extend as needed.
+ */
+export type CLIPluginAPI<Config, NormalizedConfig> = Readonly<{
+    getAppContext: () => Readonly<AppContext<Config, NormalizedConfig>>;
+    getConfig: () => Readonly<Config>;
+    getNormalizedConfig: () => Readonly<NormalizedConfig>;
+    getHooks: () => Readonly<Hooks<Config, NormalizedConfig> & Record<string, PluginHook<(...args: any[]) => any>>>;
+    updateAppContext: (appContext: DeepPartial<AppContext<Config, NormalizedConfig>>) => void;
+    config: PluginHookTap<ConfigFn<DeepPartial<Config>>>;
+    modifyConfig: PluginHookTap<ModifyConfigFn<Config>>;
+    modifyResolvedConfig: PluginHookTap<ModifyResolvedConfigFn<NormalizedConfig>>;
+    modifyRsbuildConfig: PluginHookTap<ModifyRsbuildConfigFn>;
+    modifyBundlerChain: PluginHookTap<ModifyBundlerChainFn>;
+    /** Only works when bundler is Rspack */
+    modifyRspackConfig: PluginHookTap<ModifyRspackConfigFn>;
+    /** Only works when bundler is Webpack */
+    modifyWebpackChain: PluginHookTap<ModifyWebpackChainFn>;
+    /** Only works when bundler is Webpack */
+    modifyWebpackConfig: PluginHookTap<ModifyWebpackConfigFn>;
+    modifyHtmlPartials: PluginHookTap<ModifyHtmlPartialsFn>;
+    addCommand: PluginHookTap<AddCommandFn>;
+    onPrepare: PluginHookTap<OnPrepareFn>;
+    onWatchFiles: PluginHookTap<AddWatchFilesFn>;
+    onFileChanged: PluginHookTap<OnFileChangedFn>;
+    onBeforeRestart: PluginHookTap<OnBeforeRestartFn>;
+    onBeforeCreateCompiler: PluginHookTap<OnBeforeCreateCompilerFn>;
+    onAfterCreateCompiler: PluginHookTap<OnAfterCreateCompilerFn>;
+    onBeforeBuild: PluginHookTap<OnBeforeBuildFn>;
+    onAfterBuild: PluginHookTap<OnAfterBuildFn>;
+    onBeforeDev: PluginHookTap<OnBeforeDevFn>;
+    onAfterDev: PluginHookTap<OnAfterDevFn>;
+    onBeforeDeploy: PluginHookTap<OnBeforeDeployFn>;
+    onAfterDeploy: PluginHookTap<OnAfterDeployFn>;
+    onBeforeExit: PluginHookTap<OnBeforeExitFn>;
+}>;

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

@@ -0,0 +1,40 @@
+import type { ServerRoute } from '@modern-js/types';
+import type { UniBuilderInstance, UniBuilderWebpackInstance } from '@modern-js/uni-builder';
+import type { Hooks } from '../../cli/hooks';
+import type { AsyncHook } from '../hooks';
+import type { CLIPluginAPI } from './api';
+import type { CLIPlugin } from './plugin';
+export interface Entrypoint {
+    name: string;
+    entry: string;
+}
+/** The public context */
+export type AppContext<Config, NormalizedConfig> = {
+    packageName: string;
+    configFile: string;
+    command: string;
+    isProd: boolean;
+    appDirectory: string;
+    srcDirectory?: string;
+    distDirectory?: string;
+    nodeModulesDirectory?: string;
+    plugins: CLIPlugin<Config, NormalizedConfig>[];
+    bundlerType?: 'webpack' | 'rspack' | 'esbuild';
+    builder?: UniBuilderInstance | UniBuilderWebpackInstance;
+    port?: number;
+    host?: string;
+    ip?: string;
+    serverRoutes?: ServerRoute[];
+};
+/** The inner context. */
+export type InternalContext<Config, NormalizedConfig, ExtendsHooksKey extends string> = AppContext<Config, NormalizedConfig> & {
+    /** All hooks. */
+    hooks: Hooks<Config, NormalizedConfig> & Record<ExtendsHooksKey, AsyncHook<(...args: any[]) => any>>;
+    /** All plugin registry hooks */
+    extendsHooks: Record<ExtendsHooksKey, AsyncHook<(...args: any[]) => any>>;
+    /** Current App config. */
+    config: Readonly<Config>;
+    /** The normalized Rsbuild config. */
+    normalizedConfig?: NormalizedConfig;
+    pluginAPI?: CLIPluginAPI<Config, NormalizedConfig> & Record<string, (...args: any[]) => any>;
+};

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

@@ -0,0 +1,41 @@
+import type { Command } from '@modern-js/utils/commander';
+import type { TransformFunction } from '../plugin';
+import type { Entrypoint } from './context';
+export type ConfigFn<Config> = () => Config;
+export type ModifyConfigFn<Config> = TransformFunction<Config>;
+export type ModifyResolvedConfigFn<NormalizedConfig> = TransformFunction<NormalizedConfig>;
+type IPartialMethod = (...script: string[]) => void;
+export interface PartialMethod {
+    append: IPartialMethod;
+    prepend: IPartialMethod;
+}
+export type ModifyHtmlPartialsFn = (params: {
+    entrypoint: Entrypoint;
+    partials: {
+        top: PartialMethod;
+        head: PartialMethod;
+        body: PartialMethod;
+    };
+}) => Promise<void> | void;
+export type AddCommandFn = (params: {
+    program: Command;
+}) => void;
+export type OnPrepareFn = () => Promise<void> | void;
+export type AddWatchFilesFn = () => Array<string> | {
+    files: string[];
+    isPrivate: boolean;
+};
+export type OnFileChangedFn = (params: {
+    filename: string;
+    eventType: 'add' | 'change' | 'unlink';
+    isPrivate: boolean;
+}) => void;
+export type OnBeforeRestartFn = () => Promise<void> | void;
+export type OnBeforeDevFn = () => Promise<void> | void;
+export type OnAfterDevFn = (params: {
+    isFirstCompile: boolean;
+}) => Promise<void> | void;
+export type OnBeforeDeployFn = () => Promise<void> | void;
+export type OnAfterDeployFn = () => Promise<void> | void;
+export type OnBeforeExitFn = () => void;
+export {};

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

@@ -0,0 +1,3 @@
+export type { CLIPluginAPI } from './api';
+export type { AppContext, InternalContext, Entrypoint } from './context';
+export type { CLIPlugin } from './plugin';

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

@@ -0,0 +1,6 @@
+import type { Plugin } from '../plugin';
+import type { CLIPluginAPI } from './api';
+/**
+ * The type of the CLI plugin object.
+ */
+export type CLIPlugin<Config, NormalizedConfig> = Plugin<CLIPluginAPI<Config, NormalizedConfig>>;

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

@@ -0,0 +1,10 @@
+export type AsyncHook<Callback extends (...args: any[]) => any> = {
+    tap: (cb: Callback) => void;
+    call: (...args: Parameters<Callback>) => Promise<Parameters<Callback>>;
+};
+export type CollectAsyncHook<Callback extends (...args: any[]) => any> = {
+    tap: (cb: Callback) => void;
+    call: (...args: Parameters<Callback>) => Promise<ReturnType<Callback>[]>;
+};
+export type PluginHook<Callback extends (...args: any[]) => any> = AsyncHook<Callback> | CollectAsyncHook<Callback>;
+export type PluginHookTap<T extends (...args: any[]) => any> = (options: T) => void;

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

@@ -0,0 +1,3 @@
+export type { Plugin, PluginManager, TransformFunction, } from './plugin';
+export * from './cli';
+export * from './hooks';

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

@@ -0,0 +1,40 @@
+import type { PluginHook } from './hooks';
+import type { Falsy } from './utils';
+import type { MaybePromise } from './utils';
+export type TransformFunction<T> = (arg: T) => T | Promise<T>;
+export type Plugin<PluginAPI = {}, Context = {}> = {
+    /**
+     * The name of the plugin, a unique identifier.
+     */
+    name: string;
+    /**
+     * The plugins that this plugin depends on.
+     */
+    usePlugins?: Plugin<PluginAPI, Context>[];
+    /**
+     * The plugins add new hooks to the plugin manager.
+     */
+    registryHooks?: Record<string, PluginHook<(...args: any[]) => any>>;
+    /**
+     * The plugins add new apis to the plugin manager.
+     */
+    registryApi?: (context: Context, updateAppContext: (context: Context) => void) => 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.
+     * @param api provides the context info, utility functions and lifecycle hooks.
+     */
+    setup: (api: PluginAPI) => MaybePromise<void>;
+    /**
+     * Declare the names of pre-plugins, which will be executed before the current plugin.
+     */
+    pre?: string[];
+    /**
+     * Declare the names of post-plugins, which will be executed after the current plugin.
+     */
+    post?: string[];
+};
+export type PluginManager = {
+    getPlugins: () => Plugin[];
+    addPlugins: (plugins: Array<Plugin | Falsy>) => void;
+};

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

@@ -0,0 +1,5 @@
+export type Falsy = false | null | undefined;
+export type MaybePromise<T> = T | Promise<T>;
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};