@umijs/core 3.5.20 → 4.0.0-beta.4

package/dist/route/routesConfig.js

@@ -0,0 +1 @@
+"use strict";

package/dist/route/routesConvention.d.ts

@@ -0,0 +1,3 @@
+export declare function getConventionRoutes(opts: {
+    base: string;
+}): any;

package/dist/route/routesConvention.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConventionRoutes = 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 defineRoutes_1 = require("./defineRoutes");
+const utils_2 = require("./utils");
+// opts.base: path of pages
+function getConventionRoutes(opts) {
+    const files = {};
+    (0, assert_1.default)((0, fs_1.existsSync)(opts.base) && (0, fs_1.statSync)(opts.base).isDirectory(), `Convention routes base not found.`);
+    visitFiles({
+        dir: opts.base,
+        visitor: (file) => {
+            const routeId = (0, utils_2.createRouteId)(file);
+            if ((0, utils_2.isRouteModuleFile)({ file })) {
+                files[routeId] = (0, utils_1.winPath)(file);
+            }
+            else {
+                throw new Error(`Invalid route module file: ${(0, path_1.join)(opts.base, file)}`);
+            }
+        },
+    });
+    const routeIds = Object.keys(files).sort(utils_2.byLongestFirst);
+    function defineNestedRoutes(defineRoute, parentId) {
+        const childRouteIds = routeIds.filter((id) => (0, utils_2.findParentRouteId)(routeIds, id) === parentId);
+        for (let routeId of childRouteIds) {
+            let routePath = createRoutePath(parentId ? routeId.slice(parentId.length + 1) : routeId);
+            defineRoute({
+                path: routePath,
+                file: files[routeId],
+                children() {
+                    defineNestedRoutes(defineRoute, routeId);
+                },
+            });
+        }
+    }
+    return (0, defineRoutes_1.defineRoutes)(defineNestedRoutes);
+}
+exports.getConventionRoutes = getConventionRoutes;
+function visitFiles(opts) {
+    opts.baseDir = opts.baseDir || opts.dir;
+    for (let filename of (0, fs_1.readdirSync)(opts.dir)) {
+        let file = (0, path_1.resolve)(opts.dir, filename);
+        let stat = (0, fs_1.lstatSync)(file);
+        if (stat.isDirectory()) {
+            visitFiles(Object.assign(Object.assign({}, opts), { dir: file }));
+        }
+        else if (stat.isFile() &&
+            ['.tsx', '.ts', '.js', '.jsx'].includes((0, path_1.extname)(file))) {
+            opts.visitor((0, path_1.relative)(opts.baseDir, file));
+        }
+    }
+}
+function createRoutePath(routeId) {
+    const path = routeId
+        // routes/$ -> routes/*
+        // routes/nested/$.tsx (with a "routes/nested.tsx" layout)
+        .replace(/^\$$/, '*')
+        // routes/docs.$ -> routes/docs/*
+        // routes/docs/$ -> routes/docs/*
+        .replace(/(\/|\.)\$$/, '/*')
+        // routes/$user -> routes/:user
+        .replace(/\$/g, ':')
+        // routes/not.nested -> routes/not/nested
+        .replace(/\./g, '/');
+    return /\b\/?index$/.test(path) ? path.replace(/\/?index$/, '') : path;
+}

package/dist/route/utils.d.ts

@@ -0,0 +1,7 @@
+export declare function createRouteId(file: string): string;
+export declare function stripFileExtension(file: string): string;
+export declare function byLongestFirst(a: string, b: string): number;
+export declare function findParentRouteId(routeIds: string[], childRouteId: string): string | undefined;
+export declare function isRouteModuleFile(opts: {
+    file: string;
+}): boolean;

package/dist/route/utils.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRouteModuleFile = exports.findParentRouteId = exports.byLongestFirst = exports.stripFileExtension = exports.createRouteId = void 0;
+const utils_1 = require("@umijs/utils");
+const path_1 = require("path");
+function createRouteId(file) {
+    return (0, utils_1.winPath)(stripFileExtension(file));
+}
+exports.createRouteId = createRouteId;
+function stripFileExtension(file) {
+    return file.replace(/\.[a-z0-9]+$/i, '');
+}
+exports.stripFileExtension = stripFileExtension;
+function byLongestFirst(a, b) {
+    return b.length - a.length;
+}
+exports.byLongestFirst = byLongestFirst;
+function findParentRouteId(routeIds, childRouteId) {
+    return routeIds.find((id) => childRouteId.startsWith(`${id}/`));
+}
+exports.findParentRouteId = findParentRouteId;
+const routeModuleExts = ['.js', '.jsx', '.ts', '.tsx', '.md', '.mdx'];
+function isRouteModuleFile(opts) {
+    return routeModuleExts.includes((0, path_1.extname)(opts.file));
+}
+exports.isRouteModuleFile = isRouteModuleFile;

package/dist/service/command.d.ts

@@ -0,0 +1,27 @@
+import { yParser } from '@umijs/utils';
+import { Plugin } from './plugin';
+export interface IOpts {
+    name: string;
+    description?: string;
+    options?: string;
+    details?: string;
+    fn: {
+        ({ args }: {
+            args: yParser.Arguments;
+        }): void;
+    };
+    plugin: Plugin;
+}
+export declare class Command {
+    name: string;
+    description?: string;
+    options?: string;
+    details?: string;
+    fn: {
+        ({ args }: {
+            args: yParser.Arguments;
+        }): void;
+    };
+    plugin: Plugin;
+    constructor(opts: IOpts);
+}

package/dist/service/command.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
+class Command {
+    constructor(opts) {
+        this.name = opts.name;
+        this.description = opts.description;
+        this.options = opts.options;
+        this.details = opts.details;
+        this.fn = opts.fn;
+        this.plugin = opts.plugin;
+    }
+}
+exports.Command = Command;

package/dist/service/env.d.ts

@@ -0,0 +1,4 @@
+export declare function loadEnv(opts: {
+    cwd: string;
+    envFile: string;
+}): void;

package/dist/service/env.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEnv = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const dotenv_1 = require("../../compiled/dotenv");
+function loadEnv(opts) {
+    const files = [
+        (0, path_1.join)(opts.cwd, opts.envFile),
+        (0, path_1.join)(opts.cwd, `${opts.envFile}.local`),
+    ];
+    for (const file of files) {
+        if (!(0, fs_1.existsSync)(file))
+            continue;
+        const parsed = (0, dotenv_1.parse)((0, fs_1.readFileSync)(file)) || {};
+        for (const key of Object.keys(parsed)) {
+            process.env[key] = parsed[key];
+        }
+    }
+}
+exports.loadEnv = loadEnv;

package/dist/service/generatePlugin.d.ts

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

package/dist/service/generatePlugin.js

@@ -0,0 +1,91 @@
+"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 generator_1 = require("./generator");
+exports.default = (api) => {
+    api.registerCommand({
+        name: 'generate',
+        alias: 'g',
+        details: `
+umi generate
+`,
+        description: 'generate code snippets quickly',
+        fn({ args }) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const [type] = args._;
+                const runGenerator = (generator) => {
+                    generator === null || generator === void 0 ? void 0 : generator.fn({
+                        api,
+                        args,
+                        generateFile: utils_1.generateFile,
+                        installDeps: utils_1.installDeps,
+                        updatePackageJSON: utils_1.updatePackageJSON,
+                    });
+                };
+                if (type) {
+                    const generator = api.service.generators[type];
+                    if (!generator) {
+                        throw new Error(`Generator ${type} not found.`);
+                    }
+                    if (generator.type === generator_1.GeneratorType.enable) {
+                        const enable = yield ((_a = generator.checkEnable) === null || _a === void 0 ? void 0 : _a.call(generator, {
+                            api,
+                            args,
+                        }));
+                        if (!enable) {
+                            throw new Error(`Generator ${type} is unable.The corresponding function has been turned on or is not available.`);
+                        }
+                    }
+                    runGenerator(generator);
+                }
+                else {
+                    const getEnableGenerators = (generators) => __awaiter(this, void 0, void 0, function* () {
+                        const questions = [];
+                        Object.keys(generators).forEach((key) => __awaiter(this, void 0, void 0, function* () {
+                            var _b, _c;
+                            if (generators[key].type === generator_1.GeneratorType.generate) {
+                                questions.push({
+                                    title: `${generators[key].name} -- ${generators[key].description}` ||
+                                        '',
+                                    value: generators[key].key,
+                                });
+                            }
+                            else {
+                                const enable = yield ((_c = (_b = generators[key]) === null || _b === void 0 ? void 0 : _b.checkEnable) === null || _c === void 0 ? void 0 : _c.call(_b, {
+                                    api,
+                                    args,
+                                }));
+                                if (enable) {
+                                    questions.push({
+                                        title: `${generators[key].name} -- ${generators[key].description}` ||
+                                            '',
+                                        value: generators[key].key,
+                                    });
+                                }
+                            }
+                        }));
+                        return questions;
+                    });
+                    const questions = yield getEnableGenerators(api.service.generators);
+                    const { gType } = yield (0, utils_1.prompts)({
+                        type: 'select',
+                        name: 'gType',
+                        message: 'Pick generator type',
+                        choices: questions,
+                    });
+                    runGenerator(api.service.generators[gType]);
+                }
+            });
+        },
+    });
+};

package/dist/service/generator.d.ts

@@ -0,0 +1,60 @@
+import { prompts } from '@umijs/utils';
+import { Plugin } from './plugin';
+import { PluginAPI } from './pluginAPI';
+import { IServicePluginAPI } from './service';
+export declare enum GeneratorType {
+    generate = "generate",
+    enable = "enable"
+}
+export interface IGeneratorOpts {
+    key: string;
+    name?: string;
+    description?: string;
+    type?: GeneratorType;
+    checkEnable?: {
+        (opts: {
+            args: any;
+            api: PluginAPI & IServicePluginAPI;
+        }): boolean;
+    };
+    fn: {
+        (opts: {
+            args: any;
+            api: PluginAPI & IServicePluginAPI;
+            generateFile: {
+                (opts: {
+                    path: string;
+                    target: string;
+                    data?: any;
+                    questions?: prompts.PromptObject[];
+                }): void;
+            };
+            updatePackageJSON: {
+                (opts: {
+                    opts: object;
+                    cwd?: string;
+                }): void;
+            };
+            installDeps: {
+                (opts: {
+                    opts: {
+                        devDependencies?: string[];
+                        dependencies?: string[];
+                    };
+                    cwd?: string;
+                }): void;
+            };
+        }): void;
+    };
+    plugin: Plugin;
+}
+export declare class Generator {
+    key: IGeneratorOpts['key'];
+    name?: IGeneratorOpts['name'];
+    description?: IGeneratorOpts['description'];
+    type?: IGeneratorOpts['type'];
+    checkEnable?: IGeneratorOpts['checkEnable'];
+    fn: IGeneratorOpts['fn'];
+    plugin: IGeneratorOpts['plugin'];
+    constructor(opts: IGeneratorOpts);
+}

package/dist/service/generator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Generator = exports.GeneratorType = void 0;
+var GeneratorType;
+(function (GeneratorType) {
+    GeneratorType["generate"] = "generate";
+    GeneratorType["enable"] = "enable";
+})(GeneratorType = exports.GeneratorType || (exports.GeneratorType = {}));
+class Generator {
+    constructor(opts) {
+        this.key = opts.key;
+        this.name = opts.name;
+        this.type = opts.type;
+        this.description = opts.description;
+        this.checkEnable = opts.checkEnable;
+        this.fn = opts.fn;
+        this.plugin = opts.plugin;
+    }
+}
+exports.Generator = Generator;

package/dist/service/hook.d.ts

@@ -0,0 +1,16 @@
+import { Plugin } from './plugin';
+export interface IOpts {
+    plugin: Plugin;
+    key: string;
+    fn: Function;
+    before?: string;
+    stage?: number;
+}
+export declare class Hook {
+    plugin: Plugin;
+    key: string;
+    fn: Function;
+    before?: string;
+    stage?: number;
+    constructor(opts: IOpts);
+}

package/dist/service/hook.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hook = void 0;
+const assert_1 = __importDefault(require("assert"));
+class Hook {
+    constructor(opts) {
+        (0, assert_1.default)(opts.key && opts.fn, `Invalid hook ${opts}, key and fn must supplied.`);
+        this.plugin = opts.plugin;
+        this.key = opts.key;
+        this.fn = opts.fn;
+        this.before = opts.before;
+        this.stage = opts.stage || 0;
+    }
+}
+exports.Hook = Hook;

package/dist/service/path.d.ts

@@ -0,0 +1,13 @@
+import { Env } from '../types';
+export declare function getPaths(opts: {
+    cwd: string;
+    prefix: string;
+    env: Env;
+}): {
+    cwd: string;
+    absSrcPath: string;
+    absPagesPath: string;
+    absTmpPath: string;
+    absNodeModulesPath: string;
+    absOutputPath: string;
+};

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,37 @@
+import { EnableBy, IPluginConfig } from '../types';
+import { IOpts as ICommandOpts } from './command';
+import { IGeneratorOpts } from './generator';
+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;
+    registerGenerator(opts: Omit<IGeneratorOpts, 'plugin'>): 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;
+}