techor/dist/commands/version.mjs

Author technology like a top leader

import { explorePathsSync } from '@techor/glob';
import { explorePackageManager, readWorkspaces, readPNPMWorkspaces } from '@techor/npm';
import require$$2 from 'path';
import log from '@techor/log';
import { readJSONFileSync, writeFileSync } from '@techor/fs';
import yargsParser from 'yargs-parser';
import extend from '@techor/extend';
import config from '../config.mjs';
import loadConfig from '../load-config.mjs';

const yargsParserOptions = {
    alias: {
        operator: 'o',
        workspaces: 'w',
        list: 'ls'
    },
    configuration: {
        'strip-aliased': true,
        'strip-dashed': true
    }
};
async function version() {
    const { _, ...cmdConfig } = yargsParser(process.argv.slice(2), yargsParserOptions);
    const [commandName, version] = _;
    const useConfig = loadConfig();
    const config$1 = extend(config, useConfig, {
        version: cmdConfig
    });
    if (!config$1.version.workspaces) {
        const packageManager = explorePackageManager();
        switch(packageManager){
            case 'pnpm':
                config$1.version.workspaces = readPNPMWorkspaces();
                break;
            case 'npm':
                config$1.version.workspaces = readWorkspaces();
                break;
        }
    }
    if (!config$1.version.workspaces?.length) {
        log.x`workspaces is not defined in package.json`;
    }
    const packagesOfPath = {};
    const packagesOfName = {};
    const workspacePackagePaths = config$1.version.workspaces.map((eachWorkspace)=>require$$2.join(eachWorkspace, '*package.json'));
    const resolveVersion = (eachVersion)=>{
        if (eachVersion.startsWith('workspace:')) {
            return eachVersion.replace('workspace:', '') + version;
        } else if (eachVersion === '') {
            return config$1.version.operator + version;
        }
    };
    const updateDependencies = (eachDependencies)=>{
        for(const dependencyName in eachDependencies){
            if (dependencyName in packagesOfName) {
                const dependencyVersion = eachDependencies[dependencyName];
                const resolvedVersion = resolveVersion(dependencyVersion);
                if (resolvedVersion) {
                    eachDependencies[dependencyName] = resolvedVersion;
                }
            }
        }
    };
    // Read package.json by workspaces
    for (const eachPackagePath of explorePathsSync(workspacePackagePaths)){
        const eachPackage = readJSONFileSync(require$$2.resolve(eachPackagePath));
        // Prevent version bumps of private package
        packagesOfPath[eachPackagePath] = eachPackage;
        packagesOfName[eachPackage.name] = eachPackage;
        // Bump to next verion
        eachPackage.version = version;
    }
    for(const eachPackagePath in packagesOfPath){
        const eachPackage = packagesOfPath[eachPackagePath];
        const { dependencies, devDependencies, peerDependencies } = packagesOfPath[eachPackagePath];
        dependencies && updateDependencies(dependencies);
        devDependencies && updateDependencies(devDependencies);
        peerDependencies && updateDependencies(peerDependencies);
        if (!config$1.version.list) {
            writeFileSync(eachPackagePath, eachPackage);
        }
    }
    const workspaceDepsTree = {};
    for(const name in packagesOfName){
        const { dependencies, peerDependencies, devDependencies } = packagesOfName[name];
        const workspacePackage = workspaceDepsTree[log.paint('**' + name + '**')] = {};
        const analyzeDeps = (eachDeps, key)=>{
            if (eachDeps) {
                workspacePackage[key] = {};
                for(const dependencyName in eachDeps){
                    if (dependencyName in packagesOfName) {
                        const eachDependencyVersion = eachDeps[dependencyName];
                        workspacePackage[key][log.paint('**' + dependencyName + '**')] = eachDependencyVersion || null;
                    }
                }
            }
        };
        analyzeDeps(dependencies, 'dependencies');
        analyzeDeps(peerDependencies, 'peerDependencies');
        analyzeDeps(devDependencies, 'devDependencies');
        /* 防止沒有印出空 {} 的項目 */ if (!Object.keys(workspaceDepsTree[log.paint('**' + name + '**')]).length) {
            workspaceDepsTree[log.paint('**' + name + '**')] = null;
        }
    }
    log`📦`;
    log.tree(workspaceDepsTree);
    log.success`bump version to ${version} for ${Object.keys(packagesOfName).length} packages in all workspace`;
}

export { version as default, yargsParserOptions };