@rife/cli 0.0.6-beta.1 → 0.0.6-beta.10

package/src/logger.ts

@@ -1,34 +1,16 @@
-import { createConsola } from 'consola';
-
-export interface Logger {
-    debug: (message: string, ...args: any[]) => any;
-    info: (message: string, ...args: any[]) => any;
-    error: (message: string, ...args: any[]) => any;
-    success: (message: string, ...args: any[]) => any;
-    fail: (message: string, ...args: any[]) => any;
-    withTag: (tag: string) => Logger;
-}
-
-export function createLogger() {
-    const instance = createConsola({
-        level: 4,
-        // fancy: false,
-        formatOptions: {
-            // columns: 80,
-            // colors: false,
-            compact: false,
-            date: false,
-        },
-    });
-
-    const logger: Logger = {
-        debug: (message, ...args) => instance.info(message, ...args),
-        info: (message, ...args) => instance.info(message, ...args),
-        error: (message, ...args) => instance.error(message, ...args),
-        success: (message, ...args) => instance.success(message, ...args),
-        fail: (message, ...args) => instance.fail(message, ...args),
-        withTag: tag => instance.withTag(tag),
-    };
-
-    return logger;
-}
+import { createConsola } from 'consola';
+
+export function createLogger(options?: { debug?: boolean }) {
+    const instance = createConsola({
+        level: options?.debug ? 4 : 3,
+        // fancy: false,
+        formatOptions: {
+            // columns: 80,
+            // colors: false,
+            compact: false,
+            date: false,
+        },
+    });
+
+    return instance;
+}

package/src/plugin/commander.ts

@@ -1,44 +1,49 @@
-import type { Plugin } from '../runner';
-
-export function pluginCommander() {
-    const plugin: Plugin = {
-        name: pluginCommander.name,
-        apply: runner => {
-            const { hook, config, z } = runner;
-
-            hook.startCommand.tapPromise(pluginCommander.name, async () => {
-                const { Command } = require('commander') as typeof import('commander');
-                const program = new Command();
-                program
-                    .command('dev')
-                    .option('-n, --name <string>', '', '')
-                    .description('启动开发')
-                    .action(async options => {
-                        await hook.applyConfig.promise(options);
-                        await hook.dev.promise();
-                    });
-
-                program
-                    .command('build')
-                    .option('-n, --name <string>', '', '')
-                    .description('构建项目')
-                    .action(async options => {
-                        await hook.applyConfig.promise(options);
-                        await hook.build.promise();
-                    });
-
-                program
-                    .command('release')
-                    .option('-n, --name <string>', '', '')
-                    .description('发布包')
-                    .action(async options => {
-                        await hook.applyConfig.promise(options);
-                        await hook.release.promise();
-                    });
-
-                program.parseAsync(process.argv);
-            });
-        },
-    };
-    return plugin;
-}
+import type { Plugin } from '../runner';
+
+export function pluginCommander() {
+    const plugin: 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('启动开发')
+                    .action(async () => {
+                        process.env.NODE_ENV = 'development';
+                        await hook.dev.promise();
+                    });
+
+                command
+                    .command('build')
+                    .description('构建项目')
+                    .action(async () => {
+                        process.env.NODE_ENV = 'production';
+                        await hook.build.promise();
+                    });
+
+                command
+                    .command('release')
+                    .description('发布包')
+                    .action(async () => {
+                        await hook.release.promise();
+                    });
+
+                command
+                    .command('deploy')
+                    .description('部署项目')
+                    .action(async () => {
+                        await hook.deploy.promise().catch(e => {
+                            log.fail(`部署失败，${runner.duration}，${e.message}`);
+                        });
+                    });
+            });
+
+            hook.startCommand.tapPromise(pluginCommander.name, async () => {
+                await command.parseAsync(process.argv);
+            });
+        },
+    };
+    return plugin;
+}

package/src/plugin/compiler/index.ts

@@ -1,109 +1,115 @@
-import type { ChildProcess } from 'child_process';
-
-import { AsyncSeriesHook } from 'tapable';
-
-import { TsxConfig, checkAndEmitType, compileTs, formatDiagnostic } from './compiler';
-import type { Plugin } from '../../runner';
-
-declare module '../../runner' {
-    interface Runner {
-        compiler: {
-            fail: boolean;
-            process: ChildProcess | null;
-            hook: {
-                checkAndEmitType: AsyncSeriesHook<[]>;
-                execMain: AsyncSeriesHook<[]>;
-            };
-            tsx: TsxConfig;
-        };
-    }
-}
-
-export interface pluginCompilerOptions {
-    tsx?: Partial<TsxConfig>;
-    less?: {};
-}
-
-export function pluginCompiler(options?: pluginCompilerOptions) {
-    const plugin: Plugin = {
-        name: pluginCompiler.name,
-        apply: runner => {
-            const { hook, logger, z, tapable } = 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('配置错误\n', validation.error.message);
-                process.exit(1);
-            }
-
-            runner.compiler = {
-                fail: false,
-                process: null,
-                hook: {
-                    checkAndEmitType: new tapable.AsyncSeriesHook(),
-                    execMain: new tapable.AsyncSeriesHook(),
-                },
-                tsx: validation.data.tsx,
-            };
-
-            hook.dev.tapPromise(pluginCompiler.name, async () => {
-                const tsxConfig: TsxConfig = validation.data.tsx;
-                compileTs(runner, tsxConfig, { dev: true });
-            });
-
-            hook.build.tapPromise(pluginCompiler.name, async () => {
-                const perfStart = performance.now();
-                const tsxConfig: TsxConfig = validation.data.tsx;
-                await compileTs(runner, tsxConfig, { build: true });
-                const duration = ((performance.now() - perfStart) / 1000).toFixed(3);
-                if (runner.compiler.fail) {
-                    log.fail(`构建失败，耗时 ${duration} s`);
-                    process.exit(1);
-                } else {
-                    log.success(`构建成功，耗时 ${duration} s`);
-                }
-            });
-
-            runner.compiler.hook.checkAndEmitType.tapPromise(pluginCompiler.name, async () => {
-                const { diagnostics, duration } = checkAndEmitType();
-                if (diagnostics.length) {
-                    log.error(`类型检查失败，耗时 ${duration} s\n\n%s`, formatDiagnostic(diagnostics));
-                    runner.compiler.fail = true;
-                } else {
-                    log.success(`类型检查成功，耗时 ${duration} s`);
-                }
-            });
-
-            runner.compiler.hook.execMain.tapPromise(pluginCompiler.name, async () => {
-                const compiler = runner.compiler;
-                const { main } = compiler.tsx;
-                if (!main) {
-                    log.debug('没有指定 main');
-                    return;
-                }
-                log.info(`启动文件 node %s`, main);
-
-                const { fork } = require('child_process') as typeof import('child_process');
-                compiler.process?.kill();
-                compiler.process = fork(main, { stdio: 'inherit' });
-            });
-        },
-    };
-    return plugin;
-}
+import type { ChildProcess } from 'child_process';
+
+import { AsyncSeriesHook } from 'tapable';
+
+import { TsxConfig, checkAndEmitType, compileTs, formatDiagnostic } from './compiler';
+import type { Plugin } from '../../runner';
+import { getDuration } from '../../util';
+
+declare module '../../runner' {
+    interface Runner {
+        compiler: {
+            fail: boolean;
+            process: ChildProcess | null;
+            hook: {
+                checkAndEmitType: AsyncSeriesHook<[]>;
+                execMain: AsyncSeriesHook<[]>;
+            };
+            tsx: TsxConfig;
+        };
+    }
+}
+
+export interface pluginCompilerOptions {
+    tsx?: Partial<TsxConfig>;
+    less?: {};
+}
+
+export function pluginCompiler(options?: pluginCompilerOptions) {
+    const plugin: Plugin = {
+        name: pluginCompiler.name,
+        apply: runner => {
+            const { hook, logger, z, tapable, 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('配置错误\n', validation.error.message);
+                process.exit(1);
+            }
+
+            runner.compiler = {
+                fail: false,
+                process: null,
+                hook: {
+                    checkAndEmitType: new tapable.AsyncSeriesHook(),
+                    execMain: new tapable.AsyncSeriesHook(),
+                },
+                tsx: validation.data.tsx,
+            };
+
+            hook.dev.tapPromise(pluginCompiler.name, async () => {
+                const tsxConfig: TsxConfig = validation.data.tsx;
+                compileTs(runner, tsxConfig, { dev: true });
+            });
+
+            hook.build.tapPromise(pluginCompiler.name, async () => {
+                const perfStart = performance.now();
+                const tsxConfig: TsxConfig = validation.data.tsx;
+                await compileTs(runner, tsxConfig, { build: true });
+                if (runner.compiler.fail) {
+                    log.fail(`构建失败，${getDuration(perfStart)}`);
+                    process.exit(1);
+                } else {
+                    log.success(`构建成功，${getDuration(perfStart)}`);
+                }
+            });
+
+            runner.compiler.hook.checkAndEmitType.tapPromise(pluginCompiler.name, async () => {
+                const { diagnostics, duration } = checkAndEmitType();
+                if (diagnostics.length) {
+                    log.error(`类型检查失败，耗时 ${duration} s\n\n%s`, formatDiagnostic(diagnostics));
+                    runner.compiler.fail = true;
+                } else {
+                    log.success(`类型检查成功，耗时 ${duration} s`);
+                }
+            });
+
+            runner.compiler.hook.execMain.tapPromise(pluginCompiler.name, async () => {
+                const compiler = runner.compiler;
+                const { main } = compiler.tsx;
+                if (!main) {
+                    log.debug('没有指定 main');
+                    return;
+                }
+
+                if (!(await fs.exists(main))) {
+                    log.warn(`启动文件不存在 %s`, main);
+                    return;
+                }
+
+                log.info(`启动文件 node %s`, main);
+
+                const { fork } = require('child_process') as typeof import('child_process');
+                compiler.process?.kill();
+                compiler.process = fork(main, { stdio: 'inherit' });
+            });
+        },
+    };
+    return plugin;
+}

package/src/plugin/compiler/swc.ts

@@ -1,55 +1,56 @@
-import type { TsxConfig } from './compiler';
-
-export interface SwcConfig extends TsxConfig {
-    watch?: boolean;
-    options?: any;
-    onSuccess?: (data: { watch: boolean; first: boolean; duration: number }) => any;
-    onFail?: (data: { watch: boolean; first: boolean; duration: number; reasons: Map<string, string> }) => any;
-}
-
-export async function swc(options: SwcConfig) {
-    const { watch = false, outDir } = options;
-    const { swcDir } = require('@swc/cli');
-
-    // https://swc.rs/docs/configuration/swcrc
-    const swcOptions = {
-        jsc: {
-            parser: {
-                syntax: 'typescript',
-            },
-            target: 'esnext',
-            externalHelpers: true,
-        },
-        module: {
-            type: 'commonjs',
-            // type: 'es6',
-            ignoreDynamic: true,
-        },
-        sourceMaps: true,
-    };
-
-    let first = true;
-
-    await swcDir({
-        cliOptions: {
-            outDir,
-            watch,
-            filenames: ['./src'],
-            extensions: ['.ts', '.tsx'],
-            stripLeadingPaths: true,
-        },
-        swcOptions,
-        callbacks: {
-            onSuccess: ({ duration }: any) => {
-                options?.onSuccess?.({ watch, first, duration });
-                first = false;
-            },
-            onFail: (e: any) => {
-                options?.onFail?.({ ...e, watch, first });
-                // 不退出，下次修复报错后清空屏幕
-                first = false;
-            },
-            onWatchReady: () => {},
-        },
-    });
-}
+import type { TsxConfig } from './compiler';
+
+export interface SwcConfig extends TsxConfig {
+    watch?: boolean;
+    options?: any;
+    onSuccess?: (data: { watch: boolean; first: boolean; duration: number }) => any;
+    onFail?: (data: { watch: boolean; first: boolean; duration: number; reasons: Map<string, string> }) => any;
+}
+
+export async function swc(options: SwcConfig) {
+    const { watch = false, outDir } = options;
+    const { swcDir } = require('@swc/cli');
+
+    // https://swc.rs/docs/configuration/swcrc
+    const swcOptions = {
+        jsc: {
+            parser: {
+                syntax: 'typescript',
+            },
+            target: 'esnext',
+            externalHelpers: true,
+        },
+        module: {
+            type: 'commonjs',
+            // type: 'es6',
+            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 }: any) => {
+                options?.onSuccess?.({ watch, first, duration });
+                first = false;
+            },
+            onFail: (e: any) => {
+                options?.onFail?.({ ...e, watch, first });
+                // 不退出，下次修复报错后清空屏幕
+                first = false;
+            },
+            onWatchReady: () => {},
+        },
+    });
+}