@deot/dev-cli 1.0.6 → 1.0.8

package/dist/index.cjs.js

@@ -0,0 +1,1210 @@
+'use strict';
+
+var commander = require('commander');
+var node_module = require('node:module');
+var chalk = require('chalk');
+var ora = require('ora');
+var devShared = require('@deot/dev-shared');
+var path = require('node:path');
+var fs = require('fs-extra');
+var inquirer = require('inquirer');
+var autocomplete = require('inquirer-autocomplete-prompt');
+var typescript = require('@rollup/plugin-typescript');
+var pluginNodeResolve = require('@rollup/plugin-node-resolve');
+var commonjs = require('@rollup/plugin-commonjs');
+var replace = require('@rollup/plugin-replace');
+var rollup = require('rollup');
+var apiExtractor = require('@microsoft/api-extractor');
+var parser = require('conventional-commits-parser');
+var semver = require('semver');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+
+const cwd = process.cwd();
+const require$$2 = node_module.createRequire(cwd);
+class Shared {
+    static config;
+    static getNormalizePackage = (dataMap) => {
+        Object.keys(dataMap).forEach(packageName => {
+            const relations = dataMap[packageName];
+            relations.forEach((packageName$) => {
+                if (dataMap[packageName$].includes(packageName)) {
+                    throw new Error(`${packageName} ${packageName$} deps loop`);
+                }
+            });
+        });
+        const needUseMap = Object.keys(dataMap).reduce((pre, key) => (pre[key] = 0, pre), {});
+        const queue = [];
+        for (let key in dataMap) {
+            const dependencies = dataMap[key];
+            dependencies.forEach((dependency) => {
+                needUseMap[dependency] += 1;
+            });
+        }
+        for (let key in needUseMap) {
+            if (needUseMap[key] === 0) {
+                queue.push(key);
+            }
+        }
+        const result = [];
+        while (queue.length > 0) {
+            const node = queue.shift();
+            if (!node)
+                return [];
+            result.push(node);
+            const dependencies = dataMap[node];
+            for (let i = 0; i < dependencies.length; i++) {
+                const dependency = dependencies[i];
+                needUseMap[dependency] -= 1;
+                if (needUseMap[dependency] === 0) {
+                    queue.push(dependency);
+                }
+            }
+        }
+        return result.reverse();
+    };
+    static getPackageName = (packageFolderName$) => {
+        const { workspace, packageFolderName, packageName } = Shared.impl();
+        if (!workspace
+            || !packageFolderName$
+            || packageFolderName$ === packageFolderName) {
+            return packageName;
+        }
+        else {
+            return `${packageName}-${packageFolderName$.replace(new RegExp(`${packageName}-?`), '')}`;
+        }
+    };
+    static getPackageFolderName = (packageName$) => {
+        const { workspace, packageFolderName, packageName } = Shared.impl();
+        if (!workspace)
+            return '';
+        if (packageName$ === packageName)
+            return packageFolderName;
+        return packageName$?.replace(new RegExp(`${packageName}-?`), '');
+    };
+    static impl() {
+        if (Shared.config)
+            return Shared.config;
+        const rootPackageOptions = require$$2(`${cwd}/package.json`);
+        let workspace = 'packages';
+        let isMonorepo = fs.existsSync(path__namespace.resolve(cwd, workspace));
+        workspace = isMonorepo ? workspace : '';
+        const packageFolderName = isMonorepo ? 'index' : '';
+        const packageDir = path__namespace.resolve(cwd, workspace);
+        const packageOptions = require$$2(path__namespace.resolve(packageDir, packageFolderName, 'package.json'));
+        const packageName = packageOptions.name;
+        const packageVersion = packageOptions.version;
+        const packageFolderNames = !isMonorepo ? [] : fs
+            .readdirSync(packageDir)
+            .reduce((pre, file) => {
+            const fullpath = path__namespace.resolve(packageDir, file);
+            const stat = fs.statSync(fullpath);
+            if (!(/(^_|tpl)/.test(file))
+                && stat.isDirectory()) {
+                pre.push(file);
+            }
+            return pre;
+        }, []);
+        const packageOptionsMap = packageFolderNames.reduce((pre, packageFolderName$) => {
+            pre[packageFolderName$] = require$$2(path__namespace.resolve(packageDir, packageFolderName$, 'package.json'));
+            return pre;
+        }, {});
+        const packageDirsMap = packageFolderNames.reduce((pre, packageFolderName$) => {
+            pre[packageFolderName$] = path__namespace.resolve(packageDir, packageFolderName$);
+            return pre;
+        }, {});
+        const packageRelation = packageFolderNames.reduce((pre, packageFolderName$) => {
+            let packagesOptions = packageOptionsMap[packageFolderName$];
+            let deps = {
+                ...(packagesOptions.dependencies || {}),
+                ...(packagesOptions.devDependencies || {}),
+            };
+            pre[packagesOptions.name] = Object.keys(deps).filter(i => new RegExp(`${packageName}`).test(i));
+            return pre;
+        }, {});
+        const normalizePackageNames = Shared.getNormalizePackage(packageRelation);
+        const normalizePackageFolderNames = normalizePackageNames
+            .map(i => i.replace(new RegExp(`${packageName}-?`), '') || packageFolderName);
+        const homepage = (rootPackageOptions.repository || packageOptions.repository || {}).url || '';
+        const config = {
+            cwd,
+            workspace,
+            homepage: homepage.replace(/(.*)(https?:\/\/.*)(#|\.git)/, '$2'),
+            packageFolderName,
+            packageDir,
+            packageOptions,
+            packageName,
+            packageVersion,
+            packageFolderNames,
+            packageOptionsMap,
+            packageDirsMap,
+            packageRelation,
+            normalizePackageNames,
+            normalizePackageFolderNames
+        };
+        Shared.config = config;
+        return config;
+    }
+}
+
+const run$5 = (options) => devShared.Utils.autoCatch(async () => {
+    const locals = Shared.impl();
+    const { workspace, packageFolderNames } = locals;
+    if (!workspace) {
+        return devShared.Logger.log(`<link> Monorepo Supported Only.`);
+    }
+    if (typeof options.dryRun === 'undefined') {
+        options.dryRun = process.env.NODE_ENV === 'UNIT';
+    }
+    const command = `npx pnpm link ./${workspace}/`;
+    if (options.dryRun)
+        return devShared.Shell.spawn(`echo ${command}`);
+    const spinner = ora(`Links ...\n`);
+    spinner.start();
+    await Promise.all(packageFolderNames.map(i => {
+        return devShared.Shell.spawn(`${command}${i}`);
+    }));
+    spinner.stop();
+    devShared.Logger.log(`${chalk.green('Links Success')}`);
+});
+
+const { prompt: prompt$2, registerPrompt: registerPrompt$1, Separator } = inquirer;
+const getOptions$1 = async () => {
+    const { packageFolderNames } = Shared.impl();
+    const question = [
+        {
+            type: 'list',
+            name: 'mode',
+            message: 'Select Mode:',
+            choices: [
+                new Separator('选择添加的类型：'),
+                'dependent',
+                'package'
+            ],
+            default: 'package'
+        },
+        {
+            type: 'autocomplete',
+            message: 'Select Package To Install:',
+            when: (answers) => answers.mode === 'dependent',
+            name: 'packageFolderName',
+            default: 'index',
+            source: (_, input) => {
+                input = input || '';
+                return new Promise(($resolve => {
+                    let filter = input
+                        ? packageFolderNames.filter(item => item.includes(input))
+                        : packageFolderNames;
+                    $resolve(filter);
+                }));
+            }
+        },
+        {
+            type: 'input',
+            name: 'dependentName',
+            message: 'Input Dependent Name',
+            default: '',
+            when: (answers) => answers.mode === 'dependent',
+            validate: (answer) => {
+                if (!answer) {
+                    return '请输入需要添加的模块名';
+                }
+                return true;
+            }
+        },
+        {
+            type: 'list',
+            name: 'args',
+            when: (answers) => answers.mode === 'dependent',
+            message: 'Select Install Mode:',
+            choices: [
+                '-S',
+                '-D',
+                '-O'
+            ]
+        },
+        {
+            type: 'input',
+            name: 'packageFolderName',
+            message: 'Input Package Name',
+            default: '',
+            when: (answers) => answers.mode === 'package',
+            validate: (answer) => {
+                if (!answer) {
+                    return '请输入需要添加的包名';
+                }
+                if (packageFolderNames.includes(answer) || answer === 'dev') {
+                    return '包名已存在';
+                }
+                return true;
+            }
+        }
+    ];
+    registerPrompt$1('autocomplete', autocomplete);
+    let result = await prompt$2(question);
+    if (result.mode == 'dependent') {
+        result.packageName = Shared.getPackageName(result.packageFolderName);
+    }
+    if (result.mode == 'package') {
+        result.packageName = Shared.getPackageName(result.packageFolderName);
+    }
+    result.args = [result.args];
+    return result;
+};
+
+const run$4 = (options) => devShared.Utils.autoCatch(async () => {
+    const locals = Shared.impl();
+    const { workspace, packageDir } = locals;
+    if (!workspace) {
+        return devShared.Logger.log(`<add> Monorepo Supported Only.`);
+    }
+    if (typeof options.dryRun === 'undefined') {
+        options.dryRun = process.env.NODE_ENV === 'UNIT';
+    }
+    const { mode, dependentName, args, packageFolderName, packageName } = await getOptions$1();
+    let command = mode === 'dependent'
+        ? `npx pnpm add --filter ${packageName} ${dependentName} ${args.join(' ')}`
+        : `npx pnpm link ./${workspace}/${packageFolderName}`;
+    if (options.dryRun)
+        return devShared.Shell.spawn(`echo "${command}"`);
+    const spinner = ora(`${command}\n`).start();
+    await devShared.Shell.spawn(command);
+    spinner.stop();
+    if (mode === 'package') {
+        let dir = path.resolve(packageDir);
+        fs.outputFileSync(`${dir}/${packageFolderName}/README.md`, '// TODO');
+        fs.outputFileSync(`${dir}/${packageFolderName}/src/index.ts`, '// TODO');
+        fs.outputFileSync(`${dir}/${packageFolderName}/__tests__/index.spec.ts`, '// TODO');
+        fs.outputFileSync(`${dir}/${packageFolderName}/package.json`, JSON.stringify({
+            name: packageName,
+            version: '1.0.0',
+            main: 'dist/index.js',
+            types: "dist/index.d.ts",
+            type: "module",
+            files: [
+                "dist"
+            ],
+            license: 'MIT',
+            publishConfig: {
+                access: 'public'
+            },
+            dependencies: {}
+        }, null, 2));
+        fs.outputFileSync(`${dir}/${packageFolderName}/api-extractor.json`, JSON.stringify({
+            extends: "../../api-extractor.json",
+            mainEntryPointFilePath: `./dist/${workspace}/${packageFolderName}/src/index.d.ts`,
+            dtsRollup: {
+                publicTrimmedFilePath: "./dist/index.d.ts"
+            }
+        }, null, 2));
+    }
+    await devShared.Shell.spawn(command);
+});
+
+const ALL_PACKAGE = 'All Packages';
+const { prompt: prompt$1, registerPrompt } = inquirer;
+const getOptions = async () => {
+    const isDev = process.env.NODE_ENV === 'development';
+    const { packageFolderNames } = Shared.impl();
+    const packages$ = [ALL_PACKAGE, ...packageFolderNames];
+    const question = [
+        {
+            type: 'autocomplete',
+            message: `Select Package To ${isDev ? 'Develop' : 'Test'}:`,
+            name: 'packageFolderName',
+            default: 'cli',
+            source: (_, input) => {
+                input = input || '';
+                return new Promise(($resolve => {
+                    let filter = input
+                        ? packages$.filter(item => item.includes(input))
+                        : packages$;
+                    $resolve(filter);
+                }));
+            }
+        },
+        {
+            type: 'confirm',
+            message: 'Watch Mode?',
+            name: 'watch',
+            when: () => !isDev,
+            default: (answers) => {
+                return answers.packageFolderName !== ALL_PACKAGE;
+            }
+        }
+    ];
+    registerPrompt('autocomplete', autocomplete);
+    let result = await prompt$1(question);
+    result.packageFolderName = result.packageFolderName == ALL_PACKAGE
+        ? undefined
+        : result.packageFolderName;
+    result.watch = result.watch || isDev;
+    return result;
+};
+
+const run$3 = (options) => devShared.Utils.autoCatch(async () => {
+    const locals = Shared.impl();
+    if (typeof options.dryRun === 'undefined') {
+        options.dryRun = process.env.NODE_ENV === 'UNIT';
+    }
+    if (locals.workspace && !options.packageName) {
+        const promptOptions = await getOptions();
+        options = {
+            ...options,
+            ...promptOptions
+        };
+    }
+    const { cwd, workspace, packageOptionsMap, packageDirsMap } = locals;
+    const { packageName, watch, dryRun } = options;
+    options.packageFolderName = Shared.getPackageFolderName(options.packageName) || options.packageFolderName;
+    options.workspace = workspace;
+    const packageOptions = packageOptionsMap[options.packageFolderName];
+    const packageDir = packageDirsMap[options.packageFolderName];
+    if (workspace
+        && cwd !== packageDir
+        && packageOptions?.scripts?.['test']) {
+        await devShared.Shell.spawn(`npm`, ['run', 'test']);
+        return;
+    }
+    if (!options.packageFolderName)
+        delete options.packageFolderName;
+    if (!options.workspace)
+        delete options.workspace;
+    delete options.packageName;
+    const command = `cross-env NODE_ENV=${process.env.NODE_ENV || 'TEST'} TEST_OPTIONS=${encodeURIComponent(JSON.stringify(options))} jest `
+        + ([
+            '--passWithNoTests',
+            `${watch ? '--watchAll' : ''}`
+        ].join(' '));
+    if (dryRun)
+        return devShared.Shell.spawn(`echo ${command}`);
+    await devShared.Shell.spawn(command);
+    if (!watch)
+        return;
+    devShared.Logger.log(packageName || '', '测试已通过');
+}, {
+    onError: (e) => {
+        if (typeof e === 'number' && e === 1) {
+            devShared.Logger.error('测试未通过');
+        }
+        else {
+            devShared.Logger.error(e);
+        }
+        process.exit(1);
+    }
+});
+
+const run$2 = (options) => devShared.Utils.autoCatch(async () => {
+    const locals = Shared.impl();
+    if (typeof options.dryRun === 'undefined') {
+        options.dryRun = process.env.NODE_ENV === 'UNIT';
+    }
+    if (options.dryRun)
+        return devShared.Shell.spawn(`echo development`);
+    const { cwd, workspace, packageOptionsMap, packageDirsMap } = locals;
+    const { packageName } = options;
+    const getPackageFolderName = Shared.getPackageFolderName(packageName);
+    const packageOptions = packageOptionsMap[getPackageFolderName];
+    const packageDir = packageDirsMap[getPackageFolderName];
+    options.watch = true;
+    if (!workspace
+        && packageName
+        && packageName !== '**'
+        && cwd !== packageDir
+        && packageOptions?.scripts?.['dev']) {
+        await devShared.Shell.spawn(`npm`, ['run', 'dev']);
+        return;
+    }
+    await devShared.Shell.spawn(`cross-env`, [
+        'NODE_ENV=development',
+        'npm',
+        'run',
+        'test',
+        '--',
+        packageName ? `--package-name ${packageName}` : ''
+    ]);
+});
+
+const require$$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('index.cjs.js', document.baseURI).href)));
+class Builder {
+    packageDir;
+    packageName;
+    packageOptions;
+    config;
+    commandOptions;
+    constructor(config, commandOptions) {
+        const { workspace, packageDir, packageName } = Shared.impl();
+        if (typeof config === 'string') {
+            let packageFolderName = config;
+            let packageDir$ = path__namespace.resolve(packageDir, packageFolderName);
+            config = {
+                dir: packageDir$,
+                name: packageFolderName || 'index',
+                input: packageDir$ + '/src/index.ts',
+                output: [
+                    {
+                        file: packageDir$ + '/dist/index.es.js',
+                        format: 'es',
+                        exports: 'named',
+                        sourcemap: false
+                    },
+                    {
+                        file: packageDir$ + '/dist/index.iife.js',
+                        format: 'iife',
+                        name: packageName,
+                    },
+                    {
+                        file: packageDir$ + '/dist/index.cjs.js',
+                        format: 'cjs'
+                    }
+                ].filter(i => {
+                    return commandOptions.output.includes(i.format);
+                })
+            };
+        }
+        this.packageDir = path__namespace.resolve(packageDir, workspace ? `./${config.name}` : '');
+        this.packageName = config.name === 'index'
+            ? packageName
+            : `${packageName}-${config.name}`;
+        this.packageOptions = require$$1(`${this.packageDir}/package.json`);
+        this.config = config;
+        this.commandOptions = commandOptions;
+    }
+    async process() {
+        const { cwd, workspace } = Shared.impl();
+        const { packageOptions, packageName, packageDir } = this;
+        if (workspace
+            && packageOptions?.scripts?.build
+            && packageDir !== cwd) {
+            await devShared.Shell.spawn(`npm`, ['run', 'build'], {
+                cwd: packageDir
+            });
+            return;
+        }
+        const spinner = ora(`${packageName} Build ...`);
+        try {
+            spinner.start();
+            await fs.emptyDir(`${packageDir}/dist`);
+            const stats = await this.buildSources();
+            await this.buildTypes();
+            spinner.stop();
+            devShared.Logger.log(`${chalk.cyan(`${packageName}`)}: ${chalk.green('Success')}`);
+            stats.forEach((stat) => {
+                devShared.Logger.log(`${chalk.green(stat.format.toUpperCase())}: ${devShared.Utils.formatBytes(stat.size)}`);
+            });
+        }
+        catch (e) {
+            devShared.Logger.log('Error!', e);
+            throw e;
+        }
+    }
+    async buildSources() {
+        const { workspace } = Shared.impl();
+        const { name, input, output } = this.config;
+        const { packageOptions } = this;
+        const external = Object
+            .keys({
+            ...packageOptions.dependencies,
+            ...packageOptions.peerDependencies
+        })
+            .map(i => new RegExp(`^${i}$`));
+        const source = workspace ? `${workspace}/${name}/**/*` : 'src/**/*';
+        const shims = workspace ? `${workspace}/shims.d.ts` : 'shims.d.ts';
+        const outDir = workspace ? `${workspace}/${name}/dist` : 'dist';
+        const builder = await rollup.rollup({
+            input,
+            external: [
+                /^node:/,
+                /^[a-zA-Z@]/,
+                ...external
+            ],
+            plugins: [
+                typescript({
+                    include: [source, shims],
+                    exclude: ['dist'],
+                    compilerOptions: {
+                        rootDir: '.',
+                        outDir,
+                        declaration: true
+                    }
+                }),
+                commonjs({ extensions: ['.js', '.ts'] }),
+                pluginNodeResolve.nodeResolve(),
+                replace({
+                    '1.0.6': `'${packageOptions.version}'`,
+                    false: 'false',
+                    true: true
+                })
+            ]
+        });
+        await Promise.all(output.map(builder.write));
+        const stats = [];
+        await output.reduce((pre, cur, index) => {
+            pre
+                .then(() => fs.stat(cur.file))
+                .then((stat) => {
+                stats[index] = {
+                    format: cur.format,
+                    size: stat.size
+                };
+            });
+            return pre;
+        }, Promise.resolve());
+        return stats;
+    }
+    async buildTypes() {
+        const { workspace } = Shared.impl();
+        const { packageDir, packageOptions } = this;
+        if (workspace && packageOptions?.scripts?.['build:types']) {
+            await devShared.Shell.spawn(`npm`, ['run', 'build:types'], {
+                cwd: packageDir
+            });
+            return;
+        }
+        const config = path__namespace.resolve(packageDir, `api-extractor.json`);
+        if (fs.existsSync(config)) {
+            const result = apiExtractor.Extractor.invoke(apiExtractor.ExtractorConfig.loadFileAndPrepare(config), {
+                localBuild: true,
+                showVerboseMessages: false
+            });
+            if (!result.succeeded) {
+                devShared.Logger.error(`API Extractor completed with ${result.errorCount} errors and ${result.warningCount} warnings`);
+                process.exitCode = 1;
+            }
+        }
+        await fs.remove(`${packageDir}/dist/${workspace || 'src'}`);
+    }
+}
+const builder = (options, commandOptions) => {
+    return new Builder(options, commandOptions);
+};
+
+const run$1 = (options) => devShared.Utils.autoCatch(async () => {
+    const locals = Shared.impl();
+    if (typeof options.dryRun === 'undefined') {
+        options.dryRun = process.env.NODE_ENV === 'UNIT';
+    }
+    const { normalizePackageFolderNames } = Shared.impl();
+    let packageFolderName = Shared.getPackageFolderName(options.packageName || '**');
+    let inputs = [];
+    if (locals.workspace && packageFolderName === '**') {
+        inputs = normalizePackageFolderNames;
+    }
+    else {
+        inputs = [packageFolderName];
+    }
+    if (options.dryRun)
+        return devShared.Shell.spawn(`echo ${inputs.join(' ')}`);
+    await inputs
+        .reduce((preProcess, packageFolderName$) => {
+        preProcess = preProcess.then(() => builder(packageFolderName$, options).process());
+        return preProcess;
+    }, Promise.resolve());
+}, {
+    onError: (e) => {
+        if (typeof e === 'number' && e === 1) {
+            devShared.Logger.error('编译未通过');
+        }
+        else {
+            devShared.Logger.error(e);
+        }
+        process.exit(1);
+    }
+});
+
+const require$ = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('index.cjs.js', document.baseURI).href)));
+const { prompt } = inquirer;
+const HASH = '-hash-';
+const SUFFIX = '🐒💨🙊';
+const parserOptions = {
+    noteKeywords: ['BREAKING CHANGE', 'Breaking Change']
+};
+const reBreaking = new RegExp(`(${parserOptions.noteKeywords.join(')|(')})`);
+class Releaser {
+    packageDir;
+    packageName;
+    packageFolderName;
+    packageOptions;
+    packageRelation;
+    config;
+    changeLog;
+    version;
+    commits;
+    commandOptions;
+    constructor(config, commandOptions) {
+        const { packageDir, packageRelation } = Shared.impl();
+        if (typeof config === 'string') {
+            let packageFolderName = config;
+            let packageDir$ = path__namespace.resolve(packageDir, packageFolderName);
+            config = {
+                dir: packageDir$,
+                name: packageFolderName
+            };
+        }
+        this.packageDir = config.dir;
+        this.packageName = Shared.getPackageName(config.name);
+        this.packageFolderName = config.name;
+        this.packageOptions = require$(`${this.packageDir}/package.json`);
+        this.packageRelation = packageRelation[this.packageName] || [];
+        this.config = config;
+        this.commits = [];
+        this.changeLog = '';
+        this.version = '';
+        this.commandOptions = commandOptions;
+    }
+    async parseCommits() {
+        const { workspace } = Shared.impl();
+        const { packageFolderName, packageName, commandOptions } = this;
+        let params = ['tag', '--list', `'${packageName}@*'`, '--sort', '-v:refname'];
+        const { stdout: tags } = await devShared.Shell.exec('git', params);
+        const [latestTag] = tags.split('\n');
+        devShared.Logger.log(chalk.yellow(`Last Release Tag`) + `: ${latestTag || '<none>'}`);
+        params = ['--no-pager', 'log', `${latestTag}..HEAD`, `--format=%B%n${HASH}%n%H${SUFFIX}`];
+        let { stdout } = await devShared.Shell.exec('git', params);
+        let skipGetLog = false;
+        if (latestTag) {
+            const log1 = await devShared.Shell.exec('git', ['rev-parse', latestTag]);
+            const log2 = await devShared.Shell.exec('git', ['--no-pager', 'log', '-1', '--format=%H']);
+            if (log1.stdout === log2.stdout) {
+                skipGetLog = true;
+            }
+        }
+        if (!skipGetLog && !stdout) {
+            if (latestTag) {
+                params.splice(2, 1, `${latestTag}`);
+            }
+            else {
+                params.splice(2, 1, 'HEAD');
+            }
+            ({ stdout } = await devShared.Shell.exec('git', params));
+        }
+        const allowTypes = ['feat', `fix`, `break change`, `style`, `perf`, `types`, `refactor`, `chore`];
+        const rePlugin = new RegExp(`^(${allowTypes.join('|')})${workspace ? `\\(${packageFolderName}\\)` : '(\\(.+\\))?'}: .*`, 'i');
+        const allCommits = stdout.split(SUFFIX);
+        const commits = allCommits
+            .filter((commit) => {
+            const chunk = commit.trim();
+            return chunk && rePlugin.test(chunk);
+        })
+            .map((commit) => {
+            const node = parser.sync(commit);
+            const body = (node.body || node.footer);
+            if (!node.type)
+                node.type = parser.sync(node.header?.replace(/\(.+\)!?:/, ':') || '').type;
+            if (!node.hash)
+                node.hash = commit.split(HASH).pop()?.trim();
+            node.breaking = reBreaking.test(body) || /!:/.test(node.header);
+            node.effect = false;
+            node.custom = false;
+            return node;
+        });
+        if (!commits.length) {
+            devShared.Logger.log(chalk.red(`No Commits Found.`));
+        }
+        else {
+            devShared.Logger.log(chalk.yellow(`Found `)
+                + chalk.bold(`${allCommits.length}`)
+                + ` Commits, `
+                + chalk.bold(`${commits.length}`)
+                + ' Commits Valid');
+        }
+        const { skipUpdatePackage } = commandOptions;
+        if (commits.length && skipUpdatePackage) {
+            let skip = false;
+            if (typeof skipUpdatePackage === 'boolean' && skipUpdatePackage) {
+                let result = await prompt([
+                    {
+                        type: 'confirm',
+                        name: 'skip',
+                        message: `Skip Update（${this.packageName}@${this.packageOptions.version}）：`,
+                        default: true
+                    }
+                ]);
+                skip = result.skip;
+            }
+            else if (typeof skipUpdatePackage === 'string'
+                && (skipUpdatePackage === '**'
+                    || skipUpdatePackage.split(',').includes(this.packageName))) {
+                skip = true;
+            }
+            if (skip) {
+                devShared.Logger.log(chalk.red(`Skipping Update\n`));
+                return;
+            }
+        }
+        await this.updateVersion();
+        await this.updateCommits(commits);
+        const { forceUpdatePackage } = commandOptions;
+        if (!commits.length && forceUpdatePackage) {
+            let force = false;
+            if (typeof forceUpdatePackage === 'boolean' && forceUpdatePackage) {
+                let result = await prompt([
+                    {
+                        type: 'confirm',
+                        name: 'force',
+                        message: `Force Update（${this.packageName}@${this.packageOptions.version}）：`,
+                        default: true
+                    }
+                ]);
+                force = result.force;
+            }
+            else if (typeof forceUpdatePackage === 'string'
+                && (forceUpdatePackage === '**'
+                    || forceUpdatePackage.split(',').includes(this.packageName))) {
+                force = true;
+            }
+            if (force) {
+                const oldVersion = this.packageOptions.version;
+                const versionChanged = `\`${oldVersion}\` -> \`${this.version}\``;
+                this.commits = [
+                    {
+                        type: 'chore',
+                        header: `chore(${this.packageFolderName || 'release'}): force-publish ${versionChanged}`,
+                        hash: '',
+                        effect: false,
+                        breaking: false,
+                        custom: true
+                    }
+                ];
+                this.changeLog = `### Force Update Package\n\n- ${versionChanged}`.trim();
+            }
+        }
+    }
+    rebuildChangeLog(commits) {
+        const { packageDir } = this;
+        const { homepage, workspace } = Shared.impl();
+        const logPath = path__namespace.resolve(packageDir, './CHANGELOG.md');
+        const logFile = fs.existsSync(logPath) ? fs.readFileSync(logPath, 'utf-8') : '';
+        const notes = {
+            breaking: [],
+            features: [],
+            fixes: [],
+            updates: []
+        };
+        const closeRegxp = /\(?(closes? )\(?#((\d+))\)/ig;
+        const pullRegxp = /(?<!closes? )\((#(\d+))\)/ig;
+        for (const commit of commits) {
+            const { effect, breaking, hash, header, type } = commit;
+            const ref = !hash || pullRegxp.test(header)
+                ? ''
+                : ` ([${hash?.substring(0, 7)}](${homepage}/commit/${hash}))`;
+            let message = header?.trim();
+            if (workspace && !effect) {
+                message = message.replace(/\(.+\)!?:/, ':');
+            }
+            message = message
+                .replace(pullRegxp, `[$1](${homepage}/pull/$2)`)
+                .replace(closeRegxp, `[$1$2](${homepage}/issues/$2)`) + ref;
+            if (breaking) {
+                notes.breaking.push(message);
+            }
+            else if (type === 'fix') {
+                notes.fixes.push(message);
+            }
+            else if (type === 'feat') {
+                notes.features.push(message);
+            }
+            else {
+                notes.updates.push(message);
+            }
+        }
+        Object.keys(notes).forEach(i => {
+            notes[i] = notes[i].filter((j) => {
+                return !logFile.includes(j);
+            });
+        });
+        const parts = [
+            notes.breaking.length ? `### Breaking Changes\n\n- ${notes.breaking.join('\n- ')}`.trim() : '',
+            notes.fixes.length ? `### Bugfixes\n\n- ${notes.fixes.join('\n- ')}`.trim() : '',
+            notes.features.length ? `### Features\n\n- ${notes.features.join('\n- ')}`.trim() : '',
+            notes.updates.length ? `### Updates\n\n- ${notes.updates.join('\n- ')}`.trim() : ''
+        ].filter(Boolean);
+        const newLog = parts.join('\n\n');
+        return !parts.length || logFile.includes(newLog)
+            ? ''
+            : newLog;
+    }
+    async updateVersion() {
+        const { packageOptions, commits, commandOptions } = this;
+        const { version } = packageOptions;
+        let newVersion = '';
+        if (commandOptions.customVersion) {
+            newVersion = commandOptions.customVersion;
+            if (!(/\d+.\d+.\d+/.test(newVersion)) || version === newVersion) {
+                let result = await prompt([
+                    {
+                        type: 'input',
+                        name: 'version',
+                        message: `Custom Update Version（${this.packageName}@${version}）：`,
+                        default: '',
+                        validate: (answer) => {
+                            if (!(/\d+.\d+.\d+/.test(answer))) {
+                                return 'Version Should Be Like x.x.x';
+                            }
+                            if (answer === version) {
+                                return 'Version Should Be Diff Than Before';
+                            }
+                            return true;
+                        }
+                    }
+                ]);
+                newVersion = result.version;
+            }
+        }
+        else {
+            const intersection = [
+                commandOptions.major && 'major',
+                commandOptions.minor && 'minor',
+                commandOptions.patch && 'patch'
+            ].filter(i => !!i);
+            if (intersection.length) {
+                newVersion = semver.inc(version, intersection[0]) || '';
+            }
+            else {
+                const types = new Set(commits.map(({ type }) => type));
+                const breaking = commits.some((commit) => !!commit.breaking);
+                const level = breaking
+                    ? 'major'
+                    : types.has('feat')
+                        ? 'minor'
+                        : 'patch';
+                newVersion = semver.inc(version, level) || '';
+            }
+        }
+        this.version = newVersion;
+    }
+    isChanged() {
+        return !!this.commits.length;
+    }
+    async updateCommits(commits, source) {
+        if (!commits.length)
+            return;
+        const { packageName } = this;
+        const olds = this.commits.map(i => JSON.stringify(i));
+        const newCommits = commits
+            .filter(i => {
+            return !olds.includes(JSON.stringify(i));
+        })
+            .map(j => {
+            return {
+                ...j,
+                effect: !!source
+            };
+        });
+        if (newCommits.length && this.commits.length) {
+            this.commits = this.commits.filter(i => !i.custom);
+        }
+        const commits$ = this.commits.concat(newCommits);
+        if (source) {
+            devShared.Logger.log(chalk.magenta(`MERGE COMMITS: `)
+                + chalk.bold(`${commits.length}`) + ` Commits. `
+                + 'merge ' + chalk.yellow(source) + ' into ' + chalk.green(packageName));
+        }
+        else {
+            devShared.Logger.log(``);
+        }
+        const changeLog = this.rebuildChangeLog(commits$);
+        if (changeLog) {
+            this.commits = commits$;
+            this.changeLog = changeLog;
+        }
+        else if (commits.length) {
+            devShared.Logger.log(chalk.red(`${commits.length} Commits Already Exists.`));
+        }
+    }
+    async updatePackageOptions(relationVerisons = {}) {
+        if (!this.isChanged())
+            return;
+        const { packageDir, packageOptions, commandOptions } = this;
+        const { dependencies, devDependencies } = packageOptions;
+        const newVersion = this.version;
+        devShared.Logger.log(chalk.yellow(`New Version: `) + `${newVersion}`);
+        packageOptions.version = newVersion;
+        if (Object.keys(this.packageRelation).length) {
+            for (let packageName$ in relationVerisons) {
+                let newVersion$ = relationVerisons[packageName$];
+                if (dependencies?.[packageName$]) {
+                    dependencies[packageName$] = newVersion$;
+                }
+                if (devDependencies?.[packageName$]) {
+                    devDependencies[packageName$] = newVersion$;
+                }
+            }
+        }
+        if (commandOptions.dryRun) {
+            devShared.Logger.log(chalk.yellow(`Skipping package.json Update`));
+            return;
+        }
+        devShared.Logger.log(chalk.yellow(`Updating `) + 'package.json');
+        fs.outputFileSync(`${packageDir}/package.json`, JSON.stringify(packageOptions, null, 2));
+    }
+    async updateChangelog() {
+        if (!this.isChanged())
+            return;
+        const { packageName, packageDir, packageOptions, commandOptions } = this;
+        const title = `# ${packageName} ChangeLog`;
+        const [date] = new Date().toISOString().split('T');
+        const logPath = path__namespace.resolve(packageDir, './CHANGELOG.md');
+        const logFile = fs.existsSync(logPath) ? fs.readFileSync(logPath, 'utf-8') : '';
+        const oldNotes = logFile.startsWith(title) ? logFile.slice(title.length).trim() : logFile;
+        const parts = [
+            `## v${packageOptions.version}`,
+            `_${date}_`,
+            this.changeLog
+        ].filter(Boolean);
+        const newLog = parts.join('\n\n');
+        if (commandOptions.dryRun) {
+            devShared.Logger.log(chalk.yellow(`New ChangeLog:`) + `\n${newLog}`);
+            return;
+        }
+        devShared.Logger.log(chalk.yellow(`Updating `) + `CHANGELOG.md`);
+        let content = [title, newLog, oldNotes].filter(Boolean).join('\n\n');
+        if (!content.endsWith('\n'))
+            content += '\n';
+        fs.writeFileSync(logPath, content, 'utf-8');
+    }
+    async test() {
+        if (!this.isChanged())
+            return;
+        const { commandOptions } = this;
+        if (commandOptions.dryRun) {
+            devShared.Logger.log(chalk.yellow('Skipping Test'));
+            return;
+        }
+        else {
+            devShared.Logger.log(chalk.yellow('Test...'));
+        }
+        await devShared.Shell.exec(`npm run test -- --package-name ${this.packageName}`);
+    }
+    async build() {
+        if (!this.isChanged())
+            return;
+        const { commandOptions } = this;
+        if (commandOptions.dryRun) {
+            devShared.Logger.log(chalk.yellow('Skipping Build'));
+            return;
+        }
+        else {
+            devShared.Logger.log(chalk.yellow('Build...'));
+        }
+        await devShared.Shell.exec(`npm run build -- --package-name ${this.packageName}`);
+    }
+    async publish() {
+        if (!this.isChanged())
+            return;
+        const { commandOptions, packageDir } = this;
+        if (commandOptions.dryRun || !commandOptions.publish) {
+            devShared.Logger.log(chalk.yellow(`Skipping Publish`));
+            return;
+        }
+        devShared.Logger.log(chalk.cyan(`\n Publishing to NPM`));
+        await devShared.Shell.spawn('npm', ['publish', '--no-git-checks', '--access', 'public'], {
+            cwd: packageDir
+        });
+    }
+    async tag() {
+        if (!this.isChanged())
+            return;
+        const { commandOptions, packageDir } = this;
+        const { packageName, packageOptions } = this;
+        if (commandOptions.dryRun || !commandOptions.tag) {
+            devShared.Logger.log(chalk.yellow(`Skipping Git Tag`));
+            return;
+        }
+        const tagName = `${packageName}@${packageOptions.version}`;
+        devShared.Logger.log(chalk.blue(`\n Tagging`) + chalk.grey(`${tagName}`));
+        await devShared.Shell.spawn('git', ['tag', tagName], {
+            cwd: packageDir
+        });
+    }
+    async process() {
+        const { workspace } = Shared.impl();
+        const { packageName, packageDir, packageFolderName } = this;
+        if (!packageDir || !fs.pathExists(packageDir)) {
+            throw new RangeError(`Could not find directory for package: ${packageFolderName}`);
+        }
+        devShared.Logger.log(chalk.cyan(`Releasing ${packageName}`) + ' from ' + chalk.grey(`${workspace}/${packageFolderName}`));
+        await this.parseCommits();
+        return this;
+    }
+}
+const releaser = (options, commandOptions) => {
+    return new Releaser(options, commandOptions);
+};
+
+const run = (options) => devShared.Utils.autoCatch(async () => {
+    const locals = Shared.impl();
+    if (options.dryRun) {
+        devShared.Logger.log(chalk.magenta(`DRY RUN: `)
+            + 'No files will be modified.');
+    }
+    let inputs = [];
+    if (locals.workspace) {
+        inputs = locals.normalizePackageFolderNames;
+    }
+    else {
+        inputs = [''];
+    }
+    const instances = {};
+    await inputs
+        .reduce((preProcess, packageFolderName) => {
+        preProcess = preProcess
+            .then(() => releaser(packageFolderName, options).process())
+            .then((instance) => {
+            instances[packageFolderName] = instance;
+        });
+        return preProcess;
+    }, Promise.resolve());
+    devShared.Logger.log(chalk.blue(`---------------------\n`));
+    let message = `chore(release): publish\n\n`;
+    let relationVerisons = {};
+    await inputs.reduce((preProcess, packageFolderName) => {
+        const instance = instances[packageFolderName];
+        instance.packageRelation.forEach(i => {
+            let packageFolderName$ = Shared.getPackageFolderName(i);
+            let instance$ = instances[packageFolderName$];
+            if (instance$.commits.length > 0) {
+                instance.updateCommits(instance$.commits, instance$.packageName);
+            }
+        });
+        if (instance.commits.length) {
+            preProcess = preProcess
+                .then(() => devShared.Logger.log(chalk.magenta(`CHANGED: `) + instance.packageName))
+                .then(() => instance.test())
+                .then(() => instance.build())
+                .then(() => instance.updatePackageOptions(relationVerisons))
+                .then(() => instance.updateChangelog())
+                .then(() => {
+                message += `- ${instance.packageName}@${instance.packageOptions.version}\n`;
+                relationVerisons[instance.packageName] = `^${instance.packageOptions.version}`;
+            });
+        }
+        return preProcess;
+    }, Promise.resolve());
+    devShared.Logger.log(chalk.blue(`\n---------------------\n`));
+    const isChanged = Object.keys(relationVerisons).length;
+    if (!isChanged) {
+        devShared.Logger.log(chalk.magenta(`COMMIT: `) + 'Nothing Chanaged Found.');
+    }
+    else if (options.dryRun || !options.commit) {
+        devShared.Logger.log(chalk.magenta(`COMMIT: `) + chalk.yellow(`Skipping Git Commit`) + `\n${message}`);
+    }
+    else {
+        devShared.Logger.log(chalk.magenta(`CHANGED: `) + `pnpm-lock.yaml`);
+        await devShared.Shell.spawn('npx', ['pnpm', 'install', '--lockfile-only']);
+        devShared.Logger.log(chalk.magenta(`COMMIT: `) + `CHANGELOG.md, package.json, pnpm-lock.yaml`);
+        await devShared.Shell.spawn('git', ['add', process.cwd()]);
+        await devShared.Shell.spawn('git', ['commit', '--m', `'${message}'`]);
+    }
+    await inputs
+        .reduce((preProcess, packageFolderName) => {
+        const instance = instances[packageFolderName];
+        preProcess = preProcess
+            .then(() => instance.publish())
+            .then(() => instance.tag());
+        return preProcess;
+    }, Promise.resolve());
+    devShared.Logger.log(chalk.blue(`\n---------------------\n`));
+    if (options.dryRun || !options.push) {
+        devShared.Logger.log(chalk.magenta(`FINISH: `) + 'Skipping Git Push');
+    }
+    else if (!isChanged) {
+        devShared.Logger.log(chalk.magenta(`FINISH: `) + 'Nothing Chanaged.');
+    }
+    else {
+        await devShared.Shell.spawn('git', ['push']);
+        await devShared.Shell.spawn('git', ['push', '--tags']);
+    }
+    if (options.dryRun) {
+        devShared.Logger.log(chalk.green('NO DRY RUN WAY: ')
+            + chalk.grey(`npm run release -- --no-dry-run\n`));
+    }
+}, {
+    onError: (e) => {
+        if (typeof e === 'number' && e === 1) {
+            devShared.Logger.error('发布失败');
+        }
+        else {
+            devShared.Logger.error(e);
+        }
+        process.exit(1);
+    }
+});
+
+const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('index.cjs.js', document.baseURI).href)));
+commander.program
+    .version(require$1('../package.json').version);
+commander.program
+    .usage('<cmd>');
+commander.program
+    .command('link')
+    .alias('l')
+    .description('pnpm link')
+    .option('--dry-run [boolean]', 'Dry Run')
+    .action(run$5);
+commander.program
+    .command('add')
+    .alias('a')
+    .description('add dep or create package')
+    .option('--dry-run [boolean]', 'Dry Run')
+    .action(run$4);
+commander.program
+    .command('dev')
+    .alias('d')
+    .description('dev')
+    .option('-p, --package-name <string>', 'Select PackageName')
+    .option('--dry-run [boolean]', 'Dry Run')
+    .action(run$2);
+commander.program
+    .command('build')
+    .alias('b')
+    .description('build')
+    .option('-p, --package-name <string>', 'Select packageName')
+    .option('--output <string>', 'Output', 'es,cjs')
+    .option('--dry-run [boolean]', 'Dry Run')
+    .action(run$1);
+commander.program
+    .command('release')
+    .alias('r')
+    .description('release')
+    .option('--no-dry-run [boolean]', 'No Dry Run')
+    .option('--no-tag [boolean]', 'No Tag')
+    .option('--no-publish [boolean]', 'No Publish')
+    .option('--no-commit [boolean]', 'No Commit')
+    .option('--no-push [boolean]', 'No Push')
+    .option('--force-update-package [string]', 'Force Update Package')
+    .option('--skip-update-package [string]', 'Skip Update Package')
+    .option('--custom-version [string]', 'Dry Run')
+    .option('--patch [boolean]', 'Patch')
+    .option('--major [boolean]', 'Major')
+    .option('--minor [boolean]', 'Minor')
+    .action(run);
+commander.program
+    .command('test')
+    .alias('t')
+    .description('unit-test')
+    .option('-p, --package-name <string>', 'Select PackageName')
+    .option('-w, --watch [boolean]', 'Watch Test')
+    .option('--dry-run [boolean]', 'Dry Run')
+    .action(run$3);
+commander.program.parse(process.argv);
+if (!commander.program.args.length) {
+    commander.program.help();
+}