umi 3.5.20 → 4.0.0-beta.12

package/README.md

@@ -1,54 +1,3 @@
-English | [简体中文](https://github.com/umijs/umi/blob/master/README.zh-CN.md)
-
 # umi
 
-[![codecov](https://codecov.io/gh/umijs/umi/branch/master/graph/badge.svg)](https://codecov.io/gh/umijs/umi) [![NPM version](https://img.shields.io/npm/v/umi.svg?style=flat)](https://npmjs.org/package/umi) [![CircleCI](https://circleci.com/gh/umijs/umi/tree/master.svg?style=svg)](https://circleci.com/gh/umijs/umi/tree/master) [![Build Status](https://dev.azure.com/umijs/umi/_apis/build/status/umijs.umi?branchName=master)](https://dev.azure.com/umijs/umi/_build/latest?definitionId=1&branchName=master) [![GitHub Actions status](https://github.com/umijs/umi/workflows/Node%20CI/badge.svg)](https://github.com/umijs/umi) [![NPM downloads](http://img.shields.io/npm/dm/umi.svg?style=flat)](https://npmjs.org/package/umi) [![Install size](https://badgen.net/packagephobia/install/umi)](https://packagephobia.now.sh/result?p=umi)
-
-🍙 Extensible enterprise-level front-end application framework.
-
-> Please consider following this project's author, [sorrycc](https://github.com/sorrycc), and consider starring the project to show your ❤️ and support.
-
----
-
-## Features
-
-- 🎉 **Extensible**, Umi implements the complete lifecycle and makes it extensible, and Umi's internal functions are all plugins. Umi also support plugins and presets.
-- 📦 **Out of the Box**, Umi has built-in routing, building, deployment, testing, and so on. It only requires one dependency to get started. Umi also provides an integrated preset for React with rich functionaries.
-- 🐠 **Enterprise**, It has been verified by 3000+ projects in Ant Financial and projects of Alibaba, Youku, Netease, 飞猪, KouBei and other companies.
-- 🚀 **Self Development**, Including micro frontend library, component packaging, documentation tools, request library, hooks library, data flow, etc.
-- 🌴 **Perfect Routing**, Supports both configuration routing and convention routing, while with functional completeness, such as dynamic routing, nested routing, permission routing, and so on.
-- 🚄 **Future Ready**, Umi's community is also exploring new technologies. For example, modern mode, webpack @ 5, automated external, bundler less, etc.
-
-## Getting Started
-
-Manually,
-
-```bash
-# Create directory
-$ mkdir myapp && cd myapp
-
-# Install dependency
-$ yarn add umi
-
-# Create page
-$ npx umi g page index --typescript --less
-
-# Start development
-$ npx umi dev
-```
-
-Or [Getting Started with Boilerplate](https://umijs.org/docs/getting-started).
-
-## Contributors
-
-This project exists thanks to all the people who contribute. [[Contribute](https://umijs.org/docs/contributing)]. <a href="https://github.com/umijs/umi/graphs/contributors"><img src="https://opencollective.com/umi/contributors.svg?width=890&button=false" /></a>
-
-## Feedback
-
-| Github Issue | 微信群 |
-| --- | --- |
-| [umijs/umi/issues](https://github.com/umijs/umi/issues) | <img src="https://img.alicdn.com/imgextra/i1/O1CN01jmrjUx1yw5LcPFMx0_!!6000000006642-0-tps-430-430.jpg" width="60" /> 关注后回复「umi」 |
-
-## LICENSE
-
-[MIT](https://github.com/umijs/umi/blob/master/LICENSE)
+See our website [umijs](https://umijs.org) for more information.

package/bin/forkedDev.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+require('v8-compile-cache');
+require('../dist/cli/forkedDev');

package/bin/umi.js

@@ -1,15 +1,9 @@
 #!/usr/bin/env node
 
 require('v8-compile-cache');
-
-const resolveCwd = require('@umijs/deps/compiled/resolve-cwd');
-
-const { name, bin } = require('../package.json');
-const localCLI = resolveCwd.silent(`${name}/${bin['umi']}`);
-if (!process.env.USE_GLOBAL_UMI && localCLI && localCLI !== __filename) {
-  const debug = require('@umijs/utils').createDebug('umi:cli');
-  debug('Using local install of umi');
-  require(localCLI);
-} else {
-  require('../lib/cli');
-}
+require('../dist/cli/cli')
+  .run()
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });

package/client/client/plugin.d.ts

@@ -0,0 +1,34 @@
+export declare enum ApplyPluginsType {
+    compose = "compose",
+    modify = "modify",
+    event = "event"
+}
+interface IPlugin {
+    path?: string;
+    apply: Record<string, any>;
+}
+export declare class PluginManager {
+    opts: {
+        validKeys: string[];
+    };
+    hooks: {
+        [key: string]: any;
+    };
+    constructor(opts: {
+        validKeys: string[];
+    });
+    register(plugin: IPlugin): void;
+    getHooks(keyWithDot: string): any;
+    applyPlugins({ key, type, initialValue, args, async, }: {
+        key: string;
+        type: ApplyPluginsType;
+        initialValue?: any;
+        args?: object;
+        async?: boolean;
+    }): any;
+    static create(opts: {
+        validKeys: string[];
+        plugins: IPlugin[];
+    }): PluginManager;
+}
+export {};

package/client/client/plugin.js

@@ -0,0 +1,121 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { assert, compose, isPromiseLike } from './utils';
+export var ApplyPluginsType;
+(function (ApplyPluginsType) {
+    ApplyPluginsType["compose"] = "compose";
+    ApplyPluginsType["modify"] = "modify";
+    ApplyPluginsType["event"] = "event";
+})(ApplyPluginsType || (ApplyPluginsType = {}));
+export class PluginManager {
+    constructor(opts) {
+        this.hooks = {};
+        this.opts = opts;
+    }
+    register(plugin) {
+        assert(plugin.apply && plugin.path, `plugin register failed, apply and path must supplied`);
+        Object.keys(plugin.apply).forEach((key) => {
+            assert(this.opts.validKeys.indexOf(key) > -1, `register failed, invalid key ${key} from plugin ${plugin.path}.`);
+            this.hooks[key] = (this.hooks[key] || []).concat(plugin.apply[key]);
+        });
+    }
+    getHooks(keyWithDot) {
+        const [key, ...memberKeys] = keyWithDot.split('.');
+        let hooks = this.hooks[key] || [];
+        if (memberKeys.length) {
+            hooks = hooks
+                .map((hook) => {
+                try {
+                    let ret = hook;
+                    for (const memberKey of memberKeys) {
+                        ret = ret[memberKey];
+                    }
+                    return ret;
+                }
+                catch (e) {
+                    return null;
+                }
+            })
+                .filter(Boolean);
+        }
+        return hooks;
+    }
+    applyPlugins({ key, type, initialValue, args, async, }) {
+        const hooks = this.getHooks(key) || [];
+        if (args) {
+            assert(typeof args === 'object', `applyPlugins failed, args must be plain object.`);
+        }
+        switch (type) {
+            case ApplyPluginsType.modify:
+                if (async) {
+                    return hooks.reduce((memo, hook) => __awaiter(this, void 0, void 0, function* () {
+                        assert(typeof hook === 'function' ||
+                            typeof hook === 'object' ||
+                            isPromiseLike(hook), `applyPlugins failed, all hooks for key ${key} must be function, plain object or Promise.`);
+                        if (isPromiseLike(memo)) {
+                            memo = yield memo;
+                        }
+                        if (typeof hook === 'function') {
+                            const ret = hook(memo, args);
+                            if (isPromiseLike(ret)) {
+                                return yield ret;
+                            }
+                            else {
+                                return ret;
+                            }
+                        }
+                        else {
+                            if (isPromiseLike(hook)) {
+                                hook = yield hook;
+                            }
+                            return Object.assign(Object.assign({}, memo), hook);
+                        }
+                    }), isPromiseLike(initialValue)
+                        ? initialValue
+                        : Promise.resolve(initialValue));
+                }
+                else {
+                    return hooks.reduce((memo, hook) => {
+                        assert(typeof hook === 'function' || typeof hook === 'object', `applyPlugins failed, all hooks for key ${key} must be function or plain object.`);
+                        if (typeof hook === 'function') {
+                            return hook(memo, args);
+                        }
+                        else {
+                            // TODO: deepmerge?
+                            return Object.assign(Object.assign({}, memo), hook);
+                        }
+                    }, initialValue);
+                }
+            case ApplyPluginsType.event:
+                return hooks.forEach((hook) => {
+                    assert(typeof hook === 'function', `applyPlugins failed, all hooks for key ${key} must be function.`);
+                    hook(args);
+                });
+            case ApplyPluginsType.compose:
+                return () => {
+                    return compose({
+                        fns: hooks.concat(initialValue),
+                        args,
+                    })();
+                };
+        }
+    }
+    static create(opts) {
+        const pluginManager = new PluginManager({
+            validKeys: opts.validKeys,
+        });
+        opts.plugins.forEach((plugin) => {
+            pluginManager.register(plugin);
+        });
+        return pluginManager;
+    }
+}
+// plugins meta info (in tmp file)
+// hooks api: usePlugin

package/client/client/utils.d.ts

@@ -0,0 +1,6 @@
+export declare function assert(value: unknown, message: string): void;
+export declare function compose({ fns, args, }: {
+    fns: (Function | any)[];
+    args?: object;
+}): any;
+export declare function isPromiseLike(obj: any): boolean;

package/client/client/utils.js

@@ -0,0 +1,14 @@
+export function assert(value, message) {
+    if (!value)
+        throw new Error(message);
+}
+export function compose({ fns, args, }) {
+    if (fns.length === 1) {
+        return fns[0];
+    }
+    const last = fns.pop();
+    return fns.reduce((a, b) => () => b(a, args), last);
+}
+export function isPromiseLike(obj) {
+    return !!obj && typeof obj === 'object' && typeof obj.then === 'function';
+}

package/dist/cli/cli.d.ts

@@ -0,0 +1,5 @@
+interface IOpts {
+    presets?: string[];
+}
+export declare function run(opts?: IOpts): Promise<void>;
+export {};

package/dist/cli/cli.js

@@ -0,0 +1,58 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const utils_1 = require("@umijs/utils");
+const constants_1 = require("../constants");
+const service_1 = require("../service/service");
+const dev_1 = require("./dev");
+const node_1 = require("./node");
+function run(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        (0, node_1.checkVersion)();
+        (0, node_1.checkLocal)();
+        (0, node_1.setNodeTitle)();
+        (0, node_1.setNoDeprecation)();
+        const args = (0, utils_1.yParser)(process.argv.slice(2), {
+            alias: {
+                version: ['v'],
+                help: ['h'],
+            },
+            boolean: ['version'],
+        });
+        const command = args._[0];
+        if ([constants_1.DEV_COMMAND, 'setup'].includes(command)) {
+            process.env.NODE_ENV = 'development';
+        }
+        else if (command === 'build') {
+            process.env.NODE_ENV = 'production';
+        }
+        if (opts === null || opts === void 0 ? void 0 : opts.presets) {
+            process.env.UMI_PRESETS = opts.presets.join(',');
+        }
+        if (command === constants_1.DEV_COMMAND) {
+            (0, dev_1.dev)();
+        }
+        else {
+            try {
+                yield new service_1.Service().run2({
+                    name: args._[0],
+                    args,
+                });
+            }
+            catch (e) {
+                utils_1.logger.error(e);
+                process.exit(1);
+            }
+        }
+    });
+}
+exports.run = run;

package/dist/cli/dev.d.ts

@@ -0,0 +1 @@
+export declare function dev(): void;

package/dist/cli/dev.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dev = void 0;
+const fork_1 = __importDefault(require("./fork"));
+function dev() {
+    const child = (0, fork_1.default)({
+        scriptPath: require.resolve('../../bin/forkedDev'),
+    });
+    // ref:
+    // http://nodejs.cn/api/process/signal_events.html
+    // https://lisk.io/blog/development/why-we-stopped-using-npm-start-child-processes
+    process.on('SIGINT', () => {
+        child.kill('SIGINT');
+        // ref:
+        // https://github.com/umijs/umi/issues/6009
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        child.kill('SIGTERM');
+        process.exit(1);
+    });
+}
+exports.dev = dev;

package/dist/cli/fork.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const usedPorts = [];
+function start({ scriptPath }) {
+    const execArgv = process.execArgv.slice(0);
+    const inspectArgvIndex = execArgv.findIndex((argv) => argv.includes('--inspect-brk'));
+    if (inspectArgvIndex > -1) {
+        const inspectArgv = execArgv[inspectArgvIndex];
+        execArgv.splice(inspectArgvIndex, 1, inspectArgv.replace(/--inspect-brk=(.*)/, (_match, s1) => {
+            let port;
+            try {
+                port = parseInt(s1) + 1;
+            }
+            catch (e) {
+                port = 9230; // node default inspect port plus 1.
+            }
+            if (usedPorts.includes(port)) {
+                port += 1;
+            }
+            usedPorts.push(port);
+            return `--inspect-brk=${port}`;
+        }));
+    }
+    const child = (0, child_process_1.fork)(scriptPath, process.argv.slice(2), { execArgv });
+    child.on('message', (data) => {
+        var _a;
+        const { type, payload } = data || {};
+        if (type === 'RESTART') {
+            child.kill();
+            if (payload === null || payload === void 0 ? void 0 : payload.port) {
+                process.env.PORT = payload.port;
+            }
+            start({ scriptPath });
+        }
+        (_a = process.send) === null || _a === void 0 ? void 0 : _a.call(process, data);
+    });
+    return child;
+}
+exports.default = start;

package/dist/cli/forkedDev.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@umijs/utils");
+const constants_1 = require("../constants");
+const service_1 = require("../service/service");
+const node_1 = require("./node");
+(0, node_1.setNodeTitle)(`${constants_1.FRAMEWORK_NAME}-dev`);
+(0, node_1.setNoDeprecation)();
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const args = (0, utils_1.yParser)(process.argv.slice(2));
+        const service = new service_1.Service();
+        yield service.run2({
+            name: constants_1.DEV_COMMAND,
+            args,
+        });
+        let closed = false;
+        // kill(2) Ctrl-C
+        process.once('SIGINT', () => onSignal('SIGINT'));
+        // kill(3) Ctrl-\
+        process.once('SIGQUIT', () => onSignal('SIGQUIT'));
+        // kill(15) default
+        process.once('SIGTERM', () => onSignal('SIGTERM'));
+        function onSignal(signal) {
+            if (closed)
+                return;
+            closed = true;
+            // 退出时触发插件中的 onExit 事件
+            service.applyPlugins({
+                key: 'onExit',
+                args: {
+                    signal,
+                },
+            });
+            process.exit(0);
+        }
+    }
+    catch (e) {
+        utils_1.logger.error(e);
+        process.exit(1);
+    }
+}))();

package/dist/cli/node.d.ts

@@ -0,0 +1,4 @@
+export declare function checkVersion(): void;
+export declare function checkLocal(): void;
+export declare function setNodeTitle(name?: string): void;
+export declare function setNoDeprecation(): void;

package/dist/cli/node.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setNoDeprecation = exports.setNodeTitle = exports.checkLocal = exports.checkVersion = void 0;
+const utils_1 = require("@umijs/utils");
+const constants_1 = require("../constants");
+function checkVersion() {
+    const v = parseInt(process.version.slice(1));
+    if (v < constants_1.MIN_NODE_VERSION || v === constants_1.EXCLUDE_NODE_VERSION) {
+        utils_1.logger.error(`Your node version ${v} is not supported, please upgrade to ${constants_1.MIN_NODE_VERSION} or above except ${constants_1.EXCLUDE_NODE_VERSION}.`);
+        process.exit(1);
+    }
+}
+exports.checkVersion = checkVersion;
+function checkLocal() {
+    if (__filename.includes(`packages/${constants_1.FRAMEWORK_NAME}`)) {
+        utils_1.logger.info('@local');
+    }
+}
+exports.checkLocal = checkLocal;
+function setNodeTitle(name) {
+    if (process.title === 'node') {
+        process.title = name || constants_1.FRAMEWORK_NAME;
+    }
+}
+exports.setNodeTitle = setNodeTitle;
+function setNoDeprecation() {
+    // Use magic to suppress node deprecation warnings
+    // See: https://github.com/nodejs/node/blob/master/lib/internal/process/warning.js#L77
+    // @ts-ignore
+    process.noDeprecation = '1';
+}
+exports.setNoDeprecation = setNoDeprecation;

package/dist/client/plugin.d.ts

@@ -0,0 +1,34 @@
+export declare enum ApplyPluginsType {
+    compose = "compose",
+    modify = "modify",
+    event = "event"
+}
+interface IPlugin {
+    path?: string;
+    apply: Record<string, any>;
+}
+export declare class PluginManager {
+    opts: {
+        validKeys: string[];
+    };
+    hooks: {
+        [key: string]: any;
+    };
+    constructor(opts: {
+        validKeys: string[];
+    });
+    register(plugin: IPlugin): void;
+    getHooks(keyWithDot: string): any;
+    applyPlugins({ key, type, initialValue, args, async, }: {
+        key: string;
+        type: ApplyPluginsType;
+        initialValue?: any;
+        args?: object;
+        async?: boolean;
+    }): any;
+    static create(opts: {
+        validKeys: string[];
+        plugins: IPlugin[];
+    }): PluginManager;
+}
+export {};

package/dist/client/plugin.js

@@ -0,0 +1,125 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginManager = exports.ApplyPluginsType = void 0;
+const utils_1 = require("./utils");
+var ApplyPluginsType;
+(function (ApplyPluginsType) {
+    ApplyPluginsType["compose"] = "compose";
+    ApplyPluginsType["modify"] = "modify";
+    ApplyPluginsType["event"] = "event";
+})(ApplyPluginsType = exports.ApplyPluginsType || (exports.ApplyPluginsType = {}));
+class PluginManager {
+    constructor(opts) {
+        this.hooks = {};
+        this.opts = opts;
+    }
+    register(plugin) {
+        (0, utils_1.assert)(plugin.apply && plugin.path, `plugin register failed, apply and path must supplied`);
+        Object.keys(plugin.apply).forEach((key) => {
+            (0, utils_1.assert)(this.opts.validKeys.indexOf(key) > -1, `register failed, invalid key ${key} from plugin ${plugin.path}.`);
+            this.hooks[key] = (this.hooks[key] || []).concat(plugin.apply[key]);
+        });
+    }
+    getHooks(keyWithDot) {
+        const [key, ...memberKeys] = keyWithDot.split('.');
+        let hooks = this.hooks[key] || [];
+        if (memberKeys.length) {
+            hooks = hooks
+                .map((hook) => {
+                try {
+                    let ret = hook;
+                    for (const memberKey of memberKeys) {
+                        ret = ret[memberKey];
+                    }
+                    return ret;
+                }
+                catch (e) {
+                    return null;
+                }
+            })
+                .filter(Boolean);
+        }
+        return hooks;
+    }
+    applyPlugins({ key, type, initialValue, args, async, }) {
+        const hooks = this.getHooks(key) || [];
+        if (args) {
+            (0, utils_1.assert)(typeof args === 'object', `applyPlugins failed, args must be plain object.`);
+        }
+        switch (type) {
+            case ApplyPluginsType.modify:
+                if (async) {
+                    return hooks.reduce((memo, hook) => __awaiter(this, void 0, void 0, function* () {
+                        (0, utils_1.assert)(typeof hook === 'function' ||
+                            typeof hook === 'object' ||
+                            (0, utils_1.isPromiseLike)(hook), `applyPlugins failed, all hooks for key ${key} must be function, plain object or Promise.`);
+                        if ((0, utils_1.isPromiseLike)(memo)) {
+                            memo = yield memo;
+                        }
+                        if (typeof hook === 'function') {
+                            const ret = hook(memo, args);
+                            if ((0, utils_1.isPromiseLike)(ret)) {
+                                return yield ret;
+                            }
+                            else {
+                                return ret;
+                            }
+                        }
+                        else {
+                            if ((0, utils_1.isPromiseLike)(hook)) {
+                                hook = yield hook;
+                            }
+                            return Object.assign(Object.assign({}, memo), hook);
+                        }
+                    }), (0, utils_1.isPromiseLike)(initialValue)
+                        ? initialValue
+                        : Promise.resolve(initialValue));
+                }
+                else {
+                    return hooks.reduce((memo, hook) => {
+                        (0, utils_1.assert)(typeof hook === 'function' || typeof hook === 'object', `applyPlugins failed, all hooks for key ${key} must be function or plain object.`);
+                        if (typeof hook === 'function') {
+                            return hook(memo, args);
+                        }
+                        else {
+                            // TODO: deepmerge?
+                            return Object.assign(Object.assign({}, memo), hook);
+                        }
+                    }, initialValue);
+                }
+            case ApplyPluginsType.event:
+                return hooks.forEach((hook) => {
+                    (0, utils_1.assert)(typeof hook === 'function', `applyPlugins failed, all hooks for key ${key} must be function.`);
+                    hook(args);
+                });
+            case ApplyPluginsType.compose:
+                return () => {
+                    return (0, utils_1.compose)({
+                        fns: hooks.concat(initialValue),
+                        args,
+                    })();
+                };
+        }
+    }
+    static create(opts) {
+        const pluginManager = new PluginManager({
+            validKeys: opts.validKeys,
+        });
+        opts.plugins.forEach((plugin) => {
+            pluginManager.register(plugin);
+        });
+        return pluginManager;
+    }
+}
+exports.PluginManager = PluginManager;
+// plugins meta info (in tmp file)
+// hooks api: usePlugin

package/dist/client/utils.d.ts

@@ -0,0 +1,6 @@
+export declare function assert(value: unknown, message: string): void;
+export declare function compose({ fns, args, }: {
+    fns: (Function | any)[];
+    args?: object;
+}): any;
+export declare function isPromiseLike(obj: any): boolean;