@umijs/core 3.5.20 → 4.0.0-beta.12

package/dist/route/routesConfig.d.ts

@@ -0,0 +1,5 @@
+interface IOpts {
+    routes: any[];
+}
+export declare function getConfigRoutes(opts: IOpts): any[];
+export {};

package/dist/route/routesConfig.js

@@ -0,0 +1,37 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigRoutes = void 0;
+function getConfigRoutes(opts) {
+    const memo = { ret: {}, id: 1 };
+    transformRoutes({ routes: opts.routes, parentId: undefined, memo });
+    return memo.ret;
+}
+exports.getConfigRoutes = getConfigRoutes;
+function transformRoutes(opts) {
+    opts.routes.forEach((route) => {
+        transformRoute({ route, parentId: opts.parentId, memo: opts.memo });
+    });
+}
+function transformRoute(opts) {
+    const id = String(opts.memo.id++);
+    const _a = opts.route, { routes, component } = _a, routeProps = __rest(_a, ["routes", "component"]);
+    opts.memo.ret[id] = Object.assign(Object.assign(Object.assign(Object.assign({}, routeProps), { path: opts.route.path }), (component ? { file: component } : {})), { parentId: opts.parentId, id });
+    if (opts.route.routes) {
+        transformRoutes({
+            routes: opts.route.routes,
+            parentId: id,
+            memo: opts.memo,
+        });
+    }
+}

package/dist/route/routesConvention.d.ts

@@ -0,0 +1,4 @@
+export declare function getConventionRoutes(opts: {
+    base: string;
+    prefix?: 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: `${opts.prefix || ''}${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) => __awaiter(this, void 0, void 0, function* () {
+                    yield (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.`);
+                        }
+                    }
+                    yield 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,
+                    });
+                    yield 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,56 @@
+import { EnableBy, Env, 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 | ((opts: {
+        config: any;
+        env: Env;
+    }) => boolean);
+    constructor(opts: IOpts);
+    merge(opts: {
+        key?: string;
+        config?: IPluginConfig;
+        enableBy?: any;
+    }): 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 {};