@rife/cli 0.0.6-beta.8 → 0.0.6-beta.9

package/src/plugin/compiler/index.ts

@@ -1,115 +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, 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 });
-                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;
-                }
-
-                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;
-}
+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/config.ts

@@ -1,64 +1,78 @@
-import path from 'path';
-
-import type { Config, Plugin } from '../runner';
-
-export function pluginConfig() {
-    const plugin: 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 () => {
-                const fileName = '.app.js';
-                const filePath = path.posix.resolve(fileName);
-                log.debug(`filePath %s`, filePath);
-                if (!fs.existsSync(filePath)) {
-                    log.error(`找不到配置文件 ${fileName}`);
-                    process.exit(1);
-                }
-                const all: Config[] = 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('没有指定 --name，默认使用列表第一个');
-                    config.current = config.all[0];
-                } else {
-                    log.debug(`指定 --name ${name}`);
-                    const find = config.all.find(t => t.name === name);
-                    if (!find) {
-                        log.error(`未找到 name '%s'`, name);
-                        process.exit(1);
-                    }
-                    config.current = find;
-                }
-                config.current.plugins.forEach(plugin => plugin.apply(runner));
-            });
-        },
-    };
-    return plugin;
-}
+import path from 'path';
+
+import type { Config, Plugin } from '../runner';
+
+export function pluginConfig() {
+    const plugin: 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 = path.posix.resolve(fileName);
+                        isEsm = fileName === mjs;
+                        break;
+                    }
+                }
+                log.debug(`filePath %s`, filePath);
+                if (!filePath) {
+                    log.error(`找不到配置文件 app.(c|m)?js`);
+                    process.exit(1);
+                }
+                let all: Config[] = [];
+                if (isEsm) {
+                    all = (await import(filePath)).default;
+                } else {
+                    all = 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('没有指定 --name，默认使用列表第一个');
+                    config.current = config.all[0];
+                } else {
+                    log.debug(`指定 --name ${name}`);
+                    const find = config.all.find(t => t.name === name);
+                    if (!find) {
+                        log.error(`未找到 name '%s'`, name);
+                        process.exit(1);
+                    }
+                    config.current = find;
+                }
+                config.current.plugins.forEach(plugin => plugin.apply(runner));
+            });
+        },
+    };
+    return plugin;
+}

package/src/plugin/index.ts

@@ -2,3 +2,4 @@ export * from './config';
 export * from './package';
 export * from './commander';
 export * from './compiler';
+export * from './release';

package/src/plugin/release.ts

@@ -1,4 +1,4 @@
-import { exec, execSync } from 'child_process';
+import { execSync } from 'child_process';
 
 import type { Plugin } from '../runner';
 

package/src/runner.ts

@@ -1,9 +1,10 @@
 import type { ConsolaInstance } from 'consola';
-import * as glob from 'glob';
+import { colors } from 'consola/utils';
 import { AsyncSeriesHook } from 'tapable';
 import zod from 'zod';
 
 import { createLogger } from './logger';
+import { fs, glob } from './util';
 
 export interface Config {
     name: string;
@@ -37,10 +38,11 @@ export interface Runner {
     package: any;
     z: typeof zod;
     fs: typeof import('fs-extra');
-    glob: (typeof import('glob'))['glob'];
+    glob: typeof import('glob')['glob'];
     tapable: typeof import('tapable');
     duration: string;
     tempDir: string;
+    clear: () => void;
 }
 
 export interface Plugin {
@@ -105,7 +107,7 @@ export function createRunner() {
         },
         package: {},
         z: zod,
-        fs: require('fs-extra') as typeof import('fs-extra'),
+        fs,
         glob: glob.glob,
         tapable: require('tapable') as typeof import('tapable'),
         get duration() {
@@ -113,6 +115,11 @@ export function createRunner() {
             return `耗时 ${duration} s`;
         },
         tempDir: './node_modules/.temp/',
+        clear: () => {
+            console.clear();
+            process.stdout.write('\x1b[3J');
+            console.log(`${colors.bgBlue(' 项目名称 ')} ${runner.package.name} \n`);
+        },
     };
 
     return runner;

package/src/sync.ts

@@ -26,12 +26,12 @@ const list = [
     '@rife/config', //
     '@rife/cli', //
     // '@rife/infra',
-    '@rife/logger',
+    // '@rife/logger',
     // '@rife/react',
     // '@rife/next',
     // '@rife/nest',
-    '@rife/plugin-deploy',
-    '@rife/fast',
+    // '@rife/plugin-deploy',
+    // '@rife/fast',
 ];
 
 async function main() {

package/src/util.ts

@@ -0,0 +1,9 @@
+import fs from 'fs-extra';
+import * as glob from 'glob';
+
+export { fs, glob };
+
+export const getDuration = (perfStart: number) => {
+    const duration = ((performance.now() - perfStart) / 1000).toFixed(3);
+    return `耗时 ${duration} s`;
+};

package/src/pnpmfile.ts

@@ -1,147 +0,0 @@
-// @ts-ignore
-const fs = require('fs');
-// @ts-ignore
-const h = require('https');
-
-const request = h.request;
-h.request = function (...args: any[]) {
-    const path = args[0].path || '';
-    if (path.startsWith('/@rife') && !path.endsWith('.tgz')) {
-        console.log(path);
-        args[0].headers['accept'] = 'application/json';
-    }
-    return request(...args);
-};
-
-let root: any;
-let exit: (message: string) => any;
-const origin: any = {};
-
-export function parseVersion(version: string) {
-    const [_, a = '', b = '', c = '', d = ''] = /(\d+?)\.(\d+?)\.(\d+?)\D*(\d+)?/.exec(version) || [];
-    if (!a || !b || !c) {
-        exit(`version ${version}`);
-    }
-    return [a, b, c, d].map(t => t.padStart(3, '0')).join('.');
-}
-
-function compareVersion(v1: string, v2: string) {
-    const v = [v1, v2].filter(t => Boolean(t));
-    if (v.length === 0) {
-        exit('version empty');
-    }
-    if (v.length === 1) {
-        return v[0];
-    }
-
-    return parseVersion(v1) > parseVersion(v2) ? v1 : v2;
-}
-
-const host: any = {};
-function updateRoot(type: 'dependencies' | 'devDependencies', name: string, version: string, from: string) {
-    if (origin[type][name]) return;
-    if (!host[type]) {
-        host[type] = {};
-    }
-    const dependencies = host[type];
-    dependencies[name] = {
-        version: compareVersion(version, dependencies[name]?.version),
-        from,
-    };
-}
-
-export const readPackage = (pkg: any, context: any) => {
-    if (!exit) {
-        exit = (message: string) => {
-            context.log(message);
-            // @ts-ignore
-            process.exit(1);
-        };
-    }
-    if (!root) {
-        root = pkg;
-        origin.dependencies = { ...root.dependencies };
-        origin.devDependencies = { ...root.devDependencies };
-    }
-    const dependencies = pkg.dependencies || {};
-    const devDependencies = pkg.devDependencies || {};
-    const { hostDependencies = {} } = pkg.rife || {};
-    const from = {
-        name: pkg.name,
-        version: pkg.version,
-    };
-    Object.keys(hostDependencies).forEach(name => {
-        const version = dependencies[name] || devDependencies[name];
-        if (!version) {
-            exit('cannot not found version');
-        }
-        const isDev = Boolean(devDependencies[name]);
-        if (isDev) {
-            dependencies[name] = version;
-            updateRoot('devDependencies', name, version, from);
-        } else {
-            updateRoot('dependencies', name, version, from);
-        }
-    });
-    return pkg;
-};
-
-const deps = ['devDependencies', 'dependencies'];
-const need: any[] = [];
-
-let aaaa = [];
-
-export const afterAllResolved = (lockfile, context) => {
-    fs.writeFileSync('./temp/1.json', JSON.stringify(host, undefined, 4));
-    debugger;
-
-    deps.map(dep => {
-        Object.entries(host[dep as any]).forEach(([name, data]: any) => {
-            need.push({
-                key: `${name}@${data.version}`,
-                name,
-                dep,
-                version: data.version,
-                from: data.from,
-                source: `${data.from.name}@${data.from.version}`,
-            });
-        });
-    });
-
-    // debugger;
-    const current = lockfile.importers['.'];
-    const { packages } = lockfile;
-
-    const list = Object.keys(packages).map(key => {
-        const pack = {
-            key,
-            value: packages[key],
-        };
-        return pack;
-    });
-    const t = Object.keys(packages).filter(t => t.startsWith('@rife/cli'));
-    aaaa = need.map(n => {
-        const f = list.find(t => t.key.startsWith(n.key));
-        if (f) {
-            return f;
-        }
-        const s = list.find(t2 => t2.key.startsWith(n.source));
-        const v = s?.value?.dependencies[n.name];
-        if (v) {
-            const newKey = `${n.name}@${v}`;
-            const ff = list.find(t => t.key.startsWith(newKey));
-            if (ff) {
-                return ff;
-            }
-        }
-        debugger;
-    });
-
-    debugger;
-    return lockfile;
-};
-
-process.on('exit', () => {
-    // const exits = aaaa.map(a => fs.exitsSync(`./node_modules/.pnpm/${a.replace('/', '_')}`));
-    // debugger;
-});