@umijs/core 3.5.20 → 4.0.0-beta.1

package/dist/service/path.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPaths = void 0;
+const utils_1 = require("@umijs/utils");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const types_1 = require("../types");
+function winJoin(...args) {
+    return (0, utils_1.winPath)((0, path_1.join)(...args));
+}
+function getPaths(opts) {
+    const cwd = opts.cwd;
+    const src = winJoin(cwd, 'src');
+    const absSrcPath = (0, fs_1.existsSync)(src) && (0, fs_1.statSync)(src).isDirectory() ? src : cwd;
+    const absPagesPath = winJoin(absSrcPath, 'pages');
+    const tmp = opts.env === types_1.Env.development
+        ? `.${opts.prefix}`
+        : `.${opts.prefix}-${opts.env}`;
+    const absTmpPath = winJoin(absSrcPath, tmp);
+    const absNodeModulesPath = winJoin(cwd, 'node_modules');
+    const absOutputPath = winJoin(cwd, 'dist');
+    return {
+        cwd,
+        absSrcPath,
+        absPagesPath,
+        absTmpPath,
+        absNodeModulesPath,
+        absOutputPath,
+    };
+}
+exports.getPaths = getPaths;

package/dist/service/plugin.d.ts

@@ -0,0 +1,53 @@
+import { EnableBy, IPluginConfig } from '../types';
+declare type PluginType = 'plugin' | 'preset';
+interface IOpts {
+    path: string;
+    cwd: string;
+    type: PluginType;
+}
+export interface IPluginObject {
+    id: string;
+    key: string;
+    apply?: Function;
+    config?: IPluginConfig;
+    enableBy?: EnableBy | (() => boolean);
+}
+export declare class Plugin {
+    private cwd;
+    type: PluginType;
+    path: string;
+    id: string;
+    key: string;
+    apply: Function;
+    config: IPluginConfig;
+    enableBy: EnableBy | (() => boolean);
+    constructor(opts: IOpts);
+    merge(opts: {
+        key?: string;
+        config?: IPluginConfig;
+        enableBy?: EnableBy | (() => boolean);
+    }): void;
+    getId(opts: {
+        pkg: any;
+        isPkgEntry: boolean;
+        pkgJSONPath: string | null;
+    }): any;
+    getKey(opts: {
+        pkg: any;
+        isPkgEntry: boolean;
+    }): string;
+    static isPluginOrPreset(type: 'plugin' | 'preset', name: string): boolean;
+    static stripNoneUmiScope(name: string): string;
+    static getPluginsAndPresets(opts: {
+        cwd: string;
+        pkg: any;
+        userConfig: any;
+        plugins?: string[];
+        presets?: string[];
+        prefix: string;
+    }): {
+        presets: Plugin[];
+        plugins: Plugin[];
+    };
+}
+export {};

package/dist/service/plugin.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plugin = 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 types_1 = require("../types");
+const RE = {
+    plugin: /^(@umijs\/|umi-)plugin-/,
+    preset: /^(@umijs\/|umi-)preset-/,
+};
+class Plugin {
+    constructor(opts) {
+        this.config = {};
+        this.enableBy = types_1.EnableBy.register;
+        this.type = opts.type;
+        this.path = (0, utils_1.winPath)(opts.path);
+        this.cwd = opts.cwd;
+        (0, assert_1.default)((0, fs_1.existsSync)(this.path), `Invalid ${this.type} ${this.path}, it's not exists.`);
+        let pkg = null;
+        // path is the package entry
+        let isPkgEntry = false;
+        const pkgJSONPath = utils_1.pkgUp.sync({ cwd: this.path });
+        if (pkgJSONPath) {
+            pkg = require(pkgJSONPath);
+            isPkgEntry =
+                (0, utils_1.winPath)((0, path_1.join)((0, path_1.dirname)(pkgJSONPath), pkg.main || 'index.js')) ===
+                    (0, utils_1.winPath)(this.path);
+        }
+        this.id = this.getId({ pkg, isPkgEntry, pkgJSONPath });
+        this.key = this.getKey({ pkg, isPkgEntry });
+        this.apply = () => {
+            try {
+                const ret = require(this.path);
+                // use the default member for es modules
+                return ret.__esModule ? ret.default : ret;
+            }
+            catch (e) {
+                throw new Error(`Register ${this.type} ${this.path} failed, since ${e.message}`);
+            }
+        };
+    }
+    merge(opts) {
+        if (opts.key)
+            this.key = opts.key;
+        if (opts.config)
+            this.config = opts.config;
+        if (opts.enableBy)
+            this.enableBy = opts.enableBy;
+    }
+    getId(opts) {
+        let id;
+        if (opts.isPkgEntry) {
+            id = opts.pkg.name;
+        }
+        else if ((0, utils_1.winPath)(this.path).startsWith((0, utils_1.winPath)(this.cwd))) {
+            id = `./${(0, utils_1.winPath)((0, path_1.relative)(this.cwd, this.path))}`;
+        }
+        else if (opts.pkgJSONPath) {
+            id = (0, utils_1.winPath)((0, path_1.join)(opts.pkg.name, (0, path_1.relative)((0, path_1.dirname)(opts.pkgJSONPath), this.path)));
+        }
+        else {
+            id = (0, utils_1.winPath)(this.path);
+        }
+        id = id.replace('@umijs/preset-built-in/lib/plugins', '@@');
+        id = id.replace(/\.js$/, '');
+        return id;
+    }
+    getKey(opts) {
+        // e.g.
+        // initial-state -> initialState
+        // webpack.css-loader -> webpack.cssLoader
+        function nameToKey(name) {
+            return name
+                .split('.')
+                .map((part) => utils_1.lodash.camelCase(part))
+                .join('.');
+        }
+        return nameToKey(opts.isPkgEntry
+            ? Plugin.stripNoneUmiScope(opts.pkg.name).replace(RE[this.type], '')
+            : (0, path_1.basename)(this.path, (0, path_1.extname)(this.path)));
+    }
+    static isPluginOrPreset(type, name) {
+        return RE[type].test(Plugin.stripNoneUmiScope(name));
+    }
+    static stripNoneUmiScope(name) {
+        if (name.charAt(0) === '@' && !name.startsWith('@umijs/')) {
+            name = name.split('/')[1];
+        }
+        return name;
+    }
+    static getPluginsAndPresets(opts) {
+        function get(type) {
+            const types = `${type}s`;
+            return [
+                // opts
+                ...(opts[types] || []),
+                // env
+                ...(process.env[`${opts.prefix}_${types}`.toUpperCase()] || '')
+                    .split(',')
+                    .filter(Boolean),
+                // dependencies
+                ...Object.keys(opts.pkg.devDependencies || {})
+                    .concat(Object.keys(opts.pkg.dependencies || {}))
+                    .filter(Plugin.isPluginOrPreset.bind(null, type)),
+                // user config
+                ...(opts.userConfig[types] || []),
+            ].map((path) => {
+                (0, assert_1.default)(typeof path === 'string', `Invalid plugin ${path}, it must be string.`);
+                let resolved;
+                try {
+                    resolved = utils_1.resolve.sync(path, {
+                        basedir: opts.cwd,
+                        extensions: ['.tsx', '.ts', '.mjs', '.jsx', '.js'],
+                    });
+                }
+                catch (_e) {
+                    throw new Error(`Invalid plugin ${path}, can not be resolved.`);
+                }
+                return new Plugin({
+                    path: resolved,
+                    type,
+                    cwd: opts.cwd,
+                });
+            });
+        }
+        return {
+            presets: get('preset'),
+            plugins: get('plugin'),
+        };
+    }
+}
+exports.Plugin = Plugin;

package/dist/service/pluginAPI.d.ts

@@ -0,0 +1,35 @@
+import { EnableBy, IPluginConfig } from '../types';
+import { IOpts as ICommandOpts } from './command';
+import { IOpts as IHookOpts } from './hook';
+import { Plugin } from './plugin';
+import { Service } from './service';
+export declare class PluginAPI {
+    service: Service;
+    plugin: Plugin;
+    constructor(opts: {
+        service: Service;
+        plugin: Plugin;
+    });
+    describe(opts: {
+        key?: string;
+        config?: IPluginConfig;
+        enableBy?: EnableBy | (() => boolean);
+    }): void;
+    registerCommand(opts: Omit<ICommandOpts, 'plugin'> & {
+        alias?: string | string[];
+    }): void;
+    register(opts: Omit<IHookOpts, 'plugin'>): void;
+    registerMethod(opts: {
+        name: string;
+        fn?: Function;
+    }): void;
+    registerPresets(source: Plugin[], presets: any[]): void;
+    registerPlugins(source: Plugin[], plugins: any[]): void;
+    skipPlugins(ids: string[]): void;
+    static proxyPluginAPI(opts: {
+        pluginAPI: PluginAPI;
+        service: Service;
+        serviceProps: string[];
+        staticProps: Record<string, any>;
+    }): PluginAPI;
+}

package/dist/service/pluginAPI.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginAPI = void 0;
+const utils_1 = require("@umijs/utils");
+const assert_1 = __importDefault(require("assert"));
+const types_1 = require("../types");
+const command_1 = require("./command");
+const hook_1 = require("./hook");
+const plugin_1 = require("./plugin");
+const utils_2 = require("./utils");
+class PluginAPI {
+    constructor(opts) {
+        this.service = opts.service;
+        this.plugin = opts.plugin;
+        // TODO
+        // logger
+    }
+    describe(opts) {
+        this.plugin.merge(opts);
+    }
+    registerCommand(opts) {
+        const { alias } = opts;
+        delete opts.alias;
+        const registerCommand = (commandOpts) => {
+            var _a;
+            const { name } = commandOpts;
+            (0, assert_1.default)(!this.service.commands[name], `api.registerCommand() failed, the command ${name} is exists from ${(_a = this.service.commands[name]) === null || _a === void 0 ? void 0 : _a.plugin.id}.`);
+            this.service.commands[name] = new command_1.Command(Object.assign(Object.assign({}, commandOpts), { plugin: this.plugin }));
+        };
+        registerCommand(opts);
+        if (alias) {
+            const aliases = (0, utils_2.makeArray)(alias);
+            aliases.forEach((alias) => {
+                registerCommand(Object.assign(Object.assign({}, opts), { name: alias }));
+            });
+        }
+    }
+    register(opts) {
+        var _a, _b;
+        (_a = this.service.hooks)[_b = opts.key] || (_a[_b] = []);
+        this.service.hooks[opts.key].push(new hook_1.Hook(Object.assign(Object.assign({}, opts), { plugin: this.plugin })));
+    }
+    registerMethod(opts) {
+        (0, assert_1.default)(!this.service.pluginMethods[opts.name], `api.registerMethod() failed, method ${opts.name} is already exist.`);
+        this.service.pluginMethods[opts.name] = {
+            plugin: this.plugin,
+            fn: opts.fn ||
+                ((fn) => {
+                    this.register(Object.assign({ key: opts.name }, (utils_1.lodash.isPlainObject(fn) ? fn : { fn })));
+                }),
+        };
+    }
+    registerPresets(source, presets) {
+        (0, assert_1.default)(this.service.stage === types_1.ServiceStage.initPresets, `api.registerPresets() failed, it should only used in presets.`);
+        source.splice(0, 0, ...presets.map((preset) => {
+            return new plugin_1.Plugin({
+                path: preset,
+                cwd: this.service.cwd,
+                type: types_1.PluginType.plugin,
+            });
+        }));
+    }
+    registerPlugins(source, plugins) {
+        (0, assert_1.default)(this.service.stage === types_1.ServiceStage.initPresets ||
+            this.service.stage === types_1.ServiceStage.initPlugins, `api.registerPlugins() failed, it should only be used in registering stage.`);
+        const mappedPlugins = plugins.map((plugin) => {
+            if (utils_1.lodash.isPlainObject(plugin)) {
+                (0, assert_1.default)(plugin.id && plugin.key, `Invalid plugin object, id and key must supplied.`);
+                plugin.type = types_1.PluginType.plugin;
+                plugin.enableBy = plugin.enableBy || types_1.EnableBy.register;
+                plugin.apply = plugin.apply || (() => () => { });
+                plugin.config = plugin.config || {};
+                return plugin;
+            }
+            else {
+                return new plugin_1.Plugin({
+                    path: plugin,
+                    cwd: this.service.cwd,
+                    type: types_1.PluginType.plugin,
+                });
+            }
+        });
+        if (this.service.stage === types_1.ServiceStage.initPresets) {
+            source.push(...mappedPlugins);
+        }
+        else {
+            source.splice(0, 0, ...mappedPlugins);
+        }
+    }
+    skipPlugins(ids) {
+        ids.forEach((id) => {
+            this.service.skipPluginIds.add(id);
+        });
+    }
+    static proxyPluginAPI(opts) {
+        return new Proxy(opts.pluginAPI, {
+            get: (target, prop) => {
+                if (opts.service.pluginMethods[prop]) {
+                    return opts.service.pluginMethods[prop].fn;
+                }
+                if (opts.serviceProps.includes(prop)) {
+                    // @ts-ignore
+                    const serviceProp = opts.service[prop];
+                    return typeof serviceProp === 'function'
+                        ? serviceProp.bind(opts.service)
+                        : serviceProp;
+                }
+                if (prop in opts.staticProps) {
+                    return opts.staticProps[prop];
+                }
+                // @ts-ignore
+                return target[prop];
+            },
+        });
+    }
+}
+exports.PluginAPI = PluginAPI;

package/dist/service/service.d.ts

@@ -0,0 +1,91 @@
+import { yParser } from '@umijs/utils';
+import { Config } from '../config/config';
+import { ApplyPluginsType, ConfigChangeType, EnableBy, Env, IEvent, IModify, ServiceStage } from '../types';
+import { Command } from './command';
+import { Hook } from './hook';
+import { Plugin } from './plugin';
+interface IOpts {
+    cwd: string;
+    env: Env;
+    plugins?: string[];
+    presets?: string[];
+    frameworkName?: string;
+    defaultConfigFiles?: string[];
+}
+export declare class Service {
+    private opts;
+    appData: Record<string, any>;
+    args: yParser.Arguments;
+    commands: Record<string, Command>;
+    config: Record<string, any>;
+    configSchemas: Record<string, any>;
+    configDefaults: Record<string, any>;
+    configOnChanges: Record<string, any>;
+    cwd: string;
+    env: Env;
+    hooks: Record<string, Hook[]>;
+    name: string;
+    paths: {
+        cwd?: string;
+        absSrcPath?: string;
+        absPagesPath?: string;
+        absTmpPath?: string;
+        absNodeModulesPath?: string;
+        absOutputPath?: string;
+    };
+    plugins: Record<string, Plugin>;
+    pluginMethods: Record<string, {
+        plugin: Plugin;
+        fn: Function;
+    }>;
+    skipPluginIds: Set<string>;
+    stage: ServiceStage;
+    userConfig: Record<string, any>;
+    configManager: Config | null;
+    pkg: Record<string, string | Record<string, any>>;
+    constructor(opts: IOpts);
+    applyPlugins<T>(opts: {
+        key: string;
+        type?: ApplyPluginsType;
+        initialValue?: any;
+        args?: any;
+    }): Promise<T>;
+    run(opts: {
+        name: string;
+        args?: any;
+    }): Promise<void>;
+    initPreset(opts: {
+        preset: Plugin;
+        presets: Plugin[];
+        plugins: Plugin[];
+    }): Promise<void>;
+    initPlugin(opts: {
+        plugin: Plugin;
+        presets?: Plugin[];
+        plugins: Plugin[];
+    }): Promise<any>;
+    isPluginEnable(hook: Hook): boolean;
+}
+export interface IServicePluginAPI {
+    appData: typeof Service.prototype.appData;
+    applyPlugins: typeof Service.prototype.applyPlugins;
+    args: typeof Service.prototype.args;
+    config: typeof Service.prototype.config;
+    cwd: typeof Service.prototype.cwd;
+    pkg: typeof Service.prototype.pkg;
+    name: typeof Service.prototype.name;
+    paths: Required<typeof Service.prototype.paths>;
+    userConfig: typeof Service.prototype.userConfig;
+    onCheck: IEvent<null>;
+    onStart: IEvent<null>;
+    modifyAppData: IModify<typeof Service.prototype.appData, null>;
+    modifyConfig: IModify<typeof Service.prototype.config, null>;
+    modifyDefaultConfig: IModify<typeof Service.prototype.config, null>;
+    modifyPaths: IModify<typeof Service.prototype.paths, null>;
+    ApplyPluginsType: typeof ApplyPluginsType;
+    ConfigChangeType: typeof ConfigChangeType;
+    EnableBy: typeof EnableBy;
+    ServiceStage: typeof ServiceStage;
+    registerPlugins: (plugins: (Plugin | {})[]) => void;
+}
+export {};