@rife/cli 0.0.6-beta.1

package/src/pnpmfile.ts

@@ -0,0 +1,121 @@
+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 peerDependencies = (pkg.peerDependencies = pkg.peerDependencies || {});
+    const { hostDependencies = {} } = pkg.rife || {};
+    const from = `${pkg.name}@${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) {
+            peerDependencies[name] = version;
+            updateRoot('devDependencies', name, version, from);
+        } else {
+            updateRoot('dependencies', name, version, from);
+        }
+    });
+    return pkg;
+};
+
+export const afterAllResolved = (lockfile, context) => {
+    const fact = lockfile.importers['.'];
+    context.log(JSON.stringify(host));
+    return lockfile;
+};
+
+// const logDiff = (type: 'dependencies' | 'devDependencies', diff: any, context) => {
+//     if (diff.desc) {
+//         context.log(`${type} is wrong, ${diff.desc}.`);
+//     }
+// };
+
+// export function testReadPackage(list: any[]) {
+//     root = null;
+//     origin = {};
+//     list.map(t => readPackage(t, { log: console.log }));
+//     return root;
+// }
+
+// function compareObject(fact: any = {}, expect: any = {}) {
+//     const more: any[] = [];
+//     const less: any[] = [];
+//     Object.keys(fact).forEach(name => {
+//         if (fact[name] !== expect[name]) {
+//             more.push({ name, version: fact[name] });
+//         }
+//     });
+//     Object.keys(expect).forEach(name => {
+//         if (fact[name] !== expect[name]) {
+//             less.push({ name, version: expect[name] });
+//         }
+//     });
+//     const desc: string[] = [];
+//     if (more.length) {
+//         desc.push(`${more.map(t => `${t.name}@${t.version}`).join(' ')} is redundant`);
+//     }
+//     if (less.length) {
+//         desc.push(`cannot found ${less.map(t => `${t.name}@${t.version}`).join(' ')}`);
+//     }
+//     return {
+//         more, //
+//         less,
+//         desc: desc.join(', '),
+//     };
+// }
+
+// export function testCompareObject(fact: any = {}, expect: any = {}) {
+//     const { more, less } = compareObject(fact, expect);
+//     return { more, less };
+// }

package/src/runner.ts

@@ -0,0 +1,88 @@
+import { AsyncSeriesHook } from 'tapable';
+import zod from 'zod';
+
+import { Logger, createLogger } from './logger';
+
+export interface Config {
+    name: string;
+    plugins: Plugin[];
+}
+
+export interface Runner {
+    env: 'prod' | 'dev';
+    hook: {
+        loadPackage: AsyncSeriesHook<[]>;
+        loadConfig: AsyncSeriesHook<[]>;
+        validateConfig: AsyncSeriesHook<[]>;
+        applyConfig: AsyncSeriesHook<[any]>;
+        startCommand: AsyncSeriesHook<[]>;
+        finishCommand: AsyncSeriesHook<[]>;
+        dev: AsyncSeriesHook<[]>;
+        build: AsyncSeriesHook<[]>;
+        test: AsyncSeriesHook<[]>;
+        release: AsyncSeriesHook<[]>;
+        deploy: AsyncSeriesHook<[any]>;
+        lint: AsyncSeriesHook<[]>;
+    };
+    logger: Logger;
+    config: {
+        all: Config[];
+        current: Config;
+    };
+    package: any;
+    z: typeof zod;
+    fs: typeof import('fs-extra');
+    tapable: typeof import('tapable');
+}
+
+export interface Plugin {
+    name: string;
+    apply: (runner: Runner) => any;
+}
+
+if (typeof Promise.withResolvers === 'undefined') {
+    Promise.withResolvers = <T>() => {
+        let resolve: (value: T | PromiseLike<T>) => void;
+        let reject: (reason?: unknown) => void;
+        const promise = new Promise<T>((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        return { promise, resolve: resolve!, reject: reject! };
+    };
+}
+
+export function createRunner() {
+    const runner: Runner = {
+        env: 'prod',
+        hook: {
+            loadPackage: new AsyncSeriesHook([]),
+            loadConfig: new AsyncSeriesHook([]),
+            validateConfig: new AsyncSeriesHook([]),
+            applyConfig: new AsyncSeriesHook(['options']),
+            startCommand: new AsyncSeriesHook([]),
+            finishCommand: new AsyncSeriesHook([]),
+            dev: new AsyncSeriesHook([]),
+            build: new AsyncSeriesHook([]),
+            test: new AsyncSeriesHook([]),
+            release: new AsyncSeriesHook([]),
+            deploy: new AsyncSeriesHook(['options']),
+            lint: new AsyncSeriesHook([]),
+        },
+        logger: createLogger(),
+        config: {
+            all: [],
+            // @ts-expect-error
+            current: undefined,
+        },
+        package: {},
+        z: zod,
+        fs: require('fs-extra') as typeof import('fs-extra'),
+        tapable: require('tapable') as typeof import('tapable'),
+    };
+    return runner;
+}
+
+export function defineConfig(all: Config[]) {
+    return all;
+}

package/src/sync.ts

@@ -0,0 +1,62 @@
+async function sync(name: string) {
+    const res = await fetch(`https://registry-direct.npmmirror.com/-/package/${name}/syncs`, {
+        headers: {
+            accept: '*/*',
+            'accept-language': 'zh-CN,zh;q=0.9,en;q=0.8',
+            'sec-ch-ua': '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
+            'sec-ch-ua-mobile': '?0',
+            'sec-ch-ua-platform': '"Windows"',
+            'sec-fetch-dest': 'empty',
+            'sec-fetch-mode': 'cors',
+            'sec-fetch-site': 'same-site',
+            Referer: 'https://npmmirror.com/',
+            'Referrer-Policy': 'strict-origin-when-cross-origin',
+        },
+        body: null,
+        method: 'PUT',
+    });
+    const body = await res.json();
+    if (body.ok === true) {
+        console.log(`同步 ${name} 成功`);
+    }
+    return body;
+}
+
+const list = [
+    '@rife/config', //
+    // '@rife/infra',
+    '@rife/logger',
+    // '@rife/react',
+    // '@rife/next',
+    // '@rife/nest',
+    // '@rife/wxa',
+    '@rife/fast',
+];
+
+async function main() {
+    for (const item of list) {
+        // https://registry.npmmirror.com/-/package/@rife/infra/syncs/65a255a2afa293666acf6655/log
+        await sync(item);
+    }
+
+    poll();
+}
+
+main();
+
+async function get(name: string) {
+    try {
+        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) {
+        return `${name} error`;
+    }
+}
+
+async function poll() {
+    const res = await Promise.all(list.map(get));
+    console.log(`${res.join('\n')}\n`);
+
+    setTimeout(poll, 1000);
+}

package/src/test/pnpmfile.test.ts

@@ -0,0 +1,223 @@
+import { describe, expect, test } from 'vitest';
+
+import { compareObject, parseVersion, testCompareObject, testReadPackage } from '../pnpmfile';
+
+describe('解析版本号', () => {
+    test('范围版本号', () => {
+        expect(parseVersion('^1.0.0')).toBe('001.000.000.000');
+        expect(parseVersion('1.10.0')).toBe('001.010.000.000');
+    });
+
+    test('beta 版本号', () => {
+        expect(parseVersion('1.0.0-beta.1')).toBe('001.000.000.001');
+    });
+});
+
+describe('直接依赖提升', () => {
+    test('提升 dependencies', () => {
+        const root = {
+            name: '@rife/root',
+            dependencies: {
+                '@rife/a': 'workspace:*',
+                root: '^1.0.0',
+            },
+        };
+        const a = {
+            name: '@rife/a',
+            dependencies: {
+                a1: '^1.0.0',
+            },
+            rife: {
+                hostDependencies: {
+                    a1: true,
+                },
+            },
+        };
+        const z = {
+            name: '@rife/root',
+            dependencies: {
+                '@rife/a': 'workspace:*',
+                root: '^1.0.0',
+                a1: '^1.0.0',
+            },
+        };
+        expect(testReadPackage([root, a])).toStrictEqual(z);
+    });
+
+    test('提升 devDependencies', () => {
+        const root = {
+            name: '@rife/root',
+            dependencies: {
+                '@rife/a': 'workspace:*',
+                root: '^1.0.0',
+            },
+        };
+        const a = {
+            name: '@rife/a',
+            devDependencies: {
+                a1: '^1.0.0',
+            },
+            rife: {
+                hostDependencies: {
+                    a1: true,
+                },
+            },
+        };
+        const z = {
+            name: '@rife/root',
+            dependencies: {
+                '@rife/a': 'workspace:*',
+                root: '^1.0.0',
+            },
+            devDependencies: {
+                a1: '^1.0.0',
+            },
+        };
+        expect(testReadPackage([root, a])).toStrictEqual(z);
+    });
+
+    test('同时提升 dependencies 和 devDependencies', () => {
+        const root = {
+            name: '@rife/root',
+            dependencies: {
+                '@rife/a': 'workspace:*',
+                root: '^1.0.0',
+            },
+        };
+        const a = {
+            name: '@rife/a',
+            dependencies: {
+                a1: '^1.0.0',
+            },
+            devDependencies: {
+                a2: '^1.0.0',
+            },
+            rife: {
+                hostDependencies: {
+                    a1: true,
+                    a2: true,
+                },
+            },
+        };
+        const z = {
+            name: '@rife/root',
+            dependencies: {
+                '@rife/a': 'workspace:*',
+                root: '^1.0.0',
+                a1: '^1.0.0',
+            },
+            devDependencies: {
+                a2: '^1.0.0',
+            },
+        };
+        expect(testReadPackage([root, a])).toStrictEqual(z);
+    });
+
+    test('提升不能覆盖现有版本号', () => {
+        const root = {
+            name: '@rife/root',
+            dependencies: {
+                '@rife/a': 'workspace:*',
+                root: '^1.0.0',
+                a1: '^1.0.0',
+            },
+            devDependencies: {
+                a2: '^1.0.0',
+            },
+        };
+        const a = {
+            name: '@rife/a',
+            dependencies: {
+                a1: '^1.0.1',
+            },
+            devDependencies: {
+                a2: '^1.0.1',
+            },
+            rife: {
+                hostDependencies: {
+                    a1: true,
+                    a2: true,
+                },
+            },
+        };
+        const z = {
+            name: '@rife/root',
+            dependencies: {
+                '@rife/a': 'workspace:*',
+                root: '^1.0.0',
+                a1: '^1.0.0',
+            },
+            devDependencies: {
+                a2: '^1.0.0',
+            },
+        };
+        expect(testReadPackage([root, a])).toStrictEqual(z);
+    });
+});
+
+describe('依赖同一个依赖的多个版本', () => {
+    test('总是提升最新版本', () => {
+        const root = {
+            name: '@rife/root',
+            dependencies: {
+                '@rife/a': 'workspace:*',
+                root: '^1.0.0',
+            },
+        };
+        const a = {
+            name: '@rife/a',
+            dependencies: {
+                a1: '^1.0.0',
+            },
+            rife: {
+                hostDependencies: {
+                    a1: true,
+                },
+            },
+        };
+        const b = {
+            name: '@rife/b',
+            dependencies: {
+                a1: '^1.0.1',
+                b1: '^1.0.0',
+            },
+            rife: {
+                hostDependencies: {
+                    a1: true,
+                    b1: true,
+                },
+            },
+        };
+        const z = {
+            name: '@rife/root',
+            dependencies: {
+                '@rife/a': 'workspace:*',
+                root: '^1.0.0',
+                a1: '^1.0.1',
+                b1: '^1.0.0',
+            },
+        };
+        expect(testReadPackage([root, a, b])).toStrictEqual(z);
+    });
+});
+
+describe('比较差异', () => {
+    test('相同', () => {
+        expect(testCompareObject({}, {})).toStrictEqual({ more: [], less: [] });
+    });
+
+    test('多了', () => {
+        expect(testCompareObject({ a: 1 }, {})).toStrictEqual({ more: [{ name: 'a', version: 1 }], less: [] });
+    });
+
+    test('少了', () => {
+        expect(testCompareObject({}, { a: 1 })).toStrictEqual({ more: [], less: [{ name: 'a', version: 1 }] });
+    });
+
+    test('差异', () => {
+        expect(testCompareObject({ b: 2 }, { a: 1 })).toStrictEqual({
+            more: [{ name: 'b', version: 2 }],
+            less: [{ name: 'a', version: 1 }],
+        });
+    });
+});