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

package/src/plugin/compiler/compiler.ts

@@ -1,198 +0,0 @@
-import path from 'path';
-
-import { colors } from 'consola/utils';
-import type * as ts from 'typescript';
-
-import { swc } from './swc';
-import { tsc } from './tsc';
-import { Runner } from '../../runner';
-
-export interface TsxConfig {
-    /** 默认：swc */
-    type: 'tsc' | 'swc';
-
-    /** 默认：. */
-    rootDir: string;
-
-    /** 默认：./dist/ */
-    outDir: string;
-
-    /** 默认：true */
-    clean: boolean;
-
-    /** 编译后入口启动文件 */
-    main?: string;
-
-    options?: any;
-}
-
-const clear = () => {
-    console.clear();
-    process.stdout.write('\x1b[3J');
-};
-
-export async function compileTs(
-    runner: Runner,
-    tsxConfig: TsxConfig,
-    { dev, build }: { dev?: boolean; build?: boolean } = { dev: false, build: true },
-) {
-    const { logger, fs } = runner;
-    const log = logger.withTag(compileTs.name);
-    log.debug('tsxConfig %j', tsxConfig);
-    if (tsxConfig.clean) {
-        log.info('清空目录 %s', tsxConfig.outDir);
-        await fs.emptyDir(tsxConfig.outDir);
-    }
-    const showProjectName = () => {
-        clear();
-        console.log(`${colors.bgBlue(' 项目名称 ')} ${runner.package.name} \n`);
-    };
-    if (tsxConfig.type === 'tsc') {
-        const diagnostics: ts.Diagnostic[] = [];
-        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) {
-                            // watch 模式下，第二次编译清空一下屏幕
-                            showProjectName();
-                        }
-                        break;
-                    }
-                    case 'error': {
-                        const duration = ((performance.now() - perfStart) / 1000).toFixed(3);
-                        log.error(`类型检查失败，耗时 ${duration} s\n\n%s`, formatDiagnostic(diagnostics));
-                        break;
-                    }
-                    case 'success': {
-                        const duration = ((performance.now() - perfStart) / 1000).toFixed(3);
-                        log.success(`编译成功，耗时 ${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(`编译失败，耗时 ${duration} s\n\n%s`, formatDiagnostic(diagnostics));
-                    runner.compiler.fail = true;
-                } else {
-                    log.success(`编译成功，耗时 ${duration} s`);
-                }
-            },
-        });
-        return;
-    }
-    if (tsxConfig.type === 'swc') {
-        const { promise, resolve } = Promise.withResolvers<void>();
-        swc({
-            ...tsxConfig,
-            watch: dev,
-            onSuccess: async ({ watch, first, duration }) => {
-                if (watch && !first) {
-                    // watch 模式下，第二次编译清空一下屏幕
-                    showProjectName();
-                }
-                log.success(`编译成功，耗时 ${(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) {
-                    // watch 模式下，第二次编译清空一下屏幕
-                    showProjectName();
-                }
-                const message = [...reasons.entries()]
-                    .map(([key, value]) => {
-                        const index = value.indexOf(key);
-                        if (index > -1) {
-                            return value.replace(key, path.resolve(key));
-                        }
-                        return `${value}`;
-                    })
-                    .join('\n');
-                log.error(`编译失败，耗时 ${(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}' 不存在`);
-    process.exit(1);
-}
-
-export function checkAndEmitType() {
-    const perfStart = performance.now();
-    const ts: typeof import('typescript') = require('typescript');
-    const tsConfigPath = path.resolve('tsconfig.json');
-    // 读取 tsconfig.json 文件
-    const configFile = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
-
-    // 解析 tsconfig.json 文件
-    const compilerOptions = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(tsConfigPath), {
-        noEmit: true,
-        incremental: false,
-    });
-    if (compilerOptions.options.declaration === true) {
-        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 };
-}
-
-export function formatDiagnostic(diagnostics: readonly ts.Diagnostic[]) {
-    const ts: typeof import('typescript') = require('typescript');
-    const { colors }: typeof import('consola/utils') = 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');
-}

package/src/plugin/compiler/index.ts

@@ -1,115 +0,0 @@
-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, 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 AsyncSeriesHook(),
-                    execMain: new 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,56 +0,0 @@
-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: () => {},
-        },
-    });
-}

package/src/plugin/compiler/tsc.ts

@@ -1,101 +0,0 @@
-import type { ChildProcess } from 'child_process';
-import path from 'path';
-
-import type * as ts from 'typescript';
-
-import type { TsxConfig } from './compiler';
-
-type Status = 'startWatch' | 'reCompile' | 'error' | 'success' | '';
-export interface TscConfig extends TsxConfig {
-    watch?: boolean;
-    options?: ts.CompilerOptions;
-    onWatchStatusChanged?: (data: { status: Status; message: string }) => any;
-    onReportDiagnostic?: (data: { diagnostic: ts.Diagnostic }) => any;
-    onEmitDiagnostics?: (data: { diagnostics: ts.Diagnostic[] }) => any;
-}
-export function tsc(config: TscConfig) {
-    const logger = console;
-    const ts: typeof import('typescript') = require('typescript');
-    // https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API#writing-an-incremental-program-watcher
-
-    const rootDir = config.rootDir || '.';
-
-    const formatHost: ts.FormatDiagnosticsHost = {
-        getCanonicalFileName: path => path,
-        getCurrentDirectory: ts.sys.getCurrentDirectory,
-        getNewLine: () => ts.sys.newLine,
-    };
-
-    function reportDiagnostic(diagnostic: ts.Diagnostic) {
-        config.onReportDiagnostic?.({ diagnostic });
-    }
-
-    /**
-     * Prints a diagnostic every time the watch status changes.
-     * This is mainly for messages like "Starting compilation" or "Compilation completed".
-     */
-    let a: ChildProcess | any;
-    function reportWatchStatusChanged(diagnostic: ts.Diagnostic) {
-        const message = `${ts.formatDiagnostic(diagnostic, formatHost)}`.trimEnd();
-        let status: 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('找不到tsconfig.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 {
-        // 读取 tsconfig.json 文件
-        const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-
-        // 解析 tsconfig.json 文件
-        const compilerOptions = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.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 });
-    }
-}