@umijs/preset-umi 4.0.0-beta.10

package/dist/commands/help.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@umijs/utils");
+exports.default = (api) => {
+    api.registerCommand({
+        name: 'help',
+        description: 'show commands help',
+        details: `
+umi help build
+umi help dev
+`,
+        fn() {
+            const subCommand = api.args._[0];
+            if (subCommand) {
+                if (subCommand in api.service.commands) {
+                    showHelp(api.service.commands[subCommand]);
+                }
+                else {
+                    utils_1.logger.error(`Invalid sub command ${subCommand}.`);
+                }
+            }
+            else {
+                showHelps(api.service.commands);
+            }
+        },
+    });
+    function showHelp(command) {
+        console.log(`
+Usage: umi ${command.name} [options]
+${command.description ? `${utils_1.chalk.gray(command.description)}.\n` : ''}
+${command.options ? `Options:\n${padLeft(command.options)}\n` : ''}
+${command.details ? `Details:\n${padLeft(command.details)}` : ''}
+`);
+    }
+    function showHelps(commands) {
+        console.log(`
+Usage: umi <command> [options]
+
+Commands:
+
+${getDeps(commands)}
+`);
+        console.log(`Run \`${utils_1.chalk.bold('umi help <command>')}\` for more information of specific commands.`);
+        console.log(`Visit ${utils_1.chalk.bold('https://umijs.org/')} to learn more about Umi.`);
+        console.log();
+    }
+    function getDeps(commands) {
+        return Object.keys(commands)
+            .map((key) => {
+            return `    ${utils_1.chalk.green(utils_1.lodash.padEnd(key, 10))}${commands[key].description || ''}`;
+        })
+            .join('\n');
+    }
+    function padLeft(str) {
+        return str
+            .trim()
+            .split('\n')
+            .map((line) => `    ${line}`)
+            .join('\n');
+    }
+};

package/dist/commands/plugin.d.ts

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

package/dist/commands/plugin.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@umijs/utils");
+exports.default = (api) => {
+    api.registerCommand({
+        name: 'plugin',
+        description: 'inspect umi plugins',
+        fn({ args }) {
+            const command = args._[0];
+            console.log('command', command);
+            if (!command) {
+                throw new Error(`
+Sub command not found: umi plugin
+Did you mean:
+  umi plugin list
+        `);
+            }
+            switch (command) {
+                case 'list':
+                    getPluginList();
+                    break;
+                default:
+                    throw new Error(`Unsupported sub command ${command} for umi plugin.`);
+            }
+            function getPluginList() {
+                const localPlugins = ['./plugin.ts', './plugin.js'];
+                Object.keys(api.service.plugins).forEach((pluginId) => {
+                    const plugin = api.service.plugins[pluginId];
+                    if (localPlugins.includes(plugin.id))
+                        return console.info(`- ${plugin.id} ${utils_1.chalk.greenBright('(from local)')}`);
+                    if (plugin.id.startsWith('@umijs/preset'))
+                        return console.info(`- ${plugin.id} ${utils_1.chalk.cyanBright('(from preset)')}`);
+                    console.info(`- ${plugin.id}`);
+                });
+            }
+        },
+    });
+};

package/dist/commands/setup.d.ts

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

package/dist/commands/setup.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@umijs/utils");
+exports.default = (api) => {
+    api.registerCommand({
+        name: 'setup',
+        description: 'setup project',
+        fn() {
+            // generate tmp files
+            utils_1.logger.info('generate files');
+            api.applyPlugins({
+                key: 'onGenerateFiles',
+                args: {
+                    files: null,
+                    isFirstTime: false,
+                },
+            });
+        },
+    });
+};

package/dist/commands/version.d.ts

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

package/dist/commands/version.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (api) => {
+    api.registerCommand({
+        name: 'version',
+        alias: 'v',
+        description: 'show umi version',
+        fn({ args }) {
+            const version = require('../../package.json').version;
+            if (!args.quiet) {
+                console.log(`umi@${version}`);
+            }
+            return version;
+        },
+    });
+};

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_PORT = "8000";
+export declare const DEFAULT_HOST = "0.0.0.0";
+export declare const CACHE_DIR_NAME = ".cache";
+export declare const TEMPLATES_DIR: string;

package/dist/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEMPLATES_DIR = exports.CACHE_DIR_NAME = exports.DEFAULT_HOST = exports.DEFAULT_PORT = void 0;
+const path_1 = require("path");
+exports.DEFAULT_PORT = '8000';
+exports.DEFAULT_HOST = '0.0.0.0';
+exports.CACHE_DIR_NAME = '.cache';
+exports.TEMPLATES_DIR = (0, path_1.join)(__dirname, '../templates');

package/dist/features/__sample.d.ts

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

package/dist/features/__sample.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (api) => {
+    api;
+};

package/dist/features/appData/appData.d.ts

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

package/dist/features/appData/appData.js

@@ -0,0 +1,30 @@
+"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 path_1 = require("path");
+const routes_1 = require("../tmpFiles/routes");
+exports.default = (api) => {
+    api.modifyAppData((memo) => __awaiter(void 0, void 0, void 0, function* () {
+        memo.routes = yield (0, routes_1.getRoutes)({
+            api,
+        });
+        memo.hasSrcDir = api.paths.absSrcPath.endsWith('/src');
+        memo.npmClient = api.userConfig.npmClient || (0, utils_1.getNpmClient)();
+        memo.umi = {
+            version: require('../../../package.json').version,
+        };
+        memo.react = {
+            version: require((0, path_1.join)(api.config.alias.react, 'package.json')).version,
+        };
+        return memo;
+    }));
+};

package/dist/features/check/check.d.ts

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

package/dist/features/check/check.js

@@ -0,0 +1,34 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+exports.default = (api) => {
+    api.onCheck(() => __awaiter(void 0, void 0, void 0, function* () {
+        // routes
+        (0, assert_1.default)(api.appData.routes, `routes not found, you may be run umi on the wrong directory.`);
+        yield api.applyPlugins({
+            key: 'onChangePkgJSON',
+            args: {
+                current: api.appData.pkg,
+            },
+        });
+        yield api.applyPlugins({
+            key: 'onCheckConfig',
+            args: {
+                config: api.config,
+                userConfig: api.userConfig,
+            },
+        });
+    }));
+};

package/dist/features/configPlugins/configPlugins.d.ts

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

package/dist/features/configPlugins/configPlugins.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@umijs/bundler-webpack/dist/schema");
+const utils_1 = require("@umijs/utils");
+const path_1 = require("path");
+const schema_2 = require("./schema");
+function resolveProjectDep(opts) {
+    var _a, _b;
+    if (((_a = opts.pkg.dependencies) === null || _a === void 0 ? void 0 : _a[opts.dep]) ||
+        ((_b = opts.pkg.devDependencies) === null || _b === void 0 ? void 0 : _b[opts.dep])) {
+        return (0, path_1.dirname)(utils_1.resolve.sync(`${opts.dep}/package`, {
+            basedir: opts.cwd,
+        }));
+    }
+}
+exports.default = (api) => {
+    const configDefaults = {
+        alias: {
+            umi: process.env.UMI_DIR,
+            '@umijs/renderer-react': (0, path_1.dirname)(require.resolve('@umijs/renderer-react/package.json')),
+            react: resolveProjectDep({
+                pkg: api.pkg,
+                cwd: api.cwd,
+                dep: 'react',
+            }) || (0, path_1.dirname)(require.resolve('react/package.json')),
+            'react-dom': resolveProjectDep({
+                pkg: api.pkg,
+                cwd: api.cwd,
+                dep: 'react-dom',
+            }) || (0, path_1.dirname)(require.resolve('react-dom/package.json')),
+            'react-router': (0, path_1.dirname)(require.resolve('react-router/package.json')),
+            'react-router-dom': (0, path_1.dirname)(require.resolve('react-router-dom/package.json')),
+        },
+        externals: {},
+        autoCSSModules: true,
+        publicPath: '/',
+    };
+    const bundleSchemas = (0, schema_1.getSchemas)();
+    const extraSchemas = (0, schema_2.getSchemas)();
+    const schemas = Object.assign(Object.assign({}, bundleSchemas), extraSchemas);
+    for (const key of Object.keys(schemas)) {
+        const config = {
+            schema: schemas[key] || ((joi) => joi.any()),
+        };
+        if (key in configDefaults) {
+            config.default = configDefaults[key];
+        }
+        api.registerPlugins([
+            {
+                id: `virtual: config-${key}`,
+                key: key,
+                config,
+            },
+        ]);
+    }
+    // api.paths is ready after register
+    api.modifyConfig((memo, args) => {
+        memo.alias = Object.assign(Object.assign({}, memo.alias), { '@': args.paths.absSrcPath, '@@': args.paths.absTmpPath });
+        return memo;
+    });
+};

package/dist/features/configPlugins/schema.d.ts

@@ -0,0 +1,2 @@
+import type { Root } from '@umijs/core/compiled/@hapi/joi';
+export declare function getSchemas(): Record<string, (Joi: Root) => any>;

package/dist/features/configPlugins/schema.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemas = void 0;
+const utils_1 = require("@umijs/utils");
+function getSchemas() {
+    return {
+        plugins: (Joi) => Joi.array().items(Joi.string()),
+        publicPath: (Joi) => Joi.string().regex(/\/$/).error(new Error('publicPath must end with /')),
+        favicon: (Joi) => Joi.string(),
+        headScripts: (Joi) => Joi.array().items(Joi.alternatives(Joi.string())),
+        scripts: (Joi) => Joi.array().items(Joi.alternatives(Joi.string())),
+        npmClient: (Joi) => Joi.string().valid(utils_1.NpmClientEnum.pnpm, utils_1.NpmClientEnum.tnpm, utils_1.NpmClientEnum.cnpm, utils_1.NpmClientEnum.yarn, utils_1.NpmClientEnum.npm),
+        routes: (Joi) => Joi.array().items(Joi.object()),
+    };
+}
+exports.getSchemas = getSchemas;

package/dist/features/esmi/esmi.d.ts

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

package/dist/features/esmi/esmi.js

@@ -0,0 +1,44 @@
+"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 path_1 = require("path");
+const scan_1 = require("../../libs/scan");
+exports.default = (api) => {
+    api.describe({
+        key: 'esmi',
+        config: {
+            schema(Joi) {
+                return Joi.object();
+            },
+        },
+        enableBy: api.EnableBy.config,
+    });
+    api.onStart(() => {
+        if (!api.args.vite) {
+            throw new Error(`esmi can only be used in vite mode.`);
+        }
+    });
+    // 需要在 generate 之后是因为需要先等临时文件生成
+    api.onBeforeCompiler(() => __awaiter(void 0, void 0, void 0, function* () {
+        // scan and module graph
+        // TODO: module graph
+        if (api.args.vite) {
+            const resolver = (0, scan_1.createResolver)({
+                alias: api.config.alias,
+            });
+            api.appData.deps = yield (0, scan_1.scan)({
+                entry: (0, path_1.join)(api.paths.absTmpPath, 'umi.ts'),
+                externals: api.config.externals,
+                resolver,
+            });
+        }
+    }));
+};

package/dist/features/favicon/favicon.d.ts

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

package/dist/features/favicon/favicon.js

@@ -0,0 +1,58 @@
+"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 fs_1 = require("fs");
+const path_1 = require("path");
+const FAVICON_FILES = [
+    'favicon.ico',
+    'favicon.gif',
+    'favicon.png',
+    'favicon.jpg',
+    'favicon.jpeg',
+    'favicon.svg',
+    'favicon.avif',
+    'favicon.webp',
+];
+function getFaviconFile(p) {
+    return FAVICON_FILES.find((f) => (0, fs_1.existsSync)((0, path_1.join)(p, f)));
+}
+exports.default = (api) => {
+    api.modifyAppData((memo) => __awaiter(void 0, void 0, void 0, function* () {
+        if (api.config.favicon)
+            return memo;
+        const faviconFile = getFaviconFile(api.paths.absSrcPath);
+        if (faviconFile) {
+            memo.faviconFile = faviconFile;
+        }
+        return memo;
+    }));
+    api.addMiddlewares(() => [
+        (req, res, next) => {
+            if (api.appData.faviconFile &&
+                req.path === `/${api.appData.faviconFile}`) {
+                res.sendFile((0, path_1.join)(api.paths.absSrcPath, api.appData.faviconFile));
+            }
+            else {
+                next();
+            }
+        },
+    ]);
+    api.onBuildComplete(({ err }) => {
+        if (err)
+            return;
+        if (api.appData.faviconFile) {
+            (0, fs_1.copyFileSync)((0, path_1.join)(api.paths.absSrcPath, api.appData.faviconFile), (0, path_1.join)(api.paths.absOutputPath, api.appData.faviconFile));
+        }
+    });
+    api.modifyHTMLFavicon((memo) => {
+        return `${api.config.publicPath}${api.appData.faviconFile}` || memo;
+    });
+};

package/dist/features/lowImport/babelPlugin.d.ts

@@ -0,0 +1,17 @@
+import * as Babel from '@umijs/bundler-utils/compiled/babel/core';
+import * as t from '@umijs/bundler-utils/compiled/babel/types';
+import { IOpts } from './lowImport';
+interface IPluginOpts {
+    opts: IOpts;
+}
+export default function (): {
+    visitor: {
+        Identifier(path: Babel.NodePath<t.Identifier>, state: {
+            opts: IPluginOpts;
+        }): void;
+        MemberExpression(path: Babel.NodePath<t.MemberExpression>, state: {
+            opts: IPluginOpts;
+        }): void;
+    };
+};
+export {};

package/dist/features/lowImport/babelPlugin.js

@@ -0,0 +1,68 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const helper_module_imports_1 = require("@umijs/bundler-utils/compiled/babel/helper-module-imports");
+const t = __importStar(require("@umijs/bundler-utils/compiled/babel/types"));
+function default_1() {
+    return {
+        visitor: {
+            Identifier(path, state) {
+                var _a, _b;
+                const { name } = path.node;
+                if (path.scope.hasBinding(path.node.name)) {
+                    return;
+                }
+                const parentNode = path.parentPath.node;
+                if (t.isImportSpecifier(parentNode) ||
+                    t.isImportDefaultSpecifier(parentNode) ||
+                    t.isImportNamespaceSpecifier(parentNode)) {
+                    return;
+                }
+                if ((_a = state.opts.opts.identifierToLib) === null || _a === void 0 ? void 0 : _a[name]) {
+                    path.replaceWith((0, helper_module_imports_1.addNamed)(path, name, state.opts.opts.identifierToLib[name]));
+                }
+                else if ((_b = state.opts.opts.defaultToLib) === null || _b === void 0 ? void 0 : _b[name]) {
+                    path.replaceWith((0, helper_module_imports_1.addDefault)(path, state.opts.opts.defaultToLib[name], {
+                        nameHint: name,
+                    }));
+                }
+                // TODO: state.opts.opts.namespaceToLib
+            },
+            MemberExpression(path, state) {
+                const { object, property } = path.node;
+                if (path.scope.hasBinding(object.name)) {
+                    return;
+                }
+                const parentNode = path.parentPath.node;
+                if (t.isImportSpecifier(parentNode) ||
+                    t.isImportDefaultSpecifier(parentNode) ||
+                    t.isImportNamespaceSpecifier(parentNode)) {
+                    return;
+                }
+                if (state.opts.opts.withObjs[object.name] &&
+                    (state.opts.opts.withObjs[object.name].members || []).includes(property.name)) {
+                    path.replaceWith((0, helper_module_imports_1.addNamed)(path, property.name, state.opts.opts.withObjs[object.name].importFrom));
+                }
+            },
+        },
+    };
+}
+exports.default = default_1;

package/dist/features/lowImport/lowImport.d.ts

@@ -0,0 +1,9 @@
+import { IApi } from '../../types';
+export interface IOpts {
+    withObjs: Record<string, any>;
+    identifierToLib: Record<string, string>;
+    defaultToLib: Record<string, string>;
+    namespaceToLib: Record<string, string>;
+}
+declare const _default: (api: IApi) => void;
+export default _default;

package/dist/features/lowImport/lowImport.js

@@ -0,0 +1,108 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Inspired by
+// - https://github.com/google/zx
+// - https://github.com/antfu/unplugin-auto-import
+const fs_1 = require("fs");
+const path_1 = require("path");
+const babelPlugin_1 = __importDefault(require("./babelPlugin"));
+exports.default = (api) => {
+    api.describe({
+        key: 'lowImport',
+        config: {
+            schema(Joi) {
+                return Joi.object({
+                    libs: Joi.array(),
+                });
+            },
+        },
+        enableBy: api.EnableBy.config,
+    });
+    api.modifyAppData((memo) => __awaiter(void 0, void 0, void 0, function* () {
+        memo.lowImport = [
+            yield api.applyPlugins({
+                key: 'addLowImportLibs',
+                initialValue: [],
+            }),
+            ...(api.config.lowImport.libs || []),
+        ];
+    }));
+    api.onStart(() => {
+        // generate dts
+        const dts = api.appData.lowImport.map((lib) => {
+            if (lib.withObj) {
+                const memberDts = (lib.members || [])
+                    .map((member) => `${member}: typeof import('${lib.importFrom}')['${member}'],`)
+                    .join('\n');
+                return `const ${lib.withObj} = {\n${memberDts}\n};`;
+            }
+            else if (lib.namespaceImport) {
+                return `const ${lib.namespaceImport}: typeof import('${lib.importFrom}');`;
+            }
+            else if (lib.defaultImport) {
+                return `const ${lib.defaultImport}: typeof import('${lib.importFrom}')['default'];`;
+            }
+            else {
+                return (lib.members || [])
+                    .map((member) => `const ${member}: typeof import('${lib.importFrom}')['${member}'];`)
+                    .join('\n');
+            }
+        });
+        const content = `
+// generated by umi
+declare global {
+${dts}
+}
+export {}
+    `.trim() + `\n`;
+        (0, fs_1.writeFileSync)((0, path_1.join)(api.paths.cwd, 'lowImport.d.ts'), content, 'utf-8');
+    });
+    api.addBeforeBabelPresets(() => {
+        const opts = normalizeLibs(api.appData.lowImport);
+        return [
+            {
+                plugins: [[babelPlugin_1.default, { opts }]],
+            },
+        ];
+    });
+};
+function normalizeLibs(libs) {
+    const withObjs = {};
+    const identifierToLib = {};
+    const defaultToLib = {};
+    const namespaceToLib = {};
+    for (const lib of libs) {
+        if (lib.withObj) {
+            withObjs[lib.withObj] = lib;
+        }
+        else if (lib.namespaceImport) {
+            namespaceToLib[lib.namespaceImport] = lib.importFrom;
+        }
+        else if (lib.defaultImport) {
+            defaultToLib[lib.defaultImport] = lib.importFrom;
+        }
+        else {
+            for (const member of lib.members || []) {
+                identifierToLib[member] = lib.importFrom;
+            }
+        }
+    }
+    return {
+        withObjs,
+        identifierToLib,
+        defaultToLib,
+        namespaceToLib,
+    };
+}