@oclif/core 4.5.6 → 4.7.0

package/lib/help/docopts.js

@@ -165,8 +165,22 @@ class DocOpts {
             if (Array.isArray(flag.dependsOn)) {
                 this.combineElementsToFlag(elementMap, flag.name, flag.dependsOn, ' ');
             }
+            let exclusive;
             if (Array.isArray(flag.exclusive)) {
-                this.combineElementsToFlag(elementMap, flag.name, flag.exclusive, ' | ');
+                exclusive = new Set(flag.exclusive);
+            }
+            if (Array.isArray(flag.combinable)) {
+                const combinableFlags = new Set(flag.combinable);
+                exclusive ??= new Set();
+                for (const item of this.flagList) {
+                    // each flag not in the "combinable" list, is equivalent to an "exclusive" flag
+                    if (flag !== item && !combinableFlags.has(item.name)) {
+                        exclusive.add(item.name);
+                    }
+                }
+            }
+            if (exclusive !== undefined && exclusive.size > 0) {
+                this.combineElementsToFlag(elementMap, flag.name, [...exclusive], ' | ');
             }
         }
         // Since combineElementsToFlag deletes the references in this.flags when it combines

package/lib/interfaces/parser.d.ts

@@ -87,7 +87,7 @@ export type FlagRelationship = string | {
     when: (flags: Record<string, unknown>) => Promise<boolean>;
 };
 export type Relationship = {
-    type: 'all' | 'some' | 'none';
+    type: 'all' | 'some' | 'none' | 'only';
     flags: FlagRelationship[];
 };
 export type Deprecation = {
@@ -138,6 +138,10 @@ export type FlagProps = {
      * List of flags that cannot be used with this flag.
      */
     exclusive?: string[];
+    /**
+     * List of the only flags that can be used with this flag.
+     */
+    combinable?: string[];
     /**
      * Exactly one of these flags must be provided.
      */

package/lib/parser/parse.js

@@ -75,6 +75,7 @@ const validateOptions = (flag, input) => {
         throw new errors_1.FlagInvalidOptionError(flag, input);
     return input;
 };
+const NEGATION = '--no-';
 class Parser {
     input;
     argv;
@@ -299,9 +300,16 @@ class Parser {
             if (tokenLength) {
                 // boolean
                 if (fws.inputFlag.flag.type === 'boolean' && (0, util_1.last)(fws.tokens)?.input) {
+                    const doesNotContainNegation = (i) => {
+                        const possibleNegations = [i.inputFlag.name, ...(i.inputFlag.flag.aliases ?? [])].map((n) => `${NEGATION}${n}`);
+                        const input = (0, util_1.last)(i.tokens)?.input;
+                        if (!input)
+                            return true;
+                        return !possibleNegations.includes(input);
+                    };
                     return {
                         ...fws,
-                        valueFunction: async (i) => parseFlagOrThrowError((0, util_1.last)(i.tokens)?.input !== `--no-${i.inputFlag.name}`, i.inputFlag.flag, this.context, (0, util_1.last)(i.tokens)),
+                        valueFunction: async (i) => parseFlagOrThrowError(doesNotContainNegation(i), i.inputFlag.flag, this.context, (0, util_1.last)(i.tokens)),
                     };
                 }
                 // multiple with custom delimiter
@@ -455,10 +463,14 @@ class Parser {
         if (this.flagAliases[name]) {
             return this.flagAliases[name].name;
         }
-        if (arg.startsWith('--no-')) {
-            const flag = this.booleanFlags[arg.slice(5)];
+        if (arg.startsWith(NEGATION)) {
+            const flag = this.booleanFlags[arg.slice(NEGATION.length)];
             if (flag && flag.allowNo)
                 return flag.name;
+            const flagAlias = this.flagAliases[arg.slice(NEGATION.length)];
+            if (flagAlias && flagAlias.type === 'boolean' && flagAlias.allowNo) {
+                return flagAlias.name;
+            }
         }
     }
     findShortFlag([_, char]) {

package/lib/parser/validate.js

@@ -57,6 +57,7 @@ async function validate(parse) {
                     ...(flag.relationships ? validateRelationships(name, flag) : []),
                     ...(flag.dependsOn ? [validateDependsOn(name, flag.dependsOn)] : []),
                     ...(flag.exclusive ? [validateExclusive(name, flag.exclusive)] : []),
+                    ...(flag.combinable ? [validateCombinable(name, flag.combinable)] : []),
                     ...(flag.exactlyOne ? [validateExactlyOne(name, flag.exactlyOne)] : []),
                 ];
             }
@@ -143,6 +144,29 @@ async function validate(parse) {
         }
         return { ...base, status: 'success' };
     }
+    async function validateCombinable(name, flags) {
+        const base = { name, validationFn: 'validateCombinable' };
+        const combinableFlags = new Set(flags.map((flag) => (typeof flag === 'string' ? flag : flag.name)));
+        const resolved = await resolveFlags(flags);
+        for (const flag of Object.keys(parse.output.flags)) {
+            // do not enforce exclusivity for flags that were defaulted
+            if (parse.output.metadata.flags && parse.output.metadata.flags[flag]?.setFromDefault)
+                continue;
+            if (parse.output.metadata.flags && parse.output.metadata.flags[name]?.setFromDefault)
+                continue;
+            if (flag !== name && parse.output.flags[flag] !== undefined && !combinableFlags.has(flag)) {
+                const formattedFlags = Object.keys(resolved)
+                    .map((f) => `--${f}`)
+                    .join(', ');
+                return {
+                    ...base,
+                    reason: `Only the following can be provided when using --${name}: ${formattedFlags}`,
+                    status: 'failed',
+                };
+            }
+        }
+        return { ...base, status: 'success' };
+    }
     async function validateExactlyOne(name, flags) {
         const base = { name, validationFn: 'validateExactlyOne' };
         const resolved = await resolveFlags(flags);
@@ -195,6 +219,9 @@ async function validate(parse) {
                 case 'none': {
                     return validateExclusive(name, relationship.flags);
                 }
+                case 'only': {
+                    return validateCombinable(name, relationship.flags);
+                }
                 case 'some': {
                     return validateSome(name, relationship.flags);
                 }

package/lib/util/cache-command.js

@@ -20,6 +20,7 @@ async function cacheFlags(cmdFlags, respectNoCacheDefault) {
             aliases: flag.aliases,
             char: flag.char,
             charAliases: flag.charAliases,
+            combinable: flag.combinable,
             dependsOn: flag.dependsOn,
             deprecateAliases: flag.deprecateAliases,
             deprecated: flag.deprecated,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oclif/core",
   "description": "base library for oclif CLIs",
-  "version": "4.5.6",
+  "version": "4.7.0",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/core/issues",
   "dependencies": {