@rife/cli 0.0.6-beta.11 → 0.0.6-beta.12

package/dist/cjs/cli.cjs

@@ -0,0 +1,25 @@
+"use strict";
+var __webpack_exports__ = {};
+const index_cjs_namespaceObject = require("./plugin/index.cjs");
+const external_runner_cjs_namespaceObject = require("./runner.cjs");
+const plugins = [
+    (0, index_cjs_namespaceObject.pluginPackage)(),
+    (0, index_cjs_namespaceObject.pluginConfig)(),
+    (0, index_cjs_namespaceObject.pluginCommander)(),
+    (0, index_cjs_namespaceObject.pluginRelease)()
+];
+const runner = (0, external_runner_cjs_namespaceObject.createRunner)();
+plugins.forEach((plugin)=>plugin.apply(runner));
+(async ()=>{
+    await runner.hook.loadPackage.promise();
+    await runner.hook.loadConfig.promise();
+    await runner.hook.validateConfig.promise();
+    await runner.hook.applyConfig.promise();
+    await runner.hook.validatePlugin.promise();
+    await runner.hook.registerCommand.promise();
+    await runner.hook.startCommand.promise();
+})();
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/index.cjs

@@ -0,0 +1,110 @@
+"use strict";
+var __webpack_modules__ = {
+    "./logger": function(module) {
+        module.exports = require("./logger.cjs");
+    },
+    "./plugin": function(module) {
+        module.exports = require("./plugin/index.cjs");
+    },
+    "./runner": function(module) {
+        module.exports = require("./runner.cjs");
+    },
+    "fs-extra": function(module) {
+        module.exports = require("fs-extra");
+    },
+    tapable: function(module) {
+        module.exports = require("tapable");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        fs: ()=>fs_extra__WEBPACK_IMPORTED_MODULE_3___default.a
+    });
+    var _runner__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./runner");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _runner__WEBPACK_IMPORTED_MODULE_0__)if ([
+        "default",
+        "fs"
+    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _runner__WEBPACK_IMPORTED_MODULE_0__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _plugin__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./plugin");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _plugin__WEBPACK_IMPORTED_MODULE_1__)if ([
+        "default",
+        "fs"
+    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _plugin__WEBPACK_IMPORTED_MODULE_1__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _logger__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./logger");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _logger__WEBPACK_IMPORTED_MODULE_2__)if ([
+        "default",
+        "fs"
+    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _logger__WEBPACK_IMPORTED_MODULE_2__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var fs_extra__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("fs-extra");
+    var fs_extra__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/ __webpack_require__.n(fs_extra__WEBPACK_IMPORTED_MODULE_3__);
+    var tapable__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("tapable");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in tapable__WEBPACK_IMPORTED_MODULE_4__)if ([
+        "default",
+        "fs"
+    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return tapable__WEBPACK_IMPORTED_MODULE_4__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+})();
+exports.fs = __webpack_exports__.fs;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "fs"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/logger.cjs

@@ -0,0 +1,46 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createLogger: ()=>createLogger
+});
+const external_consola_namespaceObject = require("consola");
+function createLogger(options) {
+    const instance = (0, external_consola_namespaceObject.createConsola)({
+        level: options?.debug ? 4 : 3,
+        formatOptions: {
+            compact: false,
+            date: false
+        }
+    });
+    return instance;
+}
+exports.createLogger = __webpack_exports__.createLogger;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createLogger"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugin/commander.cjs

@@ -0,0 +1,66 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    pluginCommander: ()=>pluginCommander
+});
+function pluginCommander() {
+    const plugin = {
+        name: pluginCommander.name,
+        apply: (runner)=>{
+            const { hook, command, config, z, logger } = runner;
+            const log = logger.withTag(pluginCommander.name);
+            hook.registerCommand.tapPromise(pluginCommander.name, async ()=>{
+                command.command('dev').description("\u542F\u52A8\u5F00\u53D1").action(async ()=>{
+                    process.env.NODE_ENV = 'development';
+                    await hook.dev.promise();
+                });
+                command.command('build').description("\u6784\u5EFA\u9879\u76EE").action(async ()=>{
+                    process.env.NODE_ENV = 'production';
+                    await hook.build.promise();
+                });
+                command.command('release').description("\u53D1\u5E03\u5305").action(async ()=>{
+                    await hook.release.promise();
+                });
+                command.command('deploy').description("\u90E8\u7F72\u9879\u76EE").action(async ()=>{
+                    await hook.deploy.promise().catch((e)=>{
+                        log.fail(`\u{90E8}\u{7F72}\u{5931}\u{8D25}\u{FF0C}${runner.duration}\u{FF0C}${e.message}`);
+                    });
+                });
+            });
+            hook.startCommand.tapPromise(pluginCommander.name, async ()=>{
+                await command.parseAsync(process.argv);
+            });
+        }
+    };
+    return plugin;
+}
+exports.pluginCommander = __webpack_exports__.pluginCommander;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "pluginCommander"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugin/compiler/compiler.cjs

@@ -0,0 +1,207 @@
+"use strict";
+var __webpack_modules__ = {
+    "consola/utils": function(module) {
+        module.exports = require("consola/utils");
+    },
+    typescript: function(module) {
+        module.exports = require("typescript");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        checkAndEmitType: ()=>checkAndEmitType,
+        compileTs: ()=>compileTs,
+        formatDiagnostic: ()=>formatDiagnostic
+    });
+    const external_path_namespaceObject = require("path");
+    var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+    var utils_ = __webpack_require__("consola/utils");
+    const external_swc_cjs_namespaceObject = require("./swc.cjs");
+    const external_tsc_cjs_namespaceObject = require("./tsc.cjs");
+    const clear = ()=>{
+        console.clear();
+        process.stdout.write('\x1b[3J');
+    };
+    async function compileTs(runner, tsxConfig, { dev, build } = {
+        dev: false,
+        build: true
+    }) {
+        const { logger, fs } = runner;
+        const log = logger.withTag(compileTs.name);
+        log.debug('tsxConfig %j', tsxConfig);
+        if (tsxConfig.clean) {
+            log.info("\u6E05\u7A7A\u76EE\u5F55 %s", tsxConfig.outDir);
+            await fs.emptyDir(tsxConfig.outDir);
+        }
+        const showProjectName = ()=>{
+            clear();
+            console.log(`${utils_.colors.bgBlue(" \u9879\u76EE\u540D\u79F0 ")} ${runner.package.name} \n`);
+        };
+        if ('tsc' === tsxConfig.type) {
+            const diagnostics = [];
+            let perfStart = performance.now();
+            (0, external_tsc_cjs_namespaceObject.tsc)({
+                ...tsxConfig,
+                watch: dev,
+                onWatchStatusChanged: (data)=>{
+                    switch(data.status){
+                        case 'startWatch':
+                            diagnostics.length = 0;
+                            perfStart = performance.now();
+                            break;
+                        case 'reCompile':
+                            diagnostics.length = 0;
+                            perfStart = performance.now();
+                            if (dev) showProjectName();
+                            break;
+                        case 'error':
+                            {
+                                const duration = ((performance.now() - perfStart) / 1000).toFixed(3);
+                                log.error(`\u{7C7B}\u{578B}\u{68C0}\u{67E5}\u{5931}\u{8D25}\u{FF0C}\u{8017}\u{65F6} ${duration} s\n\n%s`, formatDiagnostic(diagnostics));
+                                break;
+                            }
+                        case 'success':
+                            {
+                                const duration = ((performance.now() - perfStart) / 1000).toFixed(3);
+                                log.success(`\u{7F16}\u{8BD1}\u{6210}\u{529F}\u{FF0C}\u{8017}\u{65F6} ${duration} s`);
+                                break;
+                            }
+                        default:
+                            console.log(data);
+                            process.exit(1);
+                    }
+                },
+                onReportDiagnostic: ({ diagnostic })=>{
+                    diagnostics.push(diagnostic);
+                },
+                onEmitDiagnostics: ({ diagnostics })=>{
+                    const duration = ((performance.now() - perfStart) / 1000).toFixed(3);
+                    if (diagnostics.length) {
+                        log.error(`\u{7F16}\u{8BD1}\u{5931}\u{8D25}\u{FF0C}\u{8017}\u{65F6} ${duration} s\n\n%s`, formatDiagnostic(diagnostics));
+                        runner.compiler.fail = true;
+                    } else log.success(`\u{7F16}\u{8BD1}\u{6210}\u{529F}\u{FF0C}\u{8017}\u{65F6} ${duration} s`);
+                }
+            });
+            return;
+        }
+        if ('swc' === tsxConfig.type) {
+            const { promise, resolve } = Promise.withResolvers();
+            (0, external_swc_cjs_namespaceObject.swc)({
+                ...tsxConfig,
+                watch: dev,
+                onSuccess: async ({ watch, first, duration })=>{
+                    if (watch && !first) showProjectName();
+                    log.success(`\u{7F16}\u{8BD1}\u{6210}\u{529F}\u{FF0C}\u{8017}\u{65F6} ${(duration / 1000).toFixed(3)} s`);
+                    if (dev) runner.compiler.hook.execMain.promise();
+                    await runner.compiler.hook.checkAndEmitType.promise();
+                    resolve();
+                },
+                onFail: ({ watch, first, duration, reasons })=>{
+                    if (watch && !first) showProjectName();
+                    const message = [
+                        ...reasons.entries()
+                    ].map(([key, value])=>{
+                        const index = value.indexOf(key);
+                        if (index > -1) return value.replace(key, external_path_default().resolve(key));
+                        return `${value}`;
+                    }).join('\n');
+                    log.error(`\u{7F16}\u{8BD1}\u{5931}\u{8D25}\u{FF0C}\u{8017}\u{65F6} ${(duration / 1000).toFixed(3)} s\n\n%s`, message);
+                    runner.compiler.fail = true;
+                    resolve();
+                }
+            });
+            if (build) return promise;
+            return;
+        }
+        log.error(`compiler type '${tsxConfig.type}' \u{4E0D}\u{5B58}\u{5728}`);
+        process.exit(1);
+    }
+    function checkAndEmitType() {
+        const perfStart = performance.now();
+        const ts = __webpack_require__("typescript");
+        const tsConfigPath = external_path_default().resolve('tsconfig.json');
+        const configFile = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
+        const compilerOptions = ts.parseJsonConfigFileContent(configFile.config, ts.sys, external_path_default().dirname(tsConfigPath), {
+            noEmit: true,
+            incremental: false
+        });
+        if (true === compilerOptions.options.declaration) {
+            compilerOptions.options.noEmit = false;
+            compilerOptions.options.emitDeclarationOnly = true;
+        }
+        const host = ts.createCompilerHost(compilerOptions.options);
+        const program = ts.createProgram(compilerOptions.fileNames, compilerOptions.options, host);
+        const emitResult = program.emit();
+        const diagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+        const duration = ((performance.now() - perfStart) / 1000).toFixed(3);
+        return {
+            diagnostics,
+            duration
+        };
+    }
+    function formatDiagnostic(diagnostics) {
+        const ts = __webpack_require__("typescript");
+        const { colors } = __webpack_require__("consola/utils");
+        return diagnostics.map((diagnostic)=>{
+            const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+            if (diagnostic.file) {
+                const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+                return `${colors.gray(diagnostic.file.fileName)} ${colors.yellow(`(${line + 1},${character + 1})`)}: ${colors.white(message)}`;
+            }
+            return message;
+        }).join('\n');
+    }
+})();
+exports.checkAndEmitType = __webpack_exports__.checkAndEmitType;
+exports.compileTs = __webpack_exports__.compileTs;
+exports.formatDiagnostic = __webpack_exports__.formatDiagnostic;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "checkAndEmitType",
+    "compileTs",
+    "formatDiagnostic"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugin/compiler/index.cjs

@@ -0,0 +1,126 @@
+"use strict";
+var __webpack_modules__ = {
+    child_process: function(module) {
+        module.exports = require("child_process");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        pluginCompiler: ()=>pluginCompiler
+    });
+    const external_tapable_namespaceObject = require("tapable");
+    const external_compiler_cjs_namespaceObject = require("./compiler.cjs");
+    const external_util_cjs_namespaceObject = require("../../util.cjs");
+    function pluginCompiler(options) {
+        const plugin = {
+            name: pluginCompiler.name,
+            apply: (runner)=>{
+                const { hook, logger, z, fs } = runner;
+                const log = logger.withTag(pluginCompiler.name);
+                const validation = z.object({
+                    tsx: z.object({
+                        type: z.enum([
+                            'tsc',
+                            'swc'
+                        ]).default('swc'),
+                        rootDir: z.string().trim().min(1).default('.'),
+                        outDir: z.string().trim().min(1).default('./dist/'),
+                        clean: z.boolean().default(true),
+                        main: z.string().trim().optional(),
+                        options: z.object({}).passthrough().optional()
+                    }).default({})
+                }).optional().default({}).safeParse(options);
+                if (!validation.success) {
+                    log.error("\u914D\u7F6E\u9519\u8BEF\n", validation.error.message);
+                    process.exit(1);
+                }
+                runner.compiler = {
+                    fail: false,
+                    process: null,
+                    hook: {
+                        checkAndEmitType: new external_tapable_namespaceObject.AsyncSeriesHook(),
+                        execMain: new external_tapable_namespaceObject.AsyncSeriesHook()
+                    },
+                    tsx: validation.data.tsx
+                };
+                hook.dev.tapPromise(pluginCompiler.name, async ()=>{
+                    const tsxConfig = validation.data.tsx;
+                    (0, external_compiler_cjs_namespaceObject.compileTs)(runner, tsxConfig, {
+                        dev: true
+                    });
+                });
+                hook.build.tapPromise(pluginCompiler.name, async ()=>{
+                    const perfStart = performance.now();
+                    const tsxConfig = validation.data.tsx;
+                    await (0, external_compiler_cjs_namespaceObject.compileTs)(runner, tsxConfig, {
+                        build: true
+                    });
+                    if (runner.compiler.fail) {
+                        log.fail(`\u{6784}\u{5EFA}\u{5931}\u{8D25}\u{FF0C}${(0, external_util_cjs_namespaceObject.getDuration)(perfStart)}`);
+                        process.exit(1);
+                    } else log.success(`\u{6784}\u{5EFA}\u{6210}\u{529F}\u{FF0C}${(0, external_util_cjs_namespaceObject.getDuration)(perfStart)}`);
+                });
+                runner.compiler.hook.checkAndEmitType.tapPromise(pluginCompiler.name, async ()=>{
+                    const { diagnostics, duration } = (0, external_compiler_cjs_namespaceObject.checkAndEmitType)();
+                    if (diagnostics.length) {
+                        log.error(`\u{7C7B}\u{578B}\u{68C0}\u{67E5}\u{5931}\u{8D25}\u{FF0C}\u{8017}\u{65F6} ${duration} s\n\n%s`, (0, external_compiler_cjs_namespaceObject.formatDiagnostic)(diagnostics));
+                        runner.compiler.fail = true;
+                    } else log.success(`\u{7C7B}\u{578B}\u{68C0}\u{67E5}\u{6210}\u{529F}\u{FF0C}\u{8017}\u{65F6} ${duration} s`);
+                });
+                runner.compiler.hook.execMain.tapPromise(pluginCompiler.name, async ()=>{
+                    const compiler = runner.compiler;
+                    const { main } = compiler.tsx;
+                    if (!main) return void log.debug("\u6CA1\u6709\u6307\u5B9A main");
+                    if (!await fs.exists(main)) return void log.warn(`\u{542F}\u{52A8}\u{6587}\u{4EF6}\u{4E0D}\u{5B58}\u{5728} %s`, main);
+                    log.info(`\u{542F}\u{52A8}\u{6587}\u{4EF6} node %s`, main);
+                    const { fork } = __webpack_require__("child_process");
+                    compiler.process?.kill();
+                    compiler.process = fork(main, {
+                        stdio: 'inherit'
+                    });
+                });
+            }
+        };
+        return plugin;
+    }
+})();
+exports.pluginCompiler = __webpack_exports__.pluginCompiler;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "pluginCompiler"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});