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

package/dist/{sync.js → cjs/sync.cjs}

@@ -1,5 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+var __webpack_exports__ = {};
 async function sync(name) {
     const res = await fetch(`https://registry-direct.npmmirror.com/-/package/${name}/syncs`, {
         headers: {
@@ -12,33 +11,21 @@ async function sync(name) {
             'sec-fetch-mode': 'cors',
             'sec-fetch-site': 'same-site',
             Referer: 'https://npmmirror.com/',
-            'Referrer-Policy': 'strict-origin-when-cross-origin',
+            'Referrer-Policy': 'strict-origin-when-cross-origin'
         },
         body: null,
-        method: 'PUT',
+        method: 'PUT'
     });
     const body = await res.json();
-    if (body.ok === true) {
-        console.log(`同步 ${name} 成功`);
-    }
+    if (true === body.ok) console.log(`\u{540C}\u{6B65} ${name} \u{6210}\u{529F}`);
     return body;
 }
 const list = [
-    '@rife/config', //
-    '@rife/cli', //
-    // '@rife/infra',
-    // '@rife/logger',
-    // '@rife/react',
-    // '@rife/next',
-    // '@rife/nest',
-    // '@rife/plugin-deploy',
-    // '@rife/fast',
+    '@rife/config',
+    '@rife/cli'
 ];
 async function main() {
-    for (const item of list) {
-        // https://registry.npmmirror.com/-/package/@rife/infra/syncs/65a255a2afa293666acf6655/log
-        await sync(item);
-    }
+    for (const item of list)await sync(item);
     poll();
 }
 main();
@@ -47,8 +34,7 @@ async function get(name) {
         const res = await fetch(`https://r.cnpmjs.org/${name}?t=${Date.now()}&cache=0`);
         const data = await res.json();
         return `${name}  ${data?.['dist-tags']?.['latest']}`;
-    }
-    catch (e) {
+    } catch (e) {
         return `${name} error`;
     }
 }
@@ -57,4 +43,7 @@ async function poll() {
     console.log(`${res.join('\n')}\n`);
     setTimeout(poll, 1000);
 }
-//# sourceMappingURL=sync.js.map
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/util.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    getDuration: ()=>getDuration,
+    glob: ()=>external_glob_namespaceObject,
+    fs: ()=>external_fs_extra_default()
+});
+const external_fs_extra_namespaceObject = require("fs-extra");
+var external_fs_extra_default = /*#__PURE__*/ __webpack_require__.n(external_fs_extra_namespaceObject);
+const external_glob_namespaceObject = require("glob");
+const getDuration = (perfStart)=>{
+    const duration = ((performance.now() - perfStart) / 1000).toFixed(3);
+    return `\u{8017}\u{65F6} ${duration} s`;
+};
+exports.fs = __webpack_exports__.fs;
+exports.getDuration = __webpack_exports__.getDuration;
+exports.glob = __webpack_exports__.glob;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "fs",
+    "getDuration",
+    "glob"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/{1.mjs → esm/cli.mjs}

@@ -1,6 +1,7 @@
-import { pluginCommander, pluginConfig, pluginPackage } from './plugin';
-import { pluginRelease } from './plugin/release';
-import { createRunner } from './runner';
+import __rslib_shim_module__ from 'module';
+/*#__PURE__*/ import.meta.url;
+import { pluginCommander, pluginConfig, pluginPackage, pluginRelease } from "./plugin/index.mjs";
+import { createRunner } from "./runner.mjs";
 const plugins = [
     pluginPackage(),
     pluginConfig(),

package/dist/esm/index.mjs

@@ -0,0 +1,5 @@
+import __rslib_shim_module__ from 'module';
+/*#__PURE__*/ import.meta.url;
+export * from "./runner.mjs";
+export * from "./plugin/index.mjs";
+export * from "./logger.mjs";

package/dist/esm/logger.mjs

@@ -0,0 +1,14 @@
+import __rslib_shim_module__ from 'module';
+/*#__PURE__*/ import.meta.url;
+import { createConsola } from "consola";
+function createLogger(options) {
+    const instance = createConsola({
+        level: options?.debug ? 4 : 3,
+        formatOptions: {
+            compact: false,
+            date: false
+        }
+    });
+    return instance;
+}
+export { createLogger };

package/dist/esm/plugin/commander.mjs

@@ -0,0 +1,34 @@
+import __rslib_shim_module__ from 'module';
+/*#__PURE__*/ import.meta.url;
+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;
+}
+export { pluginCommander };

package/dist/esm/plugin/compiler/compiler.mjs

@@ -0,0 +1,160 @@
+import __rslib_shim_module__ from 'module';
+/*#__PURE__*/ import.meta.url;
+import * as __WEBPACK_EXTERNAL_MODULE_consola_utils_6b69f78e__ from "consola/utils";
+import * as __WEBPACK_EXTERNAL_MODULE_typescript__ from "typescript";
+import external_path_default from "path";
+import { swc } from "./swc.mjs";
+import { tsc } from "./tsc.mjs";
+var __webpack_modules__ = {
+    "consola/utils": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_consola_utils_6b69f78e__;
+    },
+    typescript: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_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;
+}
+var utils_ = __webpack_require__("consola/utils");
+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();
+        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();
+        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');
+}
+export { checkAndEmitType, compileTs, formatDiagnostic };

package/dist/esm/plugin/compiler/index.mjs

@@ -0,0 +1,94 @@
+import __rslib_shim_module__ from 'module';
+/*#__PURE__*/ import.meta.url;
+import * as __WEBPACK_EXTERNAL_MODULE_child_process__ from "child_process";
+import { AsyncSeriesHook } from "tapable";
+import { checkAndEmitType, compileTs, formatDiagnostic } from "./compiler.mjs";
+import { getDuration } from "../../util.mjs";
+var __webpack_modules__ = {
+    child_process: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_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;
+}
+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 AsyncSeriesHook(),
+                    execMain: new AsyncSeriesHook()
+                },
+                tsx: validation.data.tsx
+            };
+            hook.dev.tapPromise(pluginCompiler.name, async ()=>{
+                const tsxConfig = validation.data.tsx;
+                compileTs(runner, tsxConfig, {
+                    dev: true
+                });
+            });
+            hook.build.tapPromise(pluginCompiler.name, async ()=>{
+                const perfStart = performance.now();
+                const tsxConfig = validation.data.tsx;
+                await compileTs(runner, tsxConfig, {
+                    build: true
+                });
+                if (runner.compiler.fail) {
+                    log.fail(`\u{6784}\u{5EFA}\u{5931}\u{8D25}\u{FF0C}${getDuration(perfStart)}`);
+                    process.exit(1);
+                } else log.success(`\u{6784}\u{5EFA}\u{6210}\u{529F}\u{FF0C}${getDuration(perfStart)}`);
+            });
+            runner.compiler.hook.checkAndEmitType.tapPromise(pluginCompiler.name, async ()=>{
+                const { diagnostics, duration } = 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`, 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;
+}
+export { pluginCompiler };

package/dist/esm/plugin/compiler/swc.mjs

@@ -0,0 +1,75 @@
+import __rslib_shim_module__ from 'module';
+/*#__PURE__*/ import.meta.url;
+import * as __WEBPACK_EXTERNAL_MODULE__swc_cli_524a95a0__ from "@swc/cli";
+var __webpack_modules__ = {
+    "@swc/cli": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__swc_cli_524a95a0__;
+    }
+};
+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;
+}
+async function swc(options) {
+    const { watch = false, outDir } = options;
+    const { swcDir } = __webpack_require__("@swc/cli");
+    const swcOptions = {
+        jsc: {
+            parser: {
+                syntax: "typescript"
+            },
+            target: 'esnext',
+            externalHelpers: true
+        },
+        module: {
+            type: 'commonjs',
+            ignoreDynamic: true
+        },
+        sourceMaps: true
+    };
+    let first = true;
+    await swcDir({
+        cliOptions: {
+            outDir,
+            watch,
+            filenames: [
+                './src'
+            ],
+            extensions: [
+                '.ts',
+                '.tsx',
+                '.js',
+                '.jsx'
+            ],
+            stripLeadingPaths: true,
+            copyFiles: true
+        },
+        swcOptions,
+        callbacks: {
+            onSuccess: ({ duration })=>{
+                options?.onSuccess?.({
+                    watch,
+                    first,
+                    duration
+                });
+                first = false;
+            },
+            onFail: (e)=>{
+                options?.onFail?.({
+                    ...e,
+                    watch,
+                    first
+                });
+                first = false;
+            },
+            onWatchReady: ()=>{}
+        }
+    });
+}
+export { swc };

package/dist/esm/plugin/compiler/tsc.mjs

@@ -0,0 +1,73 @@
+import __rslib_shim_module__ from 'module';
+/*#__PURE__*/ import.meta.url;
+import * as __WEBPACK_EXTERNAL_MODULE_typescript__ from "typescript";
+import external_path_default from "path";
+var __webpack_modules__ = {
+    typescript: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_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;
+}
+function tsc(config) {
+    const ts = __webpack_require__("typescript");
+    const rootDir = config.rootDir || '.';
+    const formatHost = {
+        getCanonicalFileName: (path)=>path,
+        getCurrentDirectory: ts.sys.getCurrentDirectory,
+        getNewLine: ()=>ts.sys.newLine
+    };
+    function reportDiagnostic(diagnostic) {
+        config.onReportDiagnostic?.({
+            diagnostic
+        });
+    }
+    function reportWatchStatusChanged(diagnostic) {
+        const message = `${ts.formatDiagnostic(diagnostic, formatHost)}`.trimEnd();
+        let status = '';
+        if (message.includes('message TS6031: Starting compilation in watch mode')) status = 'startWatch';
+        else if (message.includes('message TS6032: File change detected')) status = 'reCompile';
+        else if (message.includes('Found 0 errors')) status = 'success';
+        else if (/Found \d+ error/.test(message)) status = 'error';
+        config.onWatchStatusChanged?.({
+            status,
+            message
+        });
+    }
+    const configPath = ts.findConfigFile(rootDir, ts.sys.fileExists, 'tsconfig.json');
+    if (!configPath) throw new Error("\u627E\u4E0D\u5230tsconfig.json");
+    const createProgram = ts.createSemanticDiagnosticsBuilderProgram;
+    if (config.watch) {
+        const host = ts.createWatchCompilerHost(configPath, {
+            ...config.options,
+            outDir: config.outDir,
+            noEmit: false,
+            incremental: true
+        }, ts.sys, createProgram, reportDiagnostic, reportWatchStatusChanged);
+        ts.createWatchProgram(host);
+    } else {
+        const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+        const compilerOptions = ts.parseJsonConfigFileContent(configFile.config, ts.sys, external_path_default.dirname(configPath), {
+            ...config.options,
+            outDir: config.outDir,
+            noEmit: false,
+            incremental: false
+        });
+        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);
+        config.onEmitDiagnostics?.({
+            diagnostics
+        });
+    }
+}
+export { tsc };

package/dist/esm/plugin/config.mjs

@@ -0,0 +1,65 @@
+import __rslib_shim_module__ from 'module';
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(import.meta.url);
+import external_path_default from "path";
+function pluginConfig() {
+    const plugin = {
+        name: pluginConfig.name,
+        apply: (runner)=>{
+            const { logger, hook, config, command, fs, z } = runner;
+            const log = logger.withTag(pluginConfig.name);
+            hook.loadConfig.tapPromise(pluginConfig.name, async ()=>{
+                let filePath = '';
+                const mjs = 'app.mjs';
+                const fileNames = [
+                    'app.js',
+                    'app.cjs',
+                    mjs
+                ];
+                let isEsm = false;
+                for (const fileName of fileNames)if (await fs.exists(fileName)) {
+                    filePath = external_path_default.posix.resolve(fileName);
+                    isEsm = fileName === mjs;
+                    break;
+                }
+                log.debug("filePath %s", filePath);
+                if (!filePath) {
+                    log.error(`\u{627E}\u{4E0D}\u{5230}\u{914D}\u{7F6E}\u{6587}\u{4EF6} app.(c|m)?js`);
+                    process.exit(1);
+                }
+                let all = [];
+                all = isEsm ? (await import(filePath)).default : require(filePath);
+                runner.config.all = all;
+            });
+            hook.validateConfig.tapPromise(pluginConfig.name, async ()=>{
+                const validation = z.array(z.object({
+                    name: z.string().trim().min(1)
+                })).min(1).safeParse(config.all);
+                if (!validation.success) {
+                    log.error(validation.error.message);
+                    process.exit(1);
+                }
+            });
+            hook.applyConfig.tapPromise(pluginConfig.name, async ()=>{
+                const result = z.object({
+                    name: z.string().trim().default('')
+                }).default({}).safeParse(command.opts());
+                const name = result.data?.name;
+                if (name) {
+                    log.debug(`\u{6307}\u{5B9A} --name ${name}`);
+                    const find = config.all.find((t)=>t.name === name);
+                    if (!find) {
+                        log.error(`\u{672A}\u{627E}\u{5230} name '%s'`, name);
+                        process.exit(1);
+                    }
+                    config.current = find;
+                } else {
+                    log.debug("\u6CA1\u6709\u6307\u5B9A --name\uFF0C\u9ED8\u8BA4\u4F7F\u7528\u5217\u8868\u7B2C\u4E00\u4E2A");
+                    config.current = config.all[0];
+                }
+                config.current.plugins.forEach((plugin)=>plugin.apply(runner));
+            });
+        }
+    };
+    return plugin;
+}
+export { pluginConfig };

package/dist/esm/plugin/index.mjs

@@ -0,0 +1,7 @@
+import __rslib_shim_module__ from 'module';
+/*#__PURE__*/ import.meta.url;
+export * from "./config.mjs";
+export * from "./package.mjs";
+export * from "./commander.mjs";
+export * from "./compiler/index.mjs";
+export * from "./release.mjs";