@adinsure-ops/ops-cli 4.8.3 → 5.0.0-rc4

package/lib/commands/npm/dependency-update.js

@@ -1,113 +1,121 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const command_1 = require("@oclif/command");
-const chalk_1 = require("chalk");
-const cli_ux_1 = require("cli-ux");
-const fs = require("fs-extra");
-const minimatch = require("minimatch");
-const semver = require("semver");
-const command_base_1 = require("../../command.base");
-const command_2 = require("../../lib/command");
-const npm_1 = require("../../lib/npm");
-class NpmDependencyUpdate extends command_base_1.default {
+import { __awaiter } from "tslib";
+import { Args, Flags, ux } from '@oclif/core';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import { minimatch } from 'minimatch';
+import semver from 'semver';
+import CommandBase from '../../command.base.js';
+import ChildProcessCommand from '../../lib/command.js';
+import NpmContext from '../../lib/npm.js';
+class NpmDependencyUpdate extends CommandBase {
     /**
      * Update dependencies in package.json files for @adinsure packages
+     * @param {string} newVersion New version to update to
+     * @param {NpmPackage[]} packages Packages to update
+     * @param {boolean} [force=false] Force the update
+     * @param {string[]} filter Regular expressions filter for packages
+     * @returns {Prmoise<void>} Void Promise
      */
-    async updateDependencies(newVersion, filter = ['**/*'], packages, force = false) {
-        // Find all package.json files that are not in node modules
-        for (const path of packages) {
-            try {
-                let data = await fs.readJSON(path.jsonPath);
-                let updatedKeys = [];
-                if (data.hasOwnProperty('dependencies')) {
-                    for (const [key, value] of Object.entries(data.dependencies)) {
-                        let currentVersion = semver.valid(String(value));
-                        if (filter.some(pkg => minimatch(key, pkg))) {
-                            if (currentVersion && semver.gt(currentVersion, newVersion) && !force) {
-                                this.warn(`Lower of same version for dependency ${key} updated in file ${path.jsonPath}: ${newVersion} vs. ${currentVersion} is ${semver.gt(newVersion, currentVersion)}`);
-                            }
-                            else {
-                                data.dependencies[key] = newVersion;
-                                updatedKeys.push(key);
+    updateDependencies(newVersion, packages, force = false, filter = ['**/*']) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Find all package.json files that are not in node modules
+            for (const path of packages) {
+                try {
+                    const data = yield fs.readJSON(path.jsonPath);
+                    const updatedKeys = [];
+                    if (Object.prototype.hasOwnProperty.call(data, 'dependencies')) {
+                        for (const [key, value] of Object.entries(data.dependencies)) {
+                            const currentVersion = semver.valid(String(value));
+                            if (filter.some(pkg => minimatch(key, pkg))) {
+                                if (currentVersion && semver.gt(currentVersion, newVersion) && !force) {
+                                    this.warn(`Lower of same version for dependency ${key} updated in file ${path.jsonPath}: ${newVersion} vs. ${currentVersion} is ${semver.gt(newVersion, currentVersion)}`);
+                                }
+                                else {
+                                    data.dependencies[key] = newVersion;
+                                    updatedKeys.push(key);
+                                }
                             }
                         }
+                        fs.writeFileSync(path.jsonPath, JSON.stringify(data, null, 4));
+                        if (updatedKeys.length > 0) {
+                            this.log(`Dependencies ${updatedKeys} updated in file ${path.jsonPath}`);
+                        }
                     }
-                    fs.writeFileSync(path.jsonPath, JSON.stringify(data, null, 4));
-                    if (updatedKeys.length > 0) {
-                        this.log(`Dependencies ${updatedKeys} updated in file ${path.jsonPath}`);
-                    }
-                }
-                if (data.hasOwnProperty('devDependencies')) {
-                    for (const [key, value] of Object.entries(data.devDependencies)) {
-                        let currentVersion = semver.valid(String(value));
-                        if (filter.some(pkg => minimatch(key, pkg))) {
-                            if (currentVersion && semver.gt(currentVersion, newVersion) && !force) {
-                                this.warn(`Lower of same version for devDependency ${key} updated in file ${path.jsonPath}: ${newVersion} vs. ${currentVersion} is ${semver.gt(newVersion, currentVersion)}`);
-                            }
-                            else {
-                                data.devDependencies[key] = newVersion;
-                                updatedKeys.push(key);
+                    if (Object.prototype.hasOwnProperty.call(data, 'devDependencies')) {
+                        for (const [key, value] of Object.entries(data.devDependencies)) {
+                            const currentVersion = semver.valid(String(value));
+                            if (filter.some(pkg => minimatch(key, pkg))) {
+                                if (currentVersion && semver.gt(currentVersion, newVersion) && !force) {
+                                    this.warn(`Lower of same version for devDependency ${key} updated in file ${path.jsonPath}: ${newVersion} vs. ${currentVersion} is ${semver.gt(newVersion, currentVersion)}`);
+                                }
+                                else {
+                                    data.devDependencies[key] = newVersion;
+                                    updatedKeys.push(key);
+                                }
                             }
                         }
+                        fs.writeFileSync(path.jsonPath, JSON.stringify(data, null, 4));
+                        if (updatedKeys.length > 0) {
+                            this.log(`devDependencies ${updatedKeys} updated in file ${path.jsonPath}`);
+                        }
                     }
-                    fs.writeFileSync(path.jsonPath, JSON.stringify(data, null, 4));
-                    if (updatedKeys.length > 0) {
-                        this.log(`devDependencies ${updatedKeys} updated in file ${path.jsonPath}`);
-                    }
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (error) {
+                    this.warn(error.message);
+                    break;
                 }
             }
-            catch (err) {
-                this.warn(err.message);
-                break;
-            }
-        }
+        });
     }
-    async run() {
-        const { args, flags } = this.parse(NpmDependencyUpdate);
-        let newVersion = semver.valid(args.version);
-        let npmContext = new npm_1.default();
-        let command = new command_2.default();
-        // Stop if version invalid
-        if (!newVersion) {
-            return this.error(`${chalk_1.default.red('Version in incorrect format')}`);
-        }
-        const packages = await npmContext.packageList(['**/*'], [''], this);
-        try {
-            await this.updateDependencies(newVersion, flags.filter, packages, flags.force);
-            cli_ux_1.default.action.start(`running 'yarn install'`, undefined, { stdout: true });
-            await command.runCommand(['yarn', 'install']);
-            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
-        }
-        catch (err) {
-            this.error(err.message);
-        }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { args, flags } = yield this.parse(NpmDependencyUpdate);
+            const newVersion = semver.valid(args.version);
+            const npmContext = new NpmContext();
+            const command = new ChildProcessCommand();
+            // Stop if version invalid
+            if (!newVersion) {
+                return this.error(`${chalk.red('Version in incorrect format')}`);
+            }
+            const packages = yield npmContext.packageList(this);
+            try {
+                yield this.updateDependencies(newVersion, packages, flags.force, flags.filter);
+                ux.action.start(`running 'yarn install'`, undefined, { stdout: true });
+                yield command.runCommand(['yarn', 'install']);
+                ux.action.stop(`${chalk.green('done')}`);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                this.error(error.message);
+            }
+        });
     }
 }
-exports.default = NpmDependencyUpdate;
 NpmDependencyUpdate.description = 'update npm dependencies per package filter';
 NpmDependencyUpdate.usage = 'npm:dependency-update <type> [flags]';
 NpmDependencyUpdate.examples = [
-    `$ ops npm:dependency-update 3.4.3 --filter @adinsure/*`
+    `$ ops npm:dependency-update 3.4.3 --filter @adinsure/*`,
 ];
-NpmDependencyUpdate.args = [
-    {
-        name: 'version',
+NpmDependencyUpdate.args = {
+    version: Args.string({
         required: true,
-        description: 'Type of release'
-    }
-];
+        description: 'Type of release',
+    }),
+};
 NpmDependencyUpdate.flags = {
-    filter: command_1.flags.string({
+    filter: Flags.string({
         description: 'regular expression for which NPM packages to update',
         required: true,
-        multiple: true
+        multiple: true,
     }),
-    exclude: command_1.flags.string({
+    exclude: Flags.string({
         description: 'exclude directories where to search for package.json',
-        multiple: true
+        multiple: true,
     }),
-    force: command_1.flags.boolean({
+    force: Flags.boolean({
         description: 'force update of version regardless of lower vs higher version check',
-        default: false
-    })
+        default: false,
+    }),
 };
+export default NpmDependencyUpdate;

package/lib/commands/npm/publish.d.ts

@@ -1,16 +1,15 @@
-import { flags } from '@oclif/command';
-import CommandBase from '../../command.base';
-import { AzurePackageArray, NpmPackage } from '../../types/npm.types';
-export default class NpmPublish extends CommandBase {
+import CommandBase from '../../command.base.js';
+import { AzurePackageArray, NpmPackage } from '../../types/npm.types.js';
+export default class NpmPublish extends CommandBase<typeof NpmPublish> {
     static description: string;
     static usage: string;
     static examples: string[];
     static flags: {
-        package: flags.IOptionFlag<string[]>;
-        exclude: flags.IOptionFlag<string[]>;
-        version: flags.IOptionFlag<string>;
-        pat: flags.IOptionFlag<string | undefined>;
-        retry: import("@oclif/parser/lib/flags").IOptionFlag<number>;
+        package: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        exclude: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        version: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        pat: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        retry: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
     private cp;
     publishPackage(pkg: NpmPackage, cmd?: string[]): Promise<{

package/lib/commands/npm/publish.js

@@ -1,182 +1,196 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const command_1 = require("@oclif/command");
-const chalk_1 = require("chalk");
-const child_process_1 = require("child_process");
-const cli_ux_1 = require("cli-ux");
-const command_base_1 = require("../../command.base");
-const npm_1 = require("../../lib/npm");
-class NpmPublish extends command_base_1.default {
-    async publishPackage(pkg, cmd = ['yarn', 'publish']) {
-        var e_1, _a, e_2, _b;
-        let sh;
-        let args;
-        // cross platform compatibility
-        if (process.platform === 'win32') {
-            sh = 'cmd';
-            args = ['/c'].concat(cmd);
-        }
-        else {
-            [sh, ...args] = cmd;
-        }
-        try {
-            this.cp = child_process_1.spawn(sh, args, {
-                cwd: pkg.path,
-                env: Object.assign(Object.assign({}, process.env), process.stdout.isTTY ? { FORCE_COLOR: process.env.FORCE_COLOR || '1' } : {}),
-                stdio: 'pipe'
-            });
-            let data = '';
-            try {
-                for (var _c = tslib_1.__asyncValues(this.cp.stdout), _d; _d = await _c.next(), !_d.done;) {
-                    const chunk = _d.value;
-                    data += chunk;
-                }
+import { __asyncValues, __awaiter } from "tslib";
+import { Flags, ux } from '@oclif/core';
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+import CommandBase from '../../command.base.js';
+import NpmContext from '../../lib/npm.js';
+class NpmPublish extends CommandBase {
+    publishPackage(pkg, cmd = ['yarn', 'publish']) {
+        var _a, e_1, _b, _c, _d, e_2, _e, _f;
+        return __awaiter(this, void 0, void 0, function* () {
+            let sh;
+            let args;
+            // cross platform compatibility
+            if (process.platform === 'win32') {
+                sh = 'cmd';
+                args = ['/c', ...cmd];
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_d && !_d.done && (_a = _c.return)) await _a.call(_c);
-                }
-                finally { if (e_1) throw e_1.error; }
+            else {
+                [sh, ...args] = cmd;
             }
-            let error = '';
             try {
-                for (var _e = tslib_1.__asyncValues(this.cp.stderr), _f; _f = await _e.next(), !_f.done;) {
-                    const chunk = _f.value;
-                    error += chunk;
+                this.cp = spawn(sh, args, {
+                    cwd: pkg.path,
+                    env: Object.assign(Object.assign({}, process.env), process.stdout.isTTY ? { FORCE_COLOR: process.env.FORCE_COLOR || '1' } : {}),
+                    stdio: 'pipe',
+                });
+                let data = '';
+                try {
+                    for (var _g = true, _h = __asyncValues(this.cp.stdout), _j; _j = yield _h.next(), _a = _j.done, !_a; _g = true) {
+                        _c = _j.value;
+                        _g = false;
+                        const chunk = _c;
+                        data += chunk;
+                    }
                 }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_g && !_a && (_b = _h.return)) yield _b.call(_h);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                let error = '';
                 try {
-                    if (_f && !_f.done && (_b = _e.return)) await _b.call(_e);
+                    for (var _k = true, _l = __asyncValues(this.cp.stderr), _m; _m = yield _l.next(), _d = _m.done, !_d; _k = true) {
+                        _f = _m.value;
+                        _k = false;
+                        const chunk = _f;
+                        error += chunk;
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_k && !_d && (_e = _l.return)) yield _e.call(_l);
+                    }
+                    finally { if (e_2) throw e_2.error; }
                 }
-                finally { if (e_2) throw e_2.error; }
+                const exitCode = yield new Promise((resolve, _reject) => {
+                    this.cp.on('close', resolve);
+                });
+                if (exitCode) {
+                    throw new Error(`subprocess error exit ${exitCode}, ${error}`);
+                }
+                return { data, error };
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
             }
-            const exitCode = await new Promise((resolve, _reject) => {
-                this.cp.on('close', resolve);
-            });
-            if (exitCode) {
-                throw new Error(`subprocess error exit ${exitCode}, ${error}`);
+            catch (error) {
+                throw new Error(error.message);
             }
-            return { data, error };
-        }
-        catch (err) {
-            throw new Error(err.message);
-        }
+        });
     }
-    async checkPackageCanPublish(pkg, allPackages, version, retries) {
-        this.log('');
-        cli_ux_1.default.action.start(`${pkg.name}@${pkg.version}`, undefined, { stdout: true });
-        let matchedPackage = allPackages.value.find(azurePackage => azurePackage.name === pkg.name);
-        if (pkg.version !== version) {
-            this.warn(`${pkg.name}@${pkg.version} doesn't match desired publish version!`);
-            cli_ux_1.default.action.stop(chalk_1.default.red(`version doesn't match version ${version}`));
-            throw new Error(`Version in package.json doesn't match desired published version`);
-        }
-        if (!matchedPackage) {
-            cli_ux_1.default.action.stop(`${chalk_1.default.green('new package')}`);
-            cli_ux_1.default.action.start(`publish new package ${pkg.name}@${pkg.version} from ${pkg.jsonPath}`, undefined, { stdout: true });
-            try {
-                await this.publishPackage(pkg);
+    checkPackageCanPublish(pkg, allPackages, version, retries) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.log('');
+            ux.action.start(`${pkg.name}@${pkg.version}`, undefined, { stdout: true });
+            const matchedPackage = allPackages.value.find(azurePackage => azurePackage.name === pkg.name);
+            if (pkg.version !== version) {
+                this.warn(`${pkg.name}@${pkg.version} doesn't match desired publish version!`);
+                ux.action.stop(chalk.red(`version doesn't match version ${version}`));
+                throw new Error(`Version in package.json doesn't match desired published version`);
             }
-            catch (err) {
-                if (err instanceof Error && err.message.includes('subprocess error exit')) {
-                    // Check if the error message contains 'subprocess error exit'
-                    // Extract the HTTP status code from the error message
-                    const statusCodeMatch = /\d{3}/.exec(err.message);
-                    const statusCode = statusCodeMatch ? parseInt(statusCodeMatch[0], 10) : null;
-                    if (statusCode && (statusCode >= 400 && statusCode < 600)) {
-                        for (let i = 0; i < retries - 1; i++) {
-                            await this.publishPackage(pkg);
+            if (!matchedPackage) {
+                ux.action.stop(`${chalk.green('new package')}`);
+                ux.action.start(`publish new package ${pkg.name}@${pkg.version} from ${pkg.jsonPath}`, undefined, { stdout: true });
+                try {
+                    yield this.publishPackage(pkg);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (error) {
+                    if (error instanceof Error && error.message.includes('subprocess error exit')) {
+                        // Check if the error message contains 'subprocess error exit'
+                        // Extract the HTTP status code from the error message
+                        const statusCodeMatch = /\d{3}/.exec(error.message);
+                        const statusCode = statusCodeMatch ? Number.parseInt(statusCodeMatch[0], 10) : null;
+                        if (statusCode && (statusCode >= 400 && statusCode < 600)) {
+                            for (let i = 0; i < retries - 1; i++) {
+                                yield this.publishPackage(pkg);
+                            }
                         }
                     }
                 }
+                ux.action.stop(`${chalk.green('done')}`);
+                return true;
+            }
+            const matchVersion = matchedPackage.versions.find(azurePackageVersion => azurePackageVersion.version === pkg.version);
+            if (!matchVersion) {
+                ux.action.stop(`${chalk.yellow('version missing')}`);
+                ux.action.start(`publish new version ${pkg.name}@${pkg.version} from ${pkg.jsonPath}`, undefined, { stdout: true });
+                yield this.publishPackage(pkg);
+                ux.action.stop(`${chalk.green('done')}`);
+                return true;
             }
-            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
-            return true;
-        }
-        let matchVersion = matchedPackage.versions.find(azurePackageVersion => azurePackageVersion.version === pkg.version);
-        if (!matchVersion) {
-            cli_ux_1.default.action.stop(`${chalk_1.default.yellow('version missing')}`);
-            cli_ux_1.default.action.start(`publish new version ${pkg.name}@${pkg.version} from ${pkg.jsonPath}`, undefined, { stdout: true });
-            await this.publishPackage(pkg);
-            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
-            return true;
-        }
-        this.warn(`${pkg.name}@${pkg.version} already exists`);
-        cli_ux_1.default.action.stop(`${chalk_1.default.blue('skipping')}`);
-        return false;
+            this.warn(`${pkg.name}@${pkg.version} already exists`);
+            ux.action.stop(`${chalk.blue('skipping')}`);
+            return false;
+        });
     }
-    async publishPackages(packages, allPackages, version, retries) {
-        let errorCount = 0;
-        this.log(`publishing ${packages.length} packages:`);
-        this.log(packages.map(pkg => pkg.name).toString());
-        for (const pkg of packages) {
-            try {
-                await this.checkPackageCanPublish(pkg, allPackages, version, retries);
+    publishPackages(packages, allPackages, version, retries) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let errorCount = 0;
+            this.log(`publishing ${packages.length} packages:`);
+            this.log(packages.map(pkg => pkg.name).toString());
+            for (const pkg of packages) {
+                try {
+                    yield this.checkPackageCanPublish(pkg, allPackages, version, retries);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (error) {
+                    this.warn(error.message);
+                    errorCount++;
+                    continue;
+                }
             }
-            catch (err) {
-                this.warn(err.message);
-                errorCount++;
-                continue;
+            if (errorCount > 0) {
+                throw new Error(`${errorCount} with Errors!`);
             }
-        }
-        if (errorCount > 0) {
-            throw new Error(`${errorCount} with Errors!`);
-        }
+        });
     }
-    async run() {
-        try {
-            const { flags } = this.parse(NpmPublish);
-            let npmContext = new npm_1.default();
-            cli_ux_1.default.action.start('Parsing packages to check', undefined, { stdout: true });
-            const packages = await npmContext.packageList(flags.package, flags.exclude, this);
-            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
-            cli_ux_1.default.action.start('Getting list of published packages', undefined, { stdout: true });
-            const allPackages = JSON.parse(await npmContext.getAllNpmPackages(flags.pat));
-            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
-            await this.publishPackages(packages, allPackages, flags.version, flags.retry);
-            cli_ux_1.default.action.stop('success');
-        }
-        catch (err) {
-            cli_ux_1.default.action.stop('error');
-            this.error(`${err.message}`);
-        }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { flags } = yield this.parse(NpmPublish);
+                const npmContext = new NpmContext();
+                ux.action.start('Parsing packages to check', undefined, { stdout: true });
+                const packages = yield npmContext.packageList(this, flags.package, flags.exclude);
+                ux.action.stop(`${chalk.green('done')}`);
+                ux.action.start('Getting list of published packages', undefined, { stdout: true });
+                // eslint-disable-next-line unicorn/no-await-expression-member
+                const allPackages = JSON.parse((yield npmContext.getAllNpmPackages(flags.pat)).data);
+                ux.action.stop(`${chalk.green('done')}`);
+                yield this.publishPackages(packages, allPackages, flags.version, flags.retry);
+                ux.action.stop('success');
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                ux.action.stop('error');
+                this.error(`${error.message}`);
+            }
+        });
     }
 }
-exports.default = NpmPublish;
 NpmPublish.description = 'Publish npm packages';
 NpmPublish.usage = 'npm:publish [options]';
 NpmPublish.examples = [
     '$ ops npm:publish -v 15.0.0',
     '$ ops npm:publish -v 15.0.0',
     '$ ops npm:publish -p @adinsure-tooling/* -v 15.0.0',
-    '$ ops npm:publish -p @adinsure-tooling/* -x @adisure-tooling/studio-services -v 6.0.0'
+    '$ ops npm:publish -p @adinsure-tooling/* -x @adisure-tooling/studio-services -v 6.0.0',
 ];
 NpmPublish.flags = {
-    package: command_1.flags.string({
+    package: Flags.string({
         char: 'p',
         description: 'package name filter you want to check',
-        multiple: true
+        multiple: true,
     }),
-    exclude: command_1.flags.string({
+    exclude: Flags.string({
         char: 'x',
         description: 'exclude packages from filter',
-        multiple: true
+        multiple: true,
     }),
-    version: command_1.flags.string({
+    version: Flags.string({
         char: 'v',
         description: 'version we want to check if published',
-        required: true
+        required: true,
     }),
-    pat: command_1.flags.string({
+    pat: Flags.string({
         description: 'PAT token or AZURE_DEVOPS_EXT_PAT environment variable',
-        env: 'AZURE_DEVOPS_EXT_PAT'
+        env: 'AZURE_DEVOPS_EXT_PAT',
     }),
-    retry: command_1.flags.integer({
+    retry: Flags.integer({
         description: 'Number of npm publishing retries in case of 4xx or 5xx http errors',
-        default: 3
+        default: 3,
     }),
 };
+export default NpmPublish;

package/lib/commands/nuget/dependency-update.d.ts

@@ -1,21 +1,26 @@
-import { flags } from '@oclif/command';
-import CommandBase from '../../command.base';
-export default class NuGetDependencyUpdate extends CommandBase {
+import { Command } from '@oclif/core';
+export default class NuGetDependencyUpdate extends Command {
     static description: string;
     static usage: string;
     static examples: string[];
     static args: {
-        name: string;
-        required: boolean;
-        description: string;
-    }[];
+        version: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
     static flags: {
-        filter: flags.IOptionFlag<string>;
-        exclude: flags.IOptionFlag<string[]>;
+        filter: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        exclude: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
     /**
      * Update dependencies in csproj files for @adinsure packages
+     * @param
+     */
+    /**
+     * Update dependencies in csproj files for @adinsure packages
+     * @param {string} newVersion New version to update to
+     * @param {NpmPackage[]} packages Packages to update
+     * @param {string[]} filter Regular expressions filter for packages
+     * @returns {Prmoise<void>} Void Promise
      */
-    updateDependencies(newVersion: string, filter: string | undefined, packages: string[]): Promise<void>;
+    updateDependencies(newVersion: string, packages: string[], filter?: string): Promise<void>;
     run(): Promise<undefined>;
 }