@umijs/core 3.5.18 → 4.0.0-beta.2

package/README.md

@@ -1 +1,3 @@
 # @umijs/core
+
+See our website [umijs](https://umijs.org) for more information.

package/dist/config/config.d.ts

@@ -0,0 +1,63 @@
+import { Env } from '../types';
+interface IOpts {
+    cwd: string;
+    env: Env;
+    specifiedEnv?: string;
+    defaultConfigFiles?: string[];
+}
+declare type ISchema = Record<string, any>;
+declare type IOnChangeTypes = Record<string, string | Function>;
+export declare class Config {
+    opts: IOpts;
+    mainConfigFile: string | null;
+    prevConfig: any;
+    files: string[];
+    constructor(opts: IOpts);
+    getUserConfig(): {
+        config: {};
+        files: string[];
+    };
+    getConfig(opts: {
+        schemas: ISchema;
+    }): {
+        config: {};
+        files: string[];
+    };
+    watch(opts: {
+        schemas: ISchema;
+        onChangeTypes: IOnChangeTypes;
+        onChange: (opts: {
+            data: ReturnType<typeof Config.diffConfigs>;
+            event: string;
+            path: string;
+        }) => Promise<void>;
+    }): () => Promise<void>;
+    static getMainConfigFile(opts: {
+        cwd: string;
+        defaultConfigFiles?: string[];
+    }): string | null;
+    static getConfigFiles(opts: {
+        mainConfigFile: string | null;
+        env: Env;
+        specifiedEnv?: string;
+    }): string[];
+    static getUserConfig(opts: {
+        configFiles: string[];
+    }): {
+        config: {};
+        files: string[];
+    };
+    static validateConfig(opts: {
+        config: any;
+        schemas: ISchema;
+    }): void;
+    static diffConfigs(opts: {
+        origin: any;
+        updated: any;
+        onChangeTypes: IOnChangeTypes;
+    }): {
+        changes: Record<string, string[]>;
+        fns: Function[];
+    };
+}
+export {};

package/dist/config/config.js

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+const esbuild_1 = __importDefault(require("@umijs/bundler-utils/compiled/esbuild"));
+const utils_1 = require("@umijs/utils");
+const assert_1 = __importDefault(require("assert"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const joi_1 = __importDefault(require("../../compiled/@hapi/joi"));
+const just_diff_1 = require("../../compiled/just-diff");
+const constants_1 = require("../constants");
+const utils_2 = require("./utils");
+class Config {
+    constructor(opts) {
+        this.files = [];
+        this.opts = opts;
+        this.mainConfigFile = Config.getMainConfigFile(this.opts);
+        this.prevConfig = null;
+    }
+    getUserConfig() {
+        const configFiles = Config.getConfigFiles({
+            mainConfigFile: this.mainConfigFile,
+            env: this.opts.env,
+            specifiedEnv: this.opts.specifiedEnv,
+        });
+        return Config.getUserConfig({
+            configFiles: (0, utils_2.getAbsFiles)({
+                files: configFiles,
+                cwd: this.opts.cwd,
+            }),
+        });
+    }
+    getConfig(opts) {
+        const { config, files } = this.getUserConfig();
+        Config.validateConfig({ config, schemas: opts.schemas });
+        this.files = files;
+        return (this.prevConfig = {
+            config: config,
+            files,
+        });
+    }
+    watch(opts) {
+        const watcher = utils_1.chokidar.watch([
+            ...this.files,
+            ...(this.mainConfigFile
+                ? []
+                : (0, utils_2.getAbsFiles)({
+                    files: this.opts.defaultConfigFiles || constants_1.DEFAULT_CONFIG_FILES,
+                    cwd: this.opts.cwd,
+                })),
+        ], {
+            ignoreInitial: true,
+            cwd: this.opts.cwd,
+        });
+        watcher.on('all', utils_1.lodash.debounce((event, path) => {
+            const { config: origin } = this.prevConfig;
+            const { config: updated, files } = this.getConfig({
+                schemas: opts.schemas,
+            });
+            watcher.add(files);
+            const data = Config.diffConfigs({
+                origin,
+                updated,
+                onChangeTypes: opts.onChangeTypes,
+            });
+            opts
+                .onChange({
+                data,
+                event,
+                path,
+            })
+                .catch((e) => {
+                throw new Error(e);
+            });
+        }, constants_1.WATCH_DEBOUNCE_STEP));
+        return () => watcher.close();
+    }
+    static getMainConfigFile(opts) {
+        let mainConfigFile = null;
+        for (const configFile of opts.defaultConfigFiles || constants_1.DEFAULT_CONFIG_FILES) {
+            const absConfigFile = (0, path_1.join)(opts.cwd, configFile);
+            if ((0, fs_1.existsSync)(absConfigFile)) {
+                mainConfigFile = absConfigFile;
+                break;
+            }
+        }
+        return mainConfigFile;
+    }
+    static getConfigFiles(opts) {
+        const ret = [];
+        const { mainConfigFile } = opts;
+        const specifiedEnv = opts.specifiedEnv || '';
+        if (mainConfigFile) {
+            const env = constants_1.SHORT_ENV[opts.env] || opts.env;
+            ret.push(...[
+                mainConfigFile,
+                specifiedEnv &&
+                    (0, utils_2.addExt)({ file: mainConfigFile, ext: `.${specifiedEnv}` }),
+                (0, utils_2.addExt)({ file: mainConfigFile, ext: `.${env}` }),
+                specifiedEnv &&
+                    (0, utils_2.addExt)({
+                        file: mainConfigFile,
+                        ext: `.${env}.${specifiedEnv}`,
+                    }),
+                (0, utils_2.addExt)({ file: mainConfigFile, ext: constants_1.LOCAL_EXT }),
+            ].filter(Boolean));
+        }
+        return ret;
+    }
+    static getUserConfig(opts) {
+        let config = {};
+        let files = [];
+        for (const configFile of opts.configFiles) {
+            files.push(configFile);
+            if ((0, fs_1.existsSync)(configFile)) {
+                utils_1.register.register({
+                    implementor: esbuild_1.default,
+                });
+                utils_1.register.clearFiles();
+                config = utils_1.lodash.merge(config, require(configFile).default);
+                for (const file of utils_1.register.getFiles()) {
+                    delete require.cache[file];
+                }
+                files.push(...utils_1.register.getFiles());
+            }
+        }
+        return {
+            config,
+            files,
+        };
+    }
+    static validateConfig(opts) {
+        const errors = new Map();
+        const configKeys = new Set(Object.keys(opts.config));
+        for (const key of Object.keys(opts.schemas)) {
+            configKeys.delete(key);
+            if (!opts.config[key])
+                continue;
+            const schema = opts.schemas[key](joi_1.default);
+            // invalid schema
+            (0, assert_1.default)(joi_1.default.isSchema(schema), `schema for config ${key} is not valid.`);
+            const { error } = schema.validate(opts.config[key]);
+            if (error)
+                errors.set(key, error);
+        }
+        // invalid config values
+        (0, assert_1.default)(errors.size === 0, `Invalid config values: ${Array.from(errors.keys()).join(', ')}
+${Array.from(errors.keys()).map((key) => {
+            return `Invalid value for ${key}:\n${errors.get(key).message}`;
+        })}`);
+        // invalid config keys
+        (0, assert_1.default)(configKeys.size === 0, `Invalid config keys: ${Array.from(configKeys).join(', ')}`);
+    }
+    static diffConfigs(opts) {
+        const patch = (0, just_diff_1.diff)(opts.origin, opts.updated);
+        const changes = {};
+        const fns = [];
+        for (const item of patch) {
+            const key = item.path[0];
+            const onChange = opts.onChangeTypes[key];
+            (0, assert_1.default)(onChange, `Invalid onChange config for key ${key}`);
+            if (typeof onChange === 'string') {
+                changes[onChange] || (changes[onChange] = []);
+                changes[onChange].push(String(key));
+            }
+            else if (typeof onChange === 'function') {
+                fns.push(onChange);
+            }
+            else {
+                throw new Error(`Invalid onChange value for key ${key}`);
+            }
+        }
+        return {
+            changes,
+            fns,
+        };
+    }
+}
+exports.Config = Config;

package/dist/config/utils.d.ts

@@ -0,0 +1,8 @@
+export declare function addExt(opts: {
+    file: string;
+    ext: string;
+}): string;
+export declare function getAbsFiles(opts: {
+    files: string[];
+    cwd: string;
+}): string[];

package/dist/config/utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAbsFiles = exports.addExt = void 0;
+const path_1 = require("path");
+function addExt(opts) {
+    const index = opts.file.lastIndexOf('.');
+    return `${opts.file.slice(0, index)}${opts.ext}${opts.file.slice(index)}`;
+}
+exports.addExt = addExt;
+function getAbsFiles(opts) {
+    return opts.files.map((file) => {
+        return (0, path_1.isAbsolute)(file) ? file : (0, path_1.join)(opts.cwd, file);
+    });
+}
+exports.getAbsFiles = getAbsFiles;

package/dist/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_CONFIG_FILES: string[];
+export declare const SHORT_ENV: {
+    development: string;
+    production: string;
+    test: string;
+};
+export declare const LOCAL_EXT = ".local";
+export declare const WATCH_DEBOUNCE_STEP = 300;
+export declare const DEFAULT_FRAMEWORK_NAME = "umi";

package/dist/constants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FRAMEWORK_NAME = exports.WATCH_DEBOUNCE_STEP = exports.LOCAL_EXT = exports.SHORT_ENV = exports.DEFAULT_CONFIG_FILES = void 0;
+exports.DEFAULT_CONFIG_FILES = ['config.ts', 'config.js'];
+exports.SHORT_ENV = {
+    development: 'dev',
+    production: 'prod',
+    test: 'test',
+};
+exports.LOCAL_EXT = '.local';
+exports.WATCH_DEBOUNCE_STEP = 300;
+exports.DEFAULT_FRAMEWORK_NAME = 'umi';

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './config/config';
+export * from './route/route';
+export { GeneratorType, IGeneratorOpts } from './service/generator';
+export * from './service/pluginAPI';
+export * from './service/service';
+export { Env, IAdd, IEvent, IModify, IRoute } from './types';

package/dist/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Env = exports.GeneratorType = void 0;
+__exportStar(require("./config/config"), exports);
+__exportStar(require("./route/route"), exports);
+var generator_1 = require("./service/generator");
+Object.defineProperty(exports, "GeneratorType", { enumerable: true, get: function () { return generator_1.GeneratorType; } });
+__exportStar(require("./service/pluginAPI"), exports);
+__exportStar(require("./service/service"), exports);
+var types_1 = require("./types");
+Object.defineProperty(exports, "Env", { enumerable: true, get: function () { return types_1.Env; } });

package/dist/route/defineRoutes.d.ts

@@ -0,0 +1 @@
+export declare function defineRoutes(callback: (defineRoute: Function) => void): any;

package/dist/route/defineRoutes.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineRoutes = void 0;
+const utils_1 = require("./utils");
+function defineRoutes(callback) {
+    const routes = Object.create(null);
+    const parentRoutes = [];
+    const defineRoute = (opts) => {
+        opts.options = opts.options || {};
+        const route = {
+            path: opts.path || '/',
+            id: (0, utils_1.createRouteId)(opts.file),
+            parentId: parentRoutes.length > 0
+                ? parentRoutes[parentRoutes.length - 1].id
+                : undefined,
+            file: opts.file,
+        };
+        routes[route.id] = route;
+        if (opts.children) {
+            parentRoutes.push(route);
+            opts.children();
+            parentRoutes.pop();
+        }
+    };
+    callback(defineRoute);
+    return routes;
+}
+exports.defineRoutes = defineRoutes;

package/dist/route/route.d.ts

@@ -0,0 +1,2 @@
+export * from './routesConvention';
+export * from './routeUtils';

package/dist/route/route.js

@@ -0,0 +1,18 @@
+"use strict";
+// TODO
+// [x] convention route
+// config route
+// programming route
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./routesConvention"), exports);
+__exportStar(require("./routeUtils"), exports);

package/dist/route/routeUtils.d.ts

@@ -0,0 +1,7 @@
+import { IRoute } from '../types';
+export declare function addParentRoute(opts: {
+    id?: string;
+    addToAll?: boolean;
+    target: IRoute;
+    routes: Record<string, IRoute>;
+}): void;

package/dist/route/routeUtils.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addParentRoute = void 0;
+function addParentRoute(opts) {
+    if (opts.addToAll) {
+        for (const id of Object.keys(opts.routes)) {
+            if (opts.routes[id].parentId === undefined) {
+                opts.routes[id].parentId = opts.target.id;
+            }
+        }
+    }
+    else if (opts.id) {
+        opts.routes[opts.id].parentId = opts.target.id;
+    }
+    else {
+        throw new Error(`addParentRoute failed, opts.addToAll or opts.id must be supplied.`);
+    }
+    // add new route
+    opts.routes[opts.target.id] = opts.target;
+}
+exports.addParentRoute = addParentRoute;

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;