@umijs/preset-umi 4.0.0-beta.10

package/dist/features/mock/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const VALID_METHODS: string[];
+export declare const DEFAULT_METHOD = "GET";
+export declare const MOCK_FILE_GLOB = "mock/**/*.[jt]s";

package/dist/features/mock/constants.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOCK_FILE_GLOB = exports.DEFAULT_METHOD = exports.VALID_METHODS = void 0;
+exports.VALID_METHODS = [
+    'GET',
+    'POST',
+    'PUT',
+    'DELETE',
+    'PATCH',
+    'HEAD',
+    'OPTIONS',
+];
+exports.DEFAULT_METHOD = 'GET';
+exports.MOCK_FILE_GLOB = 'mock/**/*.[jt]s';

package/dist/features/mock/createMockMiddleware.d.ts

@@ -0,0 +1,7 @@
+import type { RequestHandler } from '@umijs/bundler-webpack/compiled/express';
+import type { IMock } from './getMockData';
+export declare function createMockMiddleware(opts: {
+    context: {
+        mockData: Record<string, IMock>;
+    };
+}): RequestHandler;

package/dist/features/mock/createMockMiddleware.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockMiddleware = void 0;
+const path_to_regexp_1 = __importDefault(require("path-to-regexp"));
+const body_parser_1 = __importDefault(require("../../../compiled/body-parser"));
+const multer_1 = __importDefault(require("../../../compiled/multer"));
+function createMockMiddleware(opts) {
+    return (req, res, next) => {
+        const method = req.method.toUpperCase();
+        for (const key of Object.keys(opts.context.mockData)) {
+            const mock = opts.context.mockData[key];
+            if (mock.method !== method)
+                continue;
+            const { keys, re } = getPathReAndKeys(mock.path);
+            const m = re.exec(req.path);
+            if (m) {
+                if (typeof mock.handler === 'function') {
+                    // add params
+                    const params = {};
+                    for (let i = 1; i < m.length; i += 1) {
+                        const key = keys[i - 1];
+                        const prop = key.name;
+                        const val = decodeParam(m[i]);
+                        if (val !== undefined) {
+                            params[prop] = val;
+                        }
+                    }
+                    req.params = params;
+                    // handler
+                    if (method === 'GET') {
+                        mock.handler(req, res, next);
+                    }
+                    else {
+                        const jsonOpts = { limit: '5mb', strict: false };
+                        const urlEncodedOpts = { limit: '5mb', extended: true };
+                        // body parser + multer
+                        body_parser_1.default.json(jsonOpts)(req, res, () => {
+                            body_parser_1.default.urlencoded(urlEncodedOpts)(req, res, () => {
+                                (0, multer_1.default)().any()(req, res, () => {
+                                    mock.handler(req, res, next);
+                                });
+                            });
+                        });
+                    }
+                }
+                else {
+                    res.status(200).json(mock.handler);
+                }
+                return;
+            }
+        }
+        next();
+    };
+}
+exports.createMockMiddleware = createMockMiddleware;
+// TODO: cache
+function getPathReAndKeys(path) {
+    const keys = [];
+    const re = (0, path_to_regexp_1.default)(path, keys);
+    return { re, keys };
+}
+function decodeParam(val) {
+    if (typeof val !== 'string' || val.length === 0) {
+        return val;
+    }
+    try {
+        return decodeURIComponent(val);
+    }
+    catch (err) {
+        if (err instanceof URIError) {
+            err.message = `Failed to decode param ' ${val} '`;
+            // @ts-ignore
+            err.status = 400;
+            // @ts-ignore
+            err.statusCode = 400;
+        }
+        throw err;
+    }
+}

package/dist/features/mock/getMockData.d.ts

@@ -0,0 +1,9 @@
+export interface IMock {
+    method: string;
+    path: string;
+    handler: Function;
+    file?: string;
+}
+export declare function getMockData(opts: {
+    cwd: string;
+}): Record<string, IMock>;

package/dist/features/mock/getMockData.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMockData = 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 constants_1 = require("./constants");
+function getMockData(opts) {
+    utils_1.register.register({
+        implementor: esbuild_1.default,
+    });
+    utils_1.register.clearFiles();
+    const ret = utils_1.glob
+        .sync(constants_1.MOCK_FILE_GLOB, { cwd: opts.cwd })
+        .reduce((memo, file) => {
+        const mockFile = `${opts.cwd}/${file}`;
+        const m = require(mockFile);
+        const obj = m.default;
+        for (const key of Object.keys(obj)) {
+            const mock = getMock({ key, obj });
+            mock.file = mockFile;
+            // check conflict
+            const id = `${mock.method} ${mock.path}`;
+            (0, assert_1.default)(utils_1.lodash.isArray(mock.handler) ||
+                utils_1.lodash.isPlainObject(mock.handler) ||
+                typeof mock.handler === 'function', `Mock handler must be function or array or object, but got ${typeof mock.handler} for ${mock.method} in ${mock.file}`);
+            if (memo[id]) {
+                throw new Error(`${id} is duplicated in ${mockFile} and ${memo[id].file}`);
+            }
+            memo[id] = mock;
+        }
+        return memo;
+    }, {});
+    for (const file of utils_1.register.getFiles()) {
+        delete require.cache[file];
+    }
+    utils_1.register.restore();
+    return ret;
+}
+exports.getMockData = getMockData;
+function getMock(opts) {
+    const { method, path } = parseKey(opts.key);
+    const handler = opts.obj[opts.key];
+    return { method, path, handler };
+}
+function parseKey(key) {
+    const spliced = key.split(' ');
+    const len = spliced.length;
+    if (len === 1) {
+        return { method: constants_1.DEFAULT_METHOD, path: key };
+    }
+    else {
+        const [method, path] = spliced;
+        const upperCaseMethod = method.toUpperCase();
+        (0, assert_1.default)(constants_1.VALID_METHODS.includes(upperCaseMethod), `method ${method} is not supported`);
+        return { method: upperCaseMethod, path };
+    }
+}

package/dist/features/mock/mock.d.ts

@@ -0,0 +1,2 @@
+import { IApi } from '../../types';
+export default function (api: IApi): void;

package/dist/features/mock/mock.js

@@ -0,0 +1,50 @@
+"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 watch_1 = require("../../commands/dev/watch");
+const createMockMiddleware_1 = require("./createMockMiddleware");
+const getMockData_1 = require("./getMockData");
+function default_1(api) {
+    api.describe({
+        key: 'mock',
+        config: {
+            schema(Joi) {
+                return Joi.object().keys({
+                    exclude: Joi.array()
+                        .items(Joi.string())
+                        .description('exclude files not parse mock'),
+                });
+            },
+        },
+    });
+    // context for update mockData
+    const context = {
+        mockData: null,
+    };
+    api.onStart(() => {
+        (0, watch_1.watch)({
+            path: `${api.cwd}/mock`,
+            addToUnWatches: true,
+            onChange: () => {
+                context.mockData = (0, getMockData_1.getMockData)({ cwd: api.cwd });
+            },
+        });
+    });
+    api.addBeforeMiddlewares(() => __awaiter(this, void 0, void 0, function* () {
+        context.mockData = (0, getMockData_1.getMockData)({ cwd: api.cwd });
+        return [
+            (0, createMockMiddleware_1.createMockMiddleware)({
+                context,
+            }),
+        ];
+    }));
+}
+exports.default = default_1;

package/dist/features/polyfill/polyfill.d.ts

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

package/dist/features/polyfill/polyfill.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (api) => {
+    api.addPolyfillImports(() => {
+        var _a;
+        return api.config.publicPath === 'auto' && ((_a = api.config.targets) === null || _a === void 0 ? void 0 : _a.ie)
+            ? [
+                {
+                    source: require.resolve('current-script-polyfill'),
+                },
+            ]
+            : [];
+    });
+};

package/dist/features/tmpFiles/importsToStr.d.ts

@@ -0,0 +1,4 @@
+export declare function importsToStr(imports: {
+    source: string;
+    specifier?: string;
+}[]): string[];

package/dist/features/tmpFiles/importsToStr.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importsToStr = void 0;
+const winPath_1 = require("@umijs/utils/dist/winPath");
+function importsToStr(imports) {
+    return imports.map((imp) => {
+        const { source, specifier } = imp;
+        if (specifier) {
+            return `import ${specifier} from '${(0, winPath_1.winPath)(source)}';`;
+        }
+        else {
+            return `import '${(0, winPath_1.winPath)(source)}';`;
+        }
+    });
+}
+exports.importsToStr = importsToStr;

package/dist/features/tmpFiles/routes.d.ts

@@ -0,0 +1,8 @@
+import { IApi } from '../../types';
+export declare function getRoutes(opts: {
+    api: IApi;
+}): Promise<any>;
+export declare function getRouteComponents(opts: {
+    routes: Record<string, any>;
+    prefix: string;
+}): Promise<string>;

package/dist/features/tmpFiles/routes.js

@@ -0,0 +1,74 @@
+"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 });
+exports.getRouteComponents = exports.getRoutes = void 0;
+const core_1 = require("@umijs/core");
+const utils_1 = require("@umijs/utils");
+const fs_1 = require("fs");
+const path_1 = require("path");
+// get route config
+function getRoutes(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let routes = null;
+        if (opts.api.config.routes) {
+            routes = (0, core_1.getConfigRoutes)({
+                routes: opts.api.config.routes,
+            });
+        }
+        else {
+            routes = (0, core_1.getConventionRoutes)({
+                base: opts.api.paths.absPagesPath,
+                prefix: '',
+            });
+        }
+        const absLayoutPath = (0, path_1.join)(opts.api.paths.absSrcPath, 'layouts/index.tsx');
+        const layouts = yield opts.api.applyPlugins({
+            key: 'addLayouts',
+            initialValue: [
+                (0, fs_1.existsSync)(absLayoutPath) && {
+                    id: '@@/global-layout',
+                    file: absLayoutPath,
+                },
+            ].filter(Boolean),
+        });
+        for (const layout of layouts) {
+            (0, core_1.addParentRoute)({
+                addToAll: true,
+                target: {
+                    id: layout.id,
+                    path: '/',
+                    file: layout.file,
+                    parentId: undefined,
+                },
+                routes,
+            });
+        }
+        return routes;
+    });
+}
+exports.getRoutes = getRoutes;
+function getRouteComponents(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const imports = Object.keys(opts.routes)
+            .map((key) => {
+            const route = opts.routes[key];
+            if (!route.file)
+                return `// ${key}: no file to import`;
+            const path = (0, path_1.isAbsolute)(route.file) || route.file.startsWith('@/')
+                ? route.file
+                : `${opts.prefix}${route.file}`;
+            return `'${key}': () => import('${(0, utils_1.winPath)(path)}'),`;
+        })
+            .join('\n');
+        return `{\n${imports}\n}`;
+    });
+}
+exports.getRouteComponents = getRouteComponents;

package/dist/features/tmpFiles/tmpFiles.d.ts

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

package/dist/features/tmpFiles/tmpFiles.js

@@ -0,0 +1,124 @@
+"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 fs_1 = require("fs");
+const path_1 = require("path");
+const constants_1 = require("../../constants");
+const importsToStr_1 = require("./importsToStr");
+const routes_1 = require("./routes");
+exports.default = (api) => {
+    api.describe({
+        key: 'tmpFiles',
+        config: {
+            schema(Joi) {
+                return Joi.boolean();
+            },
+        },
+    });
+    api.onGenerateFiles((opts) => __awaiter(void 0, void 0, void 0, function* () {
+        // umi.ts
+        api.writeTmpFile({
+            path: 'umi.ts',
+            tplPath: (0, path_1.join)(constants_1.TEMPLATES_DIR, 'umi.tpl'),
+            context: {
+                rendererPath: yield api.applyPlugins({
+                    key: 'modifyRendererPath',
+                    initialValue: '@umijs/renderer-react',
+                }),
+                entryCode: (yield api.applyPlugins({
+                    key: 'addEntryCode',
+                    initialValue: [],
+                })).join('\n'),
+                entryCodeAhead: (yield api.applyPlugins({
+                    key: 'addEntryCodeAhead',
+                    initialValue: [],
+                })).join('\n'),
+                polyfillImports: (0, importsToStr_1.importsToStr)(yield api.applyPlugins({
+                    key: 'addPolyfillImports',
+                    initialValue: [],
+                })).join('\n'),
+                importsAhead: (0, importsToStr_1.importsToStr)(yield api.applyPlugins({
+                    key: 'addEntryImportsAhead',
+                    initialValue: [],
+                })).join('\n'),
+                imports: (0, importsToStr_1.importsToStr)(yield api.applyPlugins({
+                    key: 'addEntryImports',
+                    initialValue: [],
+                })).join('\n'),
+            },
+        });
+        // route.ts
+        let routes;
+        if (opts.isFirstTime) {
+            routes = api.appData.routes;
+        }
+        else {
+            routes = yield (0, routes_1.getRoutes)({
+                api,
+            });
+        }
+        const hasSrc = api.appData.hasSrcDir;
+        // @/pages/
+        const prefix = hasSrc ? '../../../src/pages/' : '../../pages/';
+        api.writeTmpFile({
+            path: 'core/route.ts',
+            tplPath: (0, path_1.join)(constants_1.TEMPLATES_DIR, 'route.tpl'),
+            context: {
+                routes: JSON.stringify(routes),
+                routeComponents: yield (0, routes_1.getRouteComponents)({ routes, prefix }),
+            },
+        });
+        // plugin.ts
+        const plugins = yield api.applyPlugins({
+            key: 'addRuntimePlugin',
+            initialValue: [
+                // TODO: add tryFiles in @umijs/utils
+                (0, fs_1.existsSync)((0, path_1.join)(api.paths.absSrcPath, 'app.ts')) &&
+                    (0, path_1.join)(api.paths.absSrcPath, 'app.ts'),
+                (0, fs_1.existsSync)((0, path_1.join)(api.paths.absSrcPath, 'app.tsx')) &&
+                    (0, path_1.join)(api.paths.absSrcPath, 'app.tsx'),
+                (0, fs_1.existsSync)((0, path_1.join)(api.paths.absSrcPath, 'app.jsx')) &&
+                    (0, path_1.join)(api.paths.absSrcPath, 'app.jsx'),
+                (0, fs_1.existsSync)((0, path_1.join)(api.paths.absSrcPath, 'app.js')) &&
+                    (0, path_1.join)(api.paths.absSrcPath, 'app.js'),
+            ]
+                .filter(Boolean)
+                .slice(0, 1),
+        });
+        const validKeys = yield api.applyPlugins({
+            key: 'addRuntimePluginKey',
+            initialValue: [
+                // TODO: support these methods
+                // 'modifyClientRenderOpts',
+                // 'patchRoutes',
+                'rootContainer',
+                'innerProvider',
+                'i18nProvider',
+                'dataflowProvider',
+                'outerProvider',
+                // 'render',
+                // 'onRouteChange',
+            ],
+        });
+        api.writeTmpFile({
+            path: 'core/plugin.ts',
+            tplPath: (0, path_1.join)(constants_1.TEMPLATES_DIR, 'plugin.tpl'),
+            context: {
+                plugins: plugins.map((plugin, index) => ({
+                    index,
+                    path: (0, utils_1.winPath)(plugin),
+                })),
+                validKeys: validKeys,
+            },
+        });
+    }));
+};

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

@@ -0,0 +1,11 @@
+import * as Babel from '@umijs/bundler-utils/compiled/babel/core';
+import * as t from '@umijs/bundler-utils/compiled/babel/types';
+export default function (): {
+    pre(): void;
+    post(state: any): void;
+    visitor: {
+        Program: {
+            enter(path: Babel.NodePath<t.Program>, state: any): void;
+        };
+    };
+};

package/dist/features/transform/babelPlugin.js

@@ -0,0 +1,118 @@
+"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 t = __importStar(require("@umijs/bundler-utils/compiled/babel/types"));
+const utils_1 = require("@umijs/utils");
+const path_1 = require("path");
+function isModuleExports(node) {
+    return (t.isMemberExpression(node) &&
+        t.isIdentifier(node.object, { name: 'module' }) &&
+        t.isIdentifier(node.property, { name: 'exports' }));
+}
+function isExportsMemberExpression(node) {
+    return (t.isMemberExpression(node) &&
+        t.isIdentifier(node.object, { name: 'exports' }));
+}
+function default_1() {
+    let opts;
+    return {
+        pre() {
+            // @ts-ignore
+            this.cache = new Map();
+        },
+        post(state) {
+            // @ts-ignore
+            const { cache } = this;
+            const filename = (0, utils_1.winPath)(state.opts.filename);
+            if (cache.has(filename) &&
+                !filename.includes('bundler-webpack/client') &&
+                !filename.startsWith((0, utils_1.winPath)((0, path_1.join)(opts.cwd, 'node_modules')))) {
+                opts.onCheckCode({
+                    args: Object.assign(Object.assign({}, cache.get(state.opts.filename)), { file: state.opts.filename, isFromTmp: state.opts.filename.startsWith(opts.absTmpPath) }),
+                });
+            }
+        },
+        visitor: {
+            Program: {
+                enter(path, state) {
+                    opts = state.opts;
+                    // @ts-ignore
+                    const file = path === null || path === void 0 ? void 0 : path.hub.file.opts.filename;
+                    // @ts-ignore
+                    const cache = this.cache;
+                    // reset cache
+                    cache.set(file, {
+                        code: path.hub.getCode(),
+                        imports: [],
+                        cjsExports: [],
+                    });
+                    path.node.body.forEach((node) => {
+                        // import x from 'x'; { default: 'x' }
+                        // import * as x2 from 'x'; { namespace: 'x2' }
+                        // import x3, * as xx from 'x'; { default: 'x3', namespace: 'xx' }
+                        // import { x4, a as b } from 'x'; { specifiers: { x4: 'x4', a: 'b' } }
+                        if (t.isImportDeclaration(node)) {
+                            const ret = {
+                                source: node.source.value,
+                                loc: node.loc,
+                            };
+                            node.specifiers.forEach((specifier) => {
+                                if (t.isImportDefaultSpecifier(specifier)) {
+                                    ret.default = specifier.local.name;
+                                }
+                                else if (t.isImportNamespaceSpecifier(specifier)) {
+                                    ret.namespace = specifier.local.name;
+                                }
+                                else if (t.isImportSpecifier(specifier)) {
+                                    ret.specifiers || (ret.specifiers = {});
+                                    ret.specifiers[t.isIdentifier(specifier.imported)
+                                        ? specifier.imported.name
+                                        : specifier.imported.value] = specifier.local.name;
+                                }
+                            });
+                            cache.get(file).imports.push(ret);
+                        }
+                        if (t.isExpressionStatement(node)) {
+                            const n = node;
+                            // module.exports = x;
+                            if (t.isAssignmentExpression(n.expression) &&
+                                isModuleExports(n.expression.left)) {
+                                cache.get(file).cjsExports.push('default');
+                            }
+                            // exports.x = x;
+                            if (t.isAssignmentExpression(n.expression) &&
+                                isExportsMemberExpression(n.expression.left)) {
+                                cache.get(file).cjsExports.push(
+                                // @ts-ignore
+                                n.expression.left.property.name);
+                            }
+                        }
+                        // TODO:
+                        // exports
+                        // callExpression
+                        // newExpression
+                    });
+                },
+            },
+        },
+    };
+}
+exports.default = default_1;

package/dist/features/transform/transform.d.ts

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

package/dist/features/transform/transform.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const babelPlugin_1 = __importDefault(require("./babelPlugin"));
+exports.default = (api) => {
+    api.addBeforeBabelPresets(() => {
+        return [
+            {
+                plugins: [
+                    [
+                        babelPlugin_1.default,
+                        {
+                            cwd: api.cwd,
+                            absTmpPath: api.paths.absTmpPath,
+                            onCheckCode({ args }) {
+                                api.applyPlugins({
+                                    key: 'onCheckCode',
+                                    args: args,
+                                });
+                            },
+                        },
+                    ],
+                ],
+            },
+        ];
+    });
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export type { IApi } from './types';
+declare const _default: () => {
+    plugins: string[];
+};
+export default _default;