@umijs/core 3.5.20 → 4.0.0-beta.1

package/dist/service/service.js

@@ -0,0 +1,361 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+const utils_1 = require("@umijs/utils");
+const assert_1 = __importDefault(require("assert"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const process = __importStar(require("process"));
+const tapable_1 = require("../../compiled/tapable");
+const config_1 = require("../config/config");
+const constants_1 = require("../constants");
+const types_1 = require("../types");
+const env_1 = require("./env");
+const path_2 = require("./path");
+const plugin_1 = require("./plugin");
+const pluginAPI_1 = require("./pluginAPI");
+const utils_2 = require("./utils");
+class Service {
+    constructor(opts) {
+        this.appData = {};
+        this.args = { _: [], $0: '' };
+        this.commands = {};
+        this.config = {};
+        this.configSchemas = {};
+        this.configDefaults = {};
+        this.configOnChanges = {};
+        this.hooks = {};
+        this.name = '';
+        this.paths = {};
+        // preset is plugin with different type
+        this.plugins = {};
+        this.pluginMethods = {};
+        this.skipPluginIds = new Set();
+        this.stage = types_1.ServiceStage.uninitialized;
+        this.userConfig = {};
+        this.configManager = null;
+        this.pkg = {};
+        this.cwd = opts.cwd;
+        this.env = opts.env;
+        this.opts = opts;
+        (0, assert_1.default)((0, fs_1.existsSync)(this.cwd), `Invalid cwd ${this.cwd}, it's not found.`);
+    }
+    applyPlugins(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hooks = this.hooks[opts.key] || [];
+            let type = opts.type;
+            // guess type from key
+            if (!type) {
+                if (opts.key.startsWith('on')) {
+                    type = types_1.ApplyPluginsType.event;
+                }
+                else if (opts.key.startsWith('modify')) {
+                    type = types_1.ApplyPluginsType.modify;
+                }
+                else if (opts.key.startsWith('add')) {
+                    type = types_1.ApplyPluginsType.add;
+                }
+                else {
+                    throw new Error(`Invalid applyPlugins arguments, type must be supplied for key ${opts.key}.`);
+                }
+            }
+            switch (type) {
+                case types_1.ApplyPluginsType.add:
+                    (0, assert_1.default)(!('initialValue' in opts) || Array.isArray(opts.initialValue), `applyPlugins failed, opts.initialValue must be Array if opts.type is add.`);
+                    const tAdd = new tapable_1.AsyncSeriesWaterfallHook(['memo']);
+                    for (const hook of hooks) {
+                        if (!this.isPluginEnable(hook))
+                            continue;
+                        tAdd.tapPromise({
+                            name: hook.plugin.id,
+                            stage: hook.stage,
+                            before: hook.before,
+                        }, (memo) => __awaiter(this, void 0, void 0, function* () {
+                            const items = yield hook.fn(opts.args);
+                            return memo.concat(items);
+                        }));
+                    }
+                    return (yield tAdd.promise(opts.initialValue || []));
+                case types_1.ApplyPluginsType.modify:
+                    const tModify = new tapable_1.AsyncSeriesWaterfallHook(['memo']);
+                    for (const hook of hooks) {
+                        if (!this.isPluginEnable(hook))
+                            continue;
+                        tModify.tapPromise({
+                            name: hook.plugin.id,
+                            stage: hook.stage,
+                            before: hook.before,
+                        }, (memo) => __awaiter(this, void 0, void 0, function* () {
+                            return yield hook.fn(memo, opts.args);
+                        }));
+                    }
+                    return (yield tModify.promise(opts.initialValue));
+                case types_1.ApplyPluginsType.event:
+                    const tEvent = new tapable_1.AsyncSeriesWaterfallHook(['_']);
+                    for (const hook of hooks) {
+                        if (!this.isPluginEnable(hook))
+                            continue;
+                        tEvent.tapPromise({
+                            name: hook.plugin.id,
+                            stage: hook.stage || 0,
+                            before: hook.before,
+                        }, () => __awaiter(this, void 0, void 0, function* () {
+                            yield hook.fn(opts.args);
+                        }));
+                    }
+                    return (yield tEvent.promise(1));
+                default:
+                    throw new Error(`applyPlugins failed, type is not defined or is not matched, got ${opts.type}.`);
+            }
+        });
+    }
+    run(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { name, args = {} } = opts;
+            args._ = args._ || [];
+            // shift the command itself
+            if (args._[0] === name)
+                args._.shift();
+            this.args = args;
+            this.name = name;
+            // loadEnv
+            this.stage = types_1.ServiceStage.init;
+            (0, env_1.loadEnv)({ cwd: this.cwd, envFile: '.env' });
+            // get pkg from package.json
+            let pkg = {};
+            try {
+                pkg = require((0, path_1.join)(this.cwd, 'package.json'));
+            }
+            catch (_e) {
+                // APP_ROOT
+                if (this.cwd !== process.cwd()) {
+                    try {
+                        pkg = require((0, path_1.join)(process.cwd(), 'package.json'));
+                    }
+                    catch (_e) { }
+                }
+            }
+            this.pkg = pkg;
+            // get user config
+            const configManager = new config_1.Config({
+                cwd: this.cwd,
+                env: this.env,
+                defaultConfigFiles: this.opts.defaultConfigFiles,
+            });
+            this.configManager = configManager;
+            this.userConfig = configManager.getUserConfig().config;
+            // get paths (move after?)
+            // resolve initial presets and plugins
+            const { plugins, presets } = plugin_1.Plugin.getPluginsAndPresets({
+                cwd: this.cwd,
+                pkg,
+                plugins: this.opts.plugins || [],
+                presets: [require.resolve('./servicePlugin')].concat(this.opts.presets || []),
+                userConfig: this.userConfig,
+                prefix: this.opts.frameworkName || constants_1.DEFAULT_FRAMEWORK_NAME,
+            });
+            // register presets and plugins
+            this.stage = types_1.ServiceStage.initPresets;
+            while (presets.length) {
+                yield this.initPreset({ preset: presets.shift(), presets, plugins });
+            }
+            this.stage = types_1.ServiceStage.initPlugins;
+            while (plugins.length) {
+                yield this.initPlugin({ plugin: plugins.shift(), plugins });
+            }
+            // collect configSchemas and configDefaults
+            for (const id of Object.keys(this.plugins)) {
+                const { config, key } = this.plugins[id];
+                if (config.schema)
+                    this.configSchemas[key] = config.schema;
+                if (config.default !== undefined) {
+                    this.configDefaults[key] = config.default;
+                }
+                this.configOnChanges[key] = config.onChange || types_1.ConfigChangeType.reload;
+            }
+            // setup api.config from modifyConfig and modifyDefaultConfig
+            this.stage = types_1.ServiceStage.resolveConfig;
+            const config = yield this.applyPlugins({
+                key: 'modifyConfig',
+                initialValue: configManager.getConfig({
+                    schemas: this.configSchemas,
+                }).config,
+            });
+            const defaultConfig = yield this.applyPlugins({
+                key: 'modifyDefaultConfig',
+                initialValue: this.configDefaults,
+            });
+            this.config = utils_1.lodash.merge(defaultConfig, config);
+            const paths = (0, path_2.getPaths)({
+                cwd: this.cwd,
+                env: this.env,
+                prefix: this.opts.frameworkName || constants_1.DEFAULT_FRAMEWORK_NAME,
+            });
+            if (this.config.outputPath) {
+                paths.absOutputPath = (0, path_1.join)(this.cwd, this.config.outputPath);
+            }
+            this.paths = yield this.applyPlugins({
+                key: 'modifyPaths',
+                initialValue: paths,
+            });
+            // applyPlugin collect app data
+            // TODO: some data is mutable
+            this.stage = types_1.ServiceStage.collectAppData;
+            this.appData = yield this.applyPlugins({
+                key: 'modifyAppData',
+                initialValue: {
+                    // base
+                    cwd: this.cwd,
+                    pkg,
+                    plugins,
+                    presets,
+                    name,
+                    args,
+                    // config
+                    userConfig: this.userConfig,
+                    mainConfigFile: configManager.mainConfigFile,
+                    config,
+                    defaultConfig: defaultConfig,
+                    // TODO
+                    // moduleGraph,
+                    // routes,
+                    // npmClient,
+                    // nodeVersion,
+                    // gitInfo,
+                    // gitBranch,
+                    // debugger info,
+                    // devPort,
+                    // devHost,
+                    // env
+                },
+            });
+            // applyPlugin onCheck
+            this.stage = types_1.ServiceStage.onCheck;
+            yield this.applyPlugins({
+                key: 'onCheck',
+            });
+            // applyPlugin onStart
+            this.stage = types_1.ServiceStage.onStart;
+            yield this.applyPlugins({
+                key: 'onStart',
+            });
+            // run command
+            this.stage = types_1.ServiceStage.runCommand;
+            const command = this.commands[name];
+            (0, assert_1.default)(command, `Invalid command ${name}, it's not registered.`);
+            return command.fn({ args });
+        });
+    }
+    initPreset(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { presets, plugins } = yield this.initPlugin({
+                plugin: opts.preset,
+                presets: opts.presets,
+                plugins: opts.plugins,
+            });
+            opts.presets.unshift(...(presets || []));
+            opts.plugins.unshift(...(plugins || []));
+        });
+    }
+    initPlugin(opts) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            // register to this.plugins
+            (0, assert_1.default)(!this.plugins[opts.plugin.id], `${opts.plugin.type} ${opts.plugin.id} is already registered by ${(_a = this.plugins[opts.plugin.id]) === null || _a === void 0 ? void 0 : _a.path}, ${opts.plugin.type} from ${opts.plugin.path} register failed.`);
+            this.plugins[opts.plugin.id] = opts.plugin;
+            // apply with PluginAPI
+            const pluginAPI = new pluginAPI_1.PluginAPI({
+                plugin: opts.plugin,
+                service: this,
+            });
+            pluginAPI.registerPresets = pluginAPI.registerPresets.bind(pluginAPI, opts.presets || []);
+            pluginAPI.registerPlugins = pluginAPI.registerPlugins.bind(pluginAPI, opts.plugins);
+            const proxyPluginAPI = pluginAPI_1.PluginAPI.proxyPluginAPI({
+                service: this,
+                pluginAPI,
+                serviceProps: [
+                    'appData',
+                    'applyPlugins',
+                    'args',
+                    'config',
+                    'cwd',
+                    'pkg',
+                    'name',
+                    'paths',
+                    'userConfig',
+                ],
+                staticProps: {
+                    ApplyPluginsType: types_1.ApplyPluginsType,
+                    ConfigChangeType: types_1.ConfigChangeType,
+                    EnableBy: types_1.EnableBy,
+                    ServiceStage: types_1.ServiceStage,
+                    service: this,
+                },
+            });
+            let ret = opts.plugin.apply()(proxyPluginAPI);
+            if ((0, utils_2.isPromise)(ret)) {
+                ret = yield ret;
+            }
+            if (ret === null || ret === void 0 ? void 0 : ret.presets) {
+                ret.presets = ret.presets.map((preset) => new plugin_1.Plugin({
+                    path: preset,
+                    type: types_1.PluginType.preset,
+                    cwd: this.cwd,
+                }));
+            }
+            if (ret === null || ret === void 0 ? void 0 : ret.plugins) {
+                ret.plugins = ret.plugins.map((plugin) => new plugin_1.Plugin({
+                    path: plugin,
+                    type: types_1.PluginType.plugin,
+                    cwd: this.cwd,
+                }));
+            }
+            return ret || {};
+        });
+    }
+    isPluginEnable(hook) {
+        const { id, key, enableBy } = hook.plugin;
+        if (this.skipPluginIds.has(id))
+            return false;
+        if (this.userConfig[key] === false)
+            return false;
+        if (enableBy === types_1.EnableBy.config && !(key in this.config))
+            return false;
+        if (typeof enableBy === 'function')
+            return enableBy();
+        // EnableBy.register
+        return true;
+    }
+}
+exports.Service = Service;

package/dist/service/servicePlugin.d.ts

@@ -0,0 +1,3 @@
+import { PluginAPI } from './pluginAPI';
+declare const _default: (api: PluginAPI) => void;
+export default _default;

package/dist/service/servicePlugin.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (api) => {
+    [
+        'onCheck',
+        'onStart',
+        'modifyAppData',
+        'modifyConfig',
+        'modifyDefaultConfig',
+        'modifyPaths',
+    ].forEach((name) => {
+        api.registerMethod({ name });
+    });
+};

package/dist/service/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function isPromise(obj: any): boolean;
+export declare function makeArray(item: any): any[];

package/dist/service/utils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeArray = exports.isPromise = void 0;
+function isPromise(obj) {
+    return ((typeof obj === 'object' || typeof obj === 'function') &&
+        typeof obj.then === 'function');
+}
+exports.isPromise = isPromise;
+function makeArray(item) {
+    return Array.isArray(item) ? item : [item];
+}
+exports.makeArray = makeArray;

package/dist/types.d.ts

@@ -0,0 +1,108 @@
+import joi from '../compiled/@hapi/joi';
+export declare enum Env {
+    development = "development",
+    production = "production",
+    test = "test"
+}
+export declare enum PluginType {
+    preset = "preset",
+    plugin = "plugin"
+}
+export interface IPluginConfig {
+    default?: any;
+    schema?: {
+        (joi: joi.Root): joi.Schema;
+    };
+    onChange?: string | Function;
+}
+export declare enum ServiceStage {
+    uninitialized = 0,
+    init = 1,
+    initPresets = 2,
+    initPlugins = 3,
+    resolveConfig = 4,
+    collectAppData = 5,
+    onCheck = 6,
+    onStart = 7,
+    runCommand = 8
+}
+export declare enum ConfigChangeType {
+    reload = "reload",
+    regenerateTmpFiles = "regenerateTmpFiles"
+}
+export declare enum ApplyPluginsType {
+    add = "add",
+    modify = "modify",
+    event = "event"
+}
+export declare enum EnableBy {
+    register = "register",
+    config = "config"
+}
+export interface IRoute {
+    path: string;
+    file: string;
+    id: string;
+    parentId?: string;
+}
+export interface IEvent<T> {
+    (fn: {
+        (args: T): void;
+    }): void;
+    (args: {
+        fn: {
+            (args: T): void;
+        };
+        name?: string;
+        before?: string | string[];
+        stage?: number;
+    }): void;
+}
+export interface IModify<T, U> {
+    (fn: {
+        (initialValue: T, args: U): T;
+    }): void;
+    (fn: {
+        (initialValue: T, args: U): Promise<T>;
+    }): void;
+    (args: {
+        fn: {
+            (initialValue: T, args: U): T;
+        };
+        name?: string;
+        before?: string | string[];
+        stage?: number;
+    }): void;
+    (args: {
+        fn: {
+            (initialValue: T, args: U): Promise<T>;
+        };
+        name?: string;
+        before?: string | string[];
+        stage?: number;
+    }): void;
+}
+export interface IAdd<T, U> {
+    (fn: {
+        (args: T): U | U[];
+    }): void;
+    (fn: {
+        (args: T): Promise<U | U[]>;
+    }): void;
+    (args: {
+        fn: {
+            (args: T): U | U[];
+        };
+        name?: string;
+        before?: string | string[];
+        stage?: number;
+    }): void;
+    (args: {
+        fn: {
+            (args: T): Promise<U | U[]>;
+            name?: string;
+            before?: string | string[];
+            stage?: number;
+        };
+    }): void;
+}

package/dist/types.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnableBy = exports.ApplyPluginsType = exports.ConfigChangeType = exports.ServiceStage = exports.PluginType = exports.Env = void 0;
+var Env;
+(function (Env) {
+    Env["development"] = "development";
+    Env["production"] = "production";
+    Env["test"] = "test";
+})(Env = exports.Env || (exports.Env = {}));
+var PluginType;
+(function (PluginType) {
+    PluginType["preset"] = "preset";
+    PluginType["plugin"] = "plugin";
+})(PluginType = exports.PluginType || (exports.PluginType = {}));
+var ServiceStage;
+(function (ServiceStage) {
+    ServiceStage[ServiceStage["uninitialized"] = 0] = "uninitialized";
+    ServiceStage[ServiceStage["init"] = 1] = "init";
+    ServiceStage[ServiceStage["initPresets"] = 2] = "initPresets";
+    ServiceStage[ServiceStage["initPlugins"] = 3] = "initPlugins";
+    ServiceStage[ServiceStage["resolveConfig"] = 4] = "resolveConfig";
+    ServiceStage[ServiceStage["collectAppData"] = 5] = "collectAppData";
+    ServiceStage[ServiceStage["onCheck"] = 6] = "onCheck";
+    ServiceStage[ServiceStage["onStart"] = 7] = "onStart";
+    ServiceStage[ServiceStage["runCommand"] = 8] = "runCommand";
+})(ServiceStage = exports.ServiceStage || (exports.ServiceStage = {}));
+var ConfigChangeType;
+(function (ConfigChangeType) {
+    ConfigChangeType["reload"] = "reload";
+    ConfigChangeType["regenerateTmpFiles"] = "regenerateTmpFiles";
+})(ConfigChangeType = exports.ConfigChangeType || (exports.ConfigChangeType = {}));
+var ApplyPluginsType;
+(function (ApplyPluginsType) {
+    ApplyPluginsType["add"] = "add";
+    ApplyPluginsType["modify"] = "modify";
+    ApplyPluginsType["event"] = "event";
+})(ApplyPluginsType = exports.ApplyPluginsType || (exports.ApplyPluginsType = {}));
+var EnableBy;
+(function (EnableBy) {
+    EnableBy["register"] = "register";
+    EnableBy["config"] = "config";
+})(EnableBy = exports.EnableBy || (exports.EnableBy = {}));

package/package.json

@@ -1,32 +1,52 @@
 {
   "name": "@umijs/core",
-  "version": "3.5.20",
-  "description": "@umijs/core",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
+  "version": "4.0.0-beta.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
-    "lib"
+    "dist"
   ],
+  "scripts": {
+    "build": "pnpm tsc",
+    "build:deps": "pnpm esno ../../scripts/bundleDeps.ts",
+    "dev": "pnpm build -- --watch"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/umijs/umi"
+    "url": "https://github.com/umijs/umi-next"
   },
-  "keywords": [
-    "umi"
-  ],
   "authors": [
     "chencheng <sorrycc@gmail.com> (https://github.com/sorrycc)"
   ],
   "license": "MIT",
-  "bugs": "http://github.com/umijs/umi/issues",
-  "homepage": "https://github.com/umijs/umi/tree/master/packages/core#readme",
+  "bugs": "https://github.com/umijs/umi-next/issues",
+  "homepage": "https://github.com/umijs/umi-next/tree/master/packages/core#readme",
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@umijs/ast": "3.5.20",
-    "@umijs/babel-preset-umi": "3.5.20",
-    "@umijs/deps": "3.5.20",
-    "@umijs/utils": "3.5.20"
+    "@umijs/bundler-utils": "4.0.0-beta.1",
+    "@umijs/utils": "4.0.0-beta.1"
+  },
+  "devDependencies": {
+    "@hapi/joi": "17.1.1",
+    "@types/hapi__joi": "17.1.7",
+    "dotenv": "10.0.0",
+    "just-diff": "3.1.1",
+    "tapable": "2.2.1"
+  },
+  "compiledConfig": {
+    "deps": [
+      "@hapi/joi",
+      "dotenv",
+      "just-diff",
+      "tapable"
+    ],
+    "externals": {
+      "@hapi/joi": "$$LOCAL",
+      "dotenv": "$$LOCAL",
+      "just-diff": "$$LOCAL",
+      "tapable": "$$LOCAL"
+    }
   }
 }

package/lib/Config/Config.d.ts

@@ -1,39 +0,0 @@
-import Service from '../Service/Service';
-interface IChanged {
-    key: string;
-    pluginId: string;
-}
-interface IOpts {
-    cwd: string;
-    service: Service;
-    localConfig?: boolean;
-    configFiles?: string[];
-}
-export default class Config {
-    cwd: string;
-    service: Service;
-    config?: object;
-    localConfig?: boolean;
-    configFile?: string | null;
-    configFiles: string[];
-    constructor(opts: IOpts);
-    getDefaultConfig(): Promise<{}>;
-    getConfig({ defaultConfig }: {
-        defaultConfig: object;
-    }): {};
-    getUserConfig(): {};
-    addAffix(file: string, affix: string): string;
-    requireConfigs(configFiles: string[]): any[];
-    mergeConfig(...configs: object[]): {};
-    getConfigFile(): string | null;
-    getWatchFilesAndDirectories(): string[];
-    watch(opts: {
-        userConfig: object;
-        onChange: (args: {
-            userConfig: any;
-            pluginChanged: IChanged[];
-            valueChanged: IChanged[];
-        }) => void;
-    }): () => void;
-}
-export {};