@oclif/plugin-test-esbuild 0.5.131 → 0.5.133

package/README.md

@@ -17,7 +17,7 @@ $ npm install -g @oclif/plugin-test-esbuild
 $ bundle COMMAND
 running command...
 $ bundle (--version)
-@oclif/plugin-test-esbuild/0.5.131 linux-x64 node-v24.14.1
+@oclif/plugin-test-esbuild/0.5.133 linux-x64 node-v24.14.1
 $ bundle --help [COMMAND]
 USAGE
   $ bundle COMMAND

package/dist/{chunk-PVEL6G63.js → chunk-23RHKACP.js}

@@ -1,6 +1,6 @@
 import {
   require_lib
-} from "./chunk-6SHF5RLP.js";
+} from "./chunk-EKTKY2AC.js";
 import {
   __toESM,
   init_cjs_shims

package/dist/{chunk-RMTJQRRJ.js → chunk-BZ7WUEUW.js}

@@ -1,6 +1,6 @@
 import {
   require_lib
-} from "./chunk-6SHF5RLP.js";
+} from "./chunk-EKTKY2AC.js";
 import {
   __toESM,
   init_cjs_shims

package/dist/{chunk-6SHF5RLP.js → chunk-EKTKY2AC.js}

@@ -254,7 +254,7 @@ var require_package = __commonJS({
     module.exports = {
       name: "@oclif/core",
       description: "base library for oclif CLIs",
-      version: "4.10.5",
+      version: "4.11.0",
       author: "Salesforce",
       bugs: "https://github.com/oclif/core/issues",
       dependencies: {
@@ -311,7 +311,7 @@ var require_package = __commonJS({
         madge: "^6.1.0",
         mocha: "^11.7.5",
         nyc: "^15.1.0",
-        prettier: "^3.8.1",
+        prettier: "^3.8.3",
         shx: "^0.4.0",
         sinon: "^18",
         "ts-node": "^10.9.2",
@@ -224236,7 +224236,7 @@ var require_errors2 = __commonJS({
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.FailedFlagValidationError = exports.ArgInvalidOptionError = exports.FlagInvalidOptionError = exports.NonExistentFlagsError = exports.UnexpectedArgsError = exports.RequiredArgsError = exports.InvalidArgsSpecError = exports.CLIParseError = exports.CLIError = void 0;
+    exports.ViolatedFlagConstraintError = exports.FailedFlagValidationError = exports.ArgInvalidOptionError = exports.FlagInvalidOptionError = exports.NonExistentFlagsError = exports.UnexpectedArgsError = exports.RequiredArgsError = exports.InvalidArgsSpecError = exports.CLIParseError = exports.CLIError = void 0;
     var cache_1 = __importDefault(require_cache());
     var errors_1 = require_errors();
     var util_1 = require_util();
@@ -224345,6 +224345,17 @@ Note: ${flags} allow${flagsWithMultiple.length === 1 ? "s" : ""} multiple values
       }
     };
     exports.FailedFlagValidationError = FailedFlagValidationError;
+    var ViolatedFlagConstraintError = class extends CLIParseError {
+      constructor({ exit, failed, parse }) {
+        const reasons = failed.map((r) => r.reason);
+        const deduped = (0, util_1.uniq)(reasons);
+        const errString = deduped.length === 1 ? "error" : "errors";
+        const message = `The following ${errString} occurred:
+ ${(0, theme_1.colorize)("dim", deduped.join("\n"))}`;
+        super({ exit: cache_1.default.getInstance().get("exitCodes")?.violatedFlagConstraint ?? exit, message, parse });
+      }
+    };
+    exports.ViolatedFlagConstraintError = ViolatedFlagConstraintError;
   }
 });
 
@@ -224940,6 +224951,18 @@ var require_validate = __commonJS({
             parse
           });
       }
+      function validateConstraints() {
+        if (parse.input.constraints) {
+          const validations = parse.input.constraints.map((c) => c._evaluateAgainstFlags(parse.output.flags));
+          const failed = validations.filter((v) => v.status === "failed");
+          if (failed.length > 0) {
+            throw new errors_1.ViolatedFlagConstraintError({
+              failed,
+              parse
+            });
+          }
+        }
+      }
       async function resolveFlags(flags) {
         if (cachedResolvedFlags)
           return cachedResolvedFlags;
@@ -225076,7 +225099,8 @@ var require_validate = __commonJS({
         });
       }
       validateArgs();
-      return validateFlags();
+      await validateFlags();
+      validateConstraints();
     }
   }
 });
@@ -225139,6 +225163,7 @@ var require_parser = __commonJS({
         "--": options["--"],
         args: options.args ?? {},
         argv,
+        constraints: options.constraints,
         context: options.context,
         flags: options.flags ?? {},
         strict: options.strict !== false
@@ -225225,6 +225250,7 @@ var require_command2 = __commonJS({
       /** An order-dependent object of arguments for the command */
       static args = {};
       static baseFlags;
+      static constraints;
       /**
        * Emit deprecation warning when a command alias is used
        */
@@ -225485,6 +225511,597 @@ var require_command2 = __commonJS({
   }
 });
 
+// node_modules/@oclif/core/lib/constraints.js
+var require_constraints = __commonJS({
+  "node_modules/@oclif/core/lib/constraints.js"(exports) {
+    "use strict";
+    init_cjs_shims();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.flag = flag;
+    exports.flags = flags;
+    exports.combinationOf = combinationOf;
+    function flag(flagName) {
+      return new ConstraintImpl([flagName]);
+    }
+    function flags(...flagNames) {
+      return new ConstraintImpl(flagNames);
+    }
+    function combinationOf(...flagNames) {
+      return {
+        flags: flagNames,
+        type: "all"
+      };
+    }
+    var ConstraintImpl = class {
+      /**
+       * No-op chain property allowing constraints to be more human-readable.
+       *
+       * @example
+       * flags('foo', 'bar').are.mutuallyExclusive()
+       */
+      are = this;
+      /**
+       * No-op chain property allowing constraints to be more human-readable.
+       *
+       * @example
+       * flag('foo').is.dependentOn('bar')
+       */
+      is = this;
+      constrainedFlags;
+      constraintApplicatorFunctionHolder = new ConstraintApplicatorFunctionHolder();
+      topLevelCondition;
+      underConstructionCondition;
+      constructor(constrainedFlags) {
+        this.constrainedFlags = constrainedFlags;
+      }
+      /**
+       * Chain property allowing constraint conditions to be combined with logical AND.
+       *
+       * By default, logical operators are evaluated left-to-right, but groups can be created with additional {@code when}/{@code unless} clauses.
+       *
+       * @example <caption> when someFn returns true AND someOtherFn returns true, using --foo requires --bar to be used as well.</caption>
+       * flag('foo').is.dependentOn('bar').when.thisIsTrue(someFn).and.thisIsTrue(someOtherFn)
+       *
+       * @example <caption>--foo requires --bar when (fnA returns true AND fnB returns true) OR fnC returns true</caption>
+       * flag('foo').is.dependentOn('bar').when.thisIsTrue(fnA).and.thisIsTrue(fnB).or.thisIsTrue(fnC)
+       *
+       * @example <caption>--foo requires --bar when fnA returns true AND (fnB returns true OR fnC returns true)</caption>
+       * flag('foo').is.dependentOn('bar').when.thisIsTrue(fnA).and.when.thisIsTrue(fnB).or.thisIsTrue(fnC)
+       */
+      get and() {
+        if (this.topLevelCondition === void 0) {
+          throw new Error(`Misconfigured constraint on ${createFlagString(this.constrainedFlags)}: 'and' requires a 'when' or 'unless'.`);
+        }
+        if (this.underConstructionCondition) {
+          throw new Error(`Misconfigured constraint on ${createFlagString(this.constrainedFlags)}: 'and' cannot directly follow '${this.underConstructionCondition.getName()}'`);
+        }
+        this.topLevelCondition = new AndCondition(this.topLevelCondition);
+        this.underConstructionCondition = this.topLevelCondition;
+        return this;
+      }
+      /**
+       * Chain property allowing constraint conditions to be combined with logical OR.
+       *
+       * By default, logical operators are evaluated left-to-right, but groups can be created with additional {@code when}/{@code unless} clauses.
+       *
+       * @example <caption> when EITHER someFn OR someOtherFn return true, using --foo requires --bar to be used as well.</caption>
+       * flag('foo').is.dependentOn('bar').when.thisIsTrue(someFn).or.thisIsTrue(someOtherFn)
+       *
+       * @example <caption>--foo requires --bar when (fnA returns true AND fnB returns true) OR fnC returns true</caption>
+       * flag('foo').is.dependentOn('bar').when.thisIsTrue(fnA).and.thisIsTrue(fnB).or.thisIsTrue(fnC)
+       *
+       * @example <caption>--foo requires --bar when fnA returns true AND (fnB returns true OR fnC returns true)</caption>
+       * flag('foo').is.dependentOn('bar').when.thisIsTrue(fnA).and.when.thisIsTrue(fnB).or.thisIsTrue(fnC)
+       *
+       */
+      get or() {
+        if (this.topLevelCondition === void 0) {
+          throw new Error(`Misconfigured constraint on ${createFlagString(this.constrainedFlags)}: 'or' requires a 'when' or 'unless'.`);
+        }
+        if (this.underConstructionCondition) {
+          throw new Error(`Misconfigured constraint on ${createFlagString(this.constrainedFlags)}: 'or' cannot directly follow '${this.underConstructionCondition.getName()}'`);
+        }
+        this.topLevelCondition = new OrCondition(this.topLevelCondition);
+        this.underConstructionCondition = this.topLevelCondition;
+        return this;
+      }
+      /**
+       * Chain property allowing constraints to be conditional upon a certain criterion NOT being met.
+       *
+       * @example
+       * flag('foo').is.dependentOn('bar').unless.thisIsTrue(someFn)
+       */
+      get unless() {
+        const newUnless = new UnlessCondition();
+        if (this.topLevelCondition === void 0) {
+          this.topLevelCondition = newUnless;
+        }
+        if (this.underConstructionCondition === void 0) {
+          this.underConstructionCondition = newUnless;
+        } else if (this.underConstructionCondition instanceof UnaryOpCondition) {
+          this.underConstructionCondition.setCondition(newUnless);
+          this.underConstructionCondition = newUnless;
+        } else if (this.underConstructionCondition instanceof BinaryCondition) {
+          this.underConstructionCondition.setRight(newUnless);
+          this.underConstructionCondition = newUnless;
+        } else {
+          throw new TypeError("UNKNOWN CONDITION TYPE");
+        }
+        return this;
+      }
+      /**
+       * Chain property allowing constraints to be conditional upon a certain criterion being met.
+       *
+       * @example
+       * flag('foo').is.dependentOn('bar').when.thisIsTrue(someFn)
+       */
+      get when() {
+        const newWhen = new WhenCondition();
+        if (this.topLevelCondition === void 0) {
+          this.topLevelCondition = newWhen;
+        }
+        if (this.underConstructionCondition === void 0) {
+          this.underConstructionCondition = newWhen;
+        } else if (this.underConstructionCondition instanceof UnaryOpCondition) {
+          this.underConstructionCondition.setCondition(newWhen);
+          this.underConstructionCondition = newWhen;
+        } else if (this.underConstructionCondition instanceof BinaryCondition) {
+          this.underConstructionCondition.setRight(newWhen);
+          this.underConstructionCondition = newWhen;
+        } else {
+          throw new TypeError("UNKNOWN CONDITION TYPE");
+        }
+        return this;
+      }
+      _evaluateAgainstFlags(flags2) {
+        let conditionSatisfied = false;
+        try {
+          conditionSatisfied = this.topLevelCondition ? this.topLevelCondition.isSatisfied(flags2) : true;
+        } catch (error) {
+          return {
+            name: this.constrainedFlags.join(","),
+            reason: `Error evaluating constraint conditions on ${createFlagString(this.constrainedFlags)}: ${error.message}`,
+            status: "failed",
+            validationFn: "constraintCondition"
+          };
+        }
+        try {
+          const applicationResult = this.constraintApplicatorFunctionHolder.applyConstraintApplicatorFunction(flags2);
+          return {
+            name: this.constrainedFlags.join(","),
+            reason: applicationResult,
+            status: conditionSatisfied && applicationResult !== "" ? "failed" : "success",
+            validationFn: this.constraintApplicatorFunctionHolder.constraintType ?? ""
+          };
+        } catch (error) {
+          return {
+            name: this.constrainedFlags.join(","),
+            reason: `Error evaluating constraint on ${createFlagString(this.constrainedFlags)}: ${error.message}`,
+            status: "failed",
+            validationFn: "constraintApplication"
+          };
+        }
+      }
+      /**
+       * Chain method allowing constraint to be made conditional upon EVERY established criterion being true.
+       *
+       * @example <caption>If --flagA is 'someVal' AND --flagB is 'someOtherVal', then using --foo requires using --bar too</caption>
+       * flag('foo').is.dependentOn('bar').when.allFlagCriteriaSatisfied({
+       *     flagA: (v) => v === 'someVal',
+       *     flagB: (v) => v !== 'someOtherVal'
+       * })
+       *
+       * @param criterionTester An object whose keys are flag names and whose values are functions that accept the
+       * value of that flag and return a boolean.
+       */
+      allFlagCriteriaSatisfied(criterionTester) {
+        if (this.underConstructionCondition === void 0) {
+          throw new Error(`Misconfigured constraint condition on ${createFlagString(this.constrainedFlags)}: allFlagCriteriaSatisfied must immediately follow a when/unless/and/or`);
+        } else if (this.underConstructionCondition instanceof UnaryOpCondition) {
+          this.underConstructionCondition.setCondition(new AllFlagCriteriaSatisfiedCondition(criterionTester));
+          this.underConstructionCondition = void 0;
+        } else if (this.underConstructionCondition instanceof BinaryCondition) {
+          this.underConstructionCondition.setRight(new AllFlagCriteriaSatisfiedCondition(criterionTester));
+          this.underConstructionCondition = void 0;
+        } else {
+          throw new TypeError("UNKNOWN CONDITION TYPE");
+        }
+        return this;
+      }
+      /**
+       * Chain method allowing constraint to be made conditional upon ANY established criterion being true.
+       *
+       * @example <caption>If --flagA is 'someVal' OR --flagB is 'someOtherVal', then using --foo requires using --bar too</caption>
+       * flag('foo').is.dependentOn('bar').when.anyFlagCriterionSatisfied({
+       *     flagA: (v) => v === 'someVal',
+       *     flagB: (v) => v !== 'someOtherVal'
+       * })
+       *
+       * @param criterionTester An object whose keys are flag names and whose values are functions that accept the
+       * value of that flag and return a boolean.
+       */
+      anyFlagCriterionSatisfied(criterionTester) {
+        if (this.underConstructionCondition === void 0) {
+          throw new Error(`Misconfigured constraint condition on ${createFlagString(this.constrainedFlags)}: anyFlagCriterionSatisfied must immediately follow a when/unless/and/or`);
+        } else if (this.underConstructionCondition instanceof UnaryOpCondition) {
+          this.underConstructionCondition.setCondition(new AnyFlagCriterionSatisfiedCondition(criterionTester));
+          this.underConstructionCondition = void 0;
+        } else if (this.underConstructionCondition instanceof BinaryCondition) {
+          this.underConstructionCondition.setRight(new AnyFlagCriterionSatisfiedCondition(criterionTester));
+          this.underConstructionCondition = void 0;
+        } else {
+          throw new TypeError("UNKNOWN CONDITION TYPE");
+        }
+        return this;
+      }
+      /**
+       * Chain method allowing the constrained flags to require the presence of at least one of the flags specified here.
+       *
+       * @example <caption>If --foo is used, then EITHER --bar OR --baz must be used as well</caption>
+       * flag('foo').is.dependentOn('bar', 'baz')
+       *
+       * @example <caption>If --foo is used, then BOTH --bar AND --baz must be used as well</caption>
+       * flag('foo').is.dependentOn(combinationOf('bar', 'baz'))
+       *
+       * @example <caption>If --foo is used, then EITHER --bar OR the combination of --baz1 and --baz2 must be used as well</caption>
+       * flag('foo').is.dependentOn('bar', combinationOf('baz1', 'baz2'))
+       *
+       * @param dependencyFlagGroups
+       */
+      dependentOn(...dependencyFlagGroups) {
+        this.constraintApplicatorFunctionHolder.setConstraintApplicator("dependentOn", (flags2) => {
+          const foundConstraintFlags = filterFlagsPresentInInput(this.constrainedFlags, flags2);
+          if (foundConstraintFlags.length === 0) {
+            return "";
+          }
+          for (const dependencyFlagGroup of dependencyFlagGroups) {
+            if (typeof dependencyFlagGroup === "string") {
+              if (dependencyFlagGroup in flags2 && flags2[dependencyFlagGroup] !== void 0) {
+                return "";
+              }
+            } else {
+              const foundFlagsInDependencyGroup = filterFlagsPresentInInput(dependencyFlagGroup.flags, flags2);
+              if (foundFlagsInDependencyGroup.length === dependencyFlagGroup.flags.length) {
+                return "";
+              }
+            }
+          }
+          const multipleConstrainedFlags = this.constrainedFlags.length > 1;
+          const header = multipleConstrainedFlags ? `Flags ${createFlagString(this.constrainedFlags)} require` : `Flag ${createFlagString(this.constrainedFlags)} requires`;
+          return `${header} at least one of the following${this.topLevelCondition ? " under current circumstances:" : ":"} ${createFlagString(dependencyFlagGroups)}.`;
+        });
+        return this;
+      }
+      /**
+       * Chain method allowing the constrained flags to be made exclusive with the flags provided here.
+       *
+       * @example <caption>Neither --foo1 nor --foo2 can be used with --bar OR --baz</caption>
+       * flags('foo1', 'foo2').are.exclusiveWith('bar', 'baz')
+       *
+       * @example <caption>Neither --foo1 nor --foo2 can be used with the combination of --bar and --baz, but may be used with --bar or --baz separately</caption>
+       * flags('foo1', 'foo2').are.exclusiveWith(combinationOf('bar', 'baz'))
+       *
+       * @example <caption>Neither --foo1 nor --foo2 can be used with --bar, or with the combination of --baz1 and --baz2</caption>
+       * flags('foo1', 'foo2').are.exclusiveWith('bar', combinationOf('baz1', 'baz2'))
+       *
+       * @param exclusionFlagGroups
+       */
+      exclusiveWith(...exclusionFlagGroups) {
+        this.constraintApplicatorFunctionHolder.setConstraintApplicator("exclusiveWith", (flags2) => {
+          const foundConstraintFlags = filterFlagsPresentInInput(this.constrainedFlags, flags2);
+          if (foundConstraintFlags.length === 0) {
+            return "";
+          }
+          let exclusionGroupFound = false;
+          for (const exclusionFlagGroup of exclusionFlagGroups) {
+            if (typeof exclusionFlagGroup === "string") {
+              if (exclusionFlagGroup in flags2 && flags2[exclusionFlagGroup] !== void 0) {
+                exclusionGroupFound = true;
+                break;
+              }
+            } else {
+              const foundFlagsInExclusionGroup = filterFlagsPresentInInput(exclusionFlagGroup.flags, flags2);
+              if (foundFlagsInExclusionGroup.length === exclusionFlagGroup.flags.length) {
+                exclusionGroupFound = true;
+                break;
+              }
+            }
+          }
+          if (!exclusionGroupFound) {
+            return "";
+          }
+          const multipleConstrainedFlags = this.constrainedFlags.length > 1;
+          const header = multipleConstrainedFlags ? "Flags" : "Flag";
+          return `${header} ${createFlagString(this.constrainedFlags)} cannot be used with any of the following${this.topLevelCondition ? " under current circumstances:" : ":"} ${createFlagString(exclusionFlagGroups)}.`;
+        });
+        return this;
+      }
+      /**
+       * Establish a group of flags as mutually dependent, meaning that they must either be used together or not at all.
+       *
+       * @example <caption>--foo cannot be used without --bar, and vice versa</caption>
+       * flags('foo', 'bar').are.mutuallyDependent()
+       */
+      mutuallyDependent() {
+        this.constraintApplicatorFunctionHolder.setConstraintApplicator("mutuallyDependent", (flags2) => {
+          const foundFlags = filterFlagsPresentInInput(this.constrainedFlags, flags2);
+          if (foundFlags.length === 0 || foundFlags.length === this.constrainedFlags.length) {
+            return "";
+          }
+          return `The following flags are mutually dependent${this.topLevelCondition ? " under current circumstances:" : ":"} ${createFlagString(this.constrainedFlags)}. Found only ${createFlagString(foundFlags)}.`;
+        });
+        return this;
+      }
+      /**
+       * Establish a group of flags as mutually exclusive, meaning that at most one of them can be used simultaneously.
+       *
+       * @example <caption>--foo and --bar cannot both be used at the same time</caption>
+       * flags('foo', 'bar').are.mutuallyExclusive()
+       */
+      mutuallyExclusive() {
+        this.constraintApplicatorFunctionHolder.setConstraintApplicator("mutuallyExclusive", (flags2) => {
+          const foundFlags = filterFlagsPresentInInput(this.constrainedFlags, flags2);
+          if (foundFlags.length <= 1) {
+            return "";
+          }
+          return `The following flags are mutually exclusive${this.topLevelCondition ? " under current circumstances:" : ":"} ${createFlagString(this.constrainedFlags)}. Found: ${createFlagString(foundFlags)}.`;
+        });
+        return this;
+      }
+      /**
+       * Establish a group of flags as being collectively required.
+       *
+       * @example <caption>--foo and --bar are both always required</caption>
+       * flags('foo', 'bar').are.requiredAll()
+       */
+      requiredAll() {
+        this.constraintApplicatorFunctionHolder.setConstraintApplicator("requiredAll", (flags2) => {
+          const foundFlags = filterFlagsPresentInInput(this.constrainedFlags, flags2);
+          if (foundFlags.length === this.constrainedFlags.length) {
+            return "";
+          }
+          const requirement = this.constrainedFlags.length > 1 ? "These flags are required" : "This flag is required";
+          const findings = foundFlags.length > 0 ? `Found only: ${createFlagString(foundFlags)}.` : "Found none.";
+          return `${requirement}${this.topLevelCondition ? " under current circumstances:" : ":"} ${createFlagString(this.constrainedFlags)}. ${findings}`;
+        });
+        return this;
+      }
+      /**
+       * Establish that at least one of the constrained flags must always be used.
+       *
+       * @example <caption>Must use at least one of --foo, --bar, or --baz</caption>
+       * flags('foo', 'bar', 'baz').are.requiredAny()
+       */
+      requiredAny() {
+        this.constraintApplicatorFunctionHolder.setConstraintApplicator("requiredAny", (flags2) => {
+          const foundFlags = filterFlagsPresentInInput(this.constrainedFlags, flags2);
+          if (foundFlags.length > 0) {
+            return "";
+          }
+          return `Must provide at least one of these flags${this.topLevelCondition ? " under current circumstances:" : ":"} ${createFlagString(this.constrainedFlags)}.`;
+        });
+        return this;
+      }
+      /**
+       * Establish that at least N of the specified flags must be used.
+       *
+       * @example <caption>At least 2 of the 3 flags --foo, --bar, and --baz must be used</caption>
+       * flags('foo', 'bar', 'baz').are.requiredAtLeastN(2)
+       *
+       * @param n
+       */
+      requiredAtLeastN(n) {
+        this.constraintApplicatorFunctionHolder.setConstraintApplicator(`requiredAtLeast${n}`, (flags2) => required(n, "AT_LEAST_N", this.constrainedFlags, flags2, this.topLevelCondition !== void 0));
+        return this;
+      }
+      /**
+       * Establish that at most N of the specified flags must be used.
+       *
+       * @example <caption>No more than 2 of the 3 flags --foo, --bar, and --baz may be used</caption>
+       * flags('foo', 'bar', 'baz').are.requiredAtMostN(2)
+       *
+       * @param n
+       */
+      requiredAtMostN(n) {
+        this.constraintApplicatorFunctionHolder.setConstraintApplicator(`requiredAtMost${n}`, (flags2) => required(n, "AT_MOST_N", this.constrainedFlags, flags2, this.topLevelCondition !== void 0));
+        return this;
+      }
+      /**
+       * Establish that exactly N of the specified flags must be used.
+       *
+       * @example <caption>Exactly 2 of the 3 flags --foo, --bar, and --baz must be used</caption>
+       * flags('foo', 'bar', 'baz').are.requiredExactlyN(2)
+       *
+       * @param n
+       */
+      requiredExactlyN(n) {
+        this.constraintApplicatorFunctionHolder.setConstraintApplicator(`requiredExactly${n}`, (flags2) => required(n, "EXACTLY_N", this.constrainedFlags, flags2, this.topLevelCondition !== void 0));
+        return this;
+      }
+      /**
+       * Chain method allowing the constraint to be made contingent on the return of a method that accepts all flags.
+       *
+       * @example <caption>--foo1 and --foo2 are required if --bar is equal to --baz</caption>
+       * flags('foo1', 'foo2').are.requiredAll().when.thisIsTrue((flags) => flags.bar === flags.baz)
+       *
+       * @param flagTester A method that accepts the flag values mapped by their name, and returns a boolean
+       */
+      thisIsTrue(flagTester) {
+        if (this.underConstructionCondition === void 0) {
+          throw new Error(`Misconfigured constraint condition on ${createFlagString(this.constrainedFlags)}: thisIsTrue must immediately follow a when/unless/and/or`);
+        } else if (this.underConstructionCondition instanceof UnaryOpCondition) {
+          this.underConstructionCondition.setCondition(new ThisIsTrueCondition(flagTester));
+          this.underConstructionCondition = void 0;
+        } else if (this.underConstructionCondition instanceof BinaryCondition) {
+          this.underConstructionCondition.setRight(new ThisIsTrueCondition(flagTester));
+          this.underConstructionCondition = void 0;
+        } else {
+          throw new TypeError("UNKNOWN CONDITION TYPE");
+        }
+        return this;
+      }
+    };
+    var ConstraintApplicatorFunctionHolder = class {
+      constraintType;
+      constraintApplicatorFunction;
+      applyConstraintApplicatorFunction(flags2) {
+        return (this.constraintApplicatorFunction ?? function() {
+          return "";
+        })(flags2);
+      }
+      setConstraintApplicator(constraintType, constraintFunction) {
+        if (this.constraintApplicatorFunction) {
+          throw new Error(`Misconfigured Constraint: Cannot apply multiple kinds of constraint within one statement: ${this.constraintType}, ${constraintType}. Use multiple constraint expressions instead.`);
+        }
+        this.constraintType = constraintType;
+        this.constraintApplicatorFunction = constraintFunction;
+      }
+    };
+    var Requirement = {
+      AT_LEAST_N: {
+        fn: (n, other) => other >= n,
+        label: "at least"
+      },
+      AT_MOST_N: {
+        fn: (n, other) => other <= n,
+        label: "at most"
+      },
+      EXACTLY_N: {
+        fn: (n, other) => other === n,
+        label: "exactly"
+      }
+    };
+    function required(n, requirementType, soughtFlags, providedFlags, hasConditions) {
+      const foundFlags = filterFlagsPresentInInput(soughtFlags, providedFlags);
+      if (Requirement[requirementType].fn(n, foundFlags.length)) {
+        return "";
+      }
+      return `Must provide ${Requirement[requirementType].label} ${n} of the following${hasConditions ? " under current circumstances:" : ":"} ${createFlagString(soughtFlags)}. Found ${foundFlags.length}.`;
+    }
+    function filterFlagsPresentInInput(flagsToSeek, flags2) {
+      return flagsToSeek.filter((f) => f in flags2 && flags2[f] !== void 0);
+    }
+    function createFlagString(flags2) {
+      const processedGroups = flags2.map((f) => {
+        if (typeof f === "string") {
+          return `--${f}`;
+        }
+        return `combination of ${f.flags.map((f2) => `--${f2}`).join(" and ")}`;
+      });
+      return processedGroups.join(", ");
+    }
+    var Condition = class {
+    };
+    var UnaryOpCondition = class extends Condition {
+      condition;
+      setCondition(condition) {
+        if (this.condition) {
+          throw new Error(`Duplicate conditions applied to '${this.getName()}' clause: '${this.condition.getName()}' and '${condition.getName()}'.`);
+        }
+        this.condition = condition;
+      }
+    };
+    var WhenCondition = class extends UnaryOpCondition {
+      getName() {
+        return "when";
+      }
+      isSatisfied(flags2) {
+        if (this.condition) {
+          return this.condition.isSatisfied(flags2);
+        }
+        throw new Error("'when' expression without any conditions");
+      }
+    };
+    var UnlessCondition = class extends UnaryOpCondition {
+      getName() {
+        return "unless";
+      }
+      isSatisfied(flags2) {
+        if (this.condition) {
+          return !this.condition.isSatisfied(flags2);
+        }
+        throw new Error("'unless' expression without any conditions");
+      }
+    };
+    var AllFlagCriteriaSatisfiedCondition = class extends Condition {
+      tester;
+      constructor(tester) {
+        super();
+        this.tester = tester;
+      }
+      getName() {
+        return "allFlagCriteriaSatisfied";
+      }
+      isSatisfied(flags2) {
+        for (const testedFlag of Object.keys(this.tester)) {
+          if (!this.tester[testedFlag](flags2[testedFlag])) {
+            return false;
+          }
+        }
+        return true;
+      }
+    };
+    var AnyFlagCriterionSatisfiedCondition = class extends Condition {
+      tester;
+      constructor(tester) {
+        super();
+        this.tester = tester;
+      }
+      getName() {
+        return "anyFlagCriterionSatisfied";
+      }
+      isSatisfied(flags2) {
+        for (const testedFlag of Object.keys(this.tester)) {
+          if (this.tester[testedFlag](flags2[testedFlag])) {
+            return true;
+          }
+        }
+        return false;
+      }
+    };
+    var ThisIsTrueCondition = class extends Condition {
+      tester;
+      constructor(tester) {
+        super();
+        this.tester = tester;
+      }
+      getName() {
+        return "thisIsTrue";
+      }
+      isSatisfied(flags2) {
+        return this.tester(flags2);
+      }
+    };
+    var BinaryCondition = class extends Condition {
+      left;
+      right;
+      constructor(left) {
+        super();
+        this.left = left;
+      }
+      setRight(right) {
+        this.right = right;
+      }
+    };
+    var AndCondition = class extends BinaryCondition {
+      getName() {
+        return "and";
+      }
+      isSatisfied(flags2) {
+        return this.left.isSatisfied(flags2) && (this.right ? this.right.isSatisfied(flags2) : true);
+      }
+    };
+    var OrCondition = class extends BinaryCondition {
+      getName() {
+        return "or";
+      }
+      isSatisfied(flags2) {
+        return this.left.isSatisfied(flags2) || (this.right ? this.right.isSatisfied(flags2) : false);
+      }
+    };
+  }
+});
+
 // node_modules/@oclif/core/lib/flush.js
 var require_flush = __commonJS({
   "node_modules/@oclif/core/lib/flush.js"(exports) {
@@ -225703,7 +226320,7 @@ var require_lib = __commonJS({
       };
     })();
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.ux = exports.toStandardizedId = exports.toConfiguredId = exports.settings = exports.Performance = exports.Parser = exports.ModuleLoader = exports.getLogger = exports.Interfaces = exports.loadHelpClass = exports.HelpBase = exports.Help = exports.CommandHelp = exports.flush = exports.Flags = exports.execute = exports.handle = exports.Errors = exports.Plugin = exports.Config = exports.Command = exports.Args = void 0;
+    exports.ux = exports.toStandardizedId = exports.toConfiguredId = exports.settings = exports.Performance = exports.Parser = exports.ModuleLoader = exports.getLogger = exports.Interfaces = exports.loadHelpClass = exports.HelpBase = exports.Help = exports.CommandHelp = exports.flush = exports.Flags = exports.execute = exports.handle = exports.Errors = exports.Constraints = exports.Plugin = exports.Config = exports.Command = exports.Args = void 0;
     var util_1 = require_util();
     function checkCWD() {
       try {
@@ -225742,6 +226359,7 @@ var require_lib = __commonJS({
     Object.defineProperty(exports, "Plugin", { enumerable: true, get: function() {
       return config_1.Plugin;
     } });
+    exports.Constraints = __importStar(require_constraints());
     exports.Errors = __importStar(require_errors());
     var handle_1 = require_handle();
     Object.defineProperty(exports, "handle", { enumerable: true, get: function() {

package/dist/{chunk-TR666ZRS.js → chunk-IO7NG6HL.js}

@@ -1,6 +1,6 @@
 import {
   require_lib
-} from "./chunk-6SHF5RLP.js";
+} from "./chunk-EKTKY2AC.js";
 import {
   __toESM,
   init_cjs_shims

package/dist/{chunk-YFVRENPV.js → chunk-T4PKXBYS.js}

@@ -1,6 +1,6 @@
 import {
   require_lib
-} from "./chunk-6SHF5RLP.js";
+} from "./chunk-EKTKY2AC.js";
 import {
   __toESM,
   init_cjs_shims

package/dist/commands/esbuild.js

@@ -1,7 +1,7 @@
 import {
   ESBuild
-} from "../chunk-PVEL6G63.js";
-import "../chunk-6SHF5RLP.js";
+} from "../chunk-23RHKACP.js";
+import "../chunk-EKTKY2AC.js";
 import "../chunk-YXPP4ZUR.js";
 import "../chunk-RRP6KXWN.js";
 export {

package/dist/commands/hello/index.js

@@ -1,7 +1,7 @@
 import {
   Hello
-} from "../../chunk-YFVRENPV.js";
-import "../../chunk-6SHF5RLP.js";
+} from "../../chunk-T4PKXBYS.js";
+import "../../chunk-EKTKY2AC.js";
 import "../../chunk-YXPP4ZUR.js";
 import "../../chunk-RRP6KXWN.js";
 export {

package/dist/commands/hello/world.js

@@ -1,7 +1,7 @@
 import {
   World
-} from "../../chunk-TR666ZRS.js";
-import "../../chunk-6SHF5RLP.js";
+} from "../../chunk-IO7NG6HL.js";
+import "../../chunk-EKTKY2AC.js";
 import "../../chunk-YXPP4ZUR.js";
 import "../../chunk-RRP6KXWN.js";
 export {

package/dist/hooks/init/init.js

@@ -1,7 +1,7 @@
 import {
   init_default
-} from "../../chunk-RMTJQRRJ.js";
-import "../../chunk-6SHF5RLP.js";
+} from "../../chunk-BZ7WUEUW.js";
+import "../../chunk-EKTKY2AC.js";
 import "../../chunk-YXPP4ZUR.js";
 import "../../chunk-RRP6KXWN.js";
 export {

package/dist/index.js

@@ -1,20 +1,20 @@
 import {
   ESBuild
-} from "./chunk-PVEL6G63.js";
+} from "./chunk-23RHKACP.js";
 import {
   Hello
-} from "./chunk-YFVRENPV.js";
+} from "./chunk-T4PKXBYS.js";
 import {
   World
-} from "./chunk-TR666ZRS.js";
+} from "./chunk-IO7NG6HL.js";
 import {
   init_default
-} from "./chunk-RMTJQRRJ.js";
+} from "./chunk-BZ7WUEUW.js";
 import {
   require_ansis,
   require_lib,
   require_src
-} from "./chunk-6SHF5RLP.js";
+} from "./chunk-EKTKY2AC.js";
 import {
   require_lib as require_lib2
 } from "./chunk-SO2G2ODZ.js";

package/oclif.manifest.json

@@ -475,5 +475,5 @@
       "enableJsonFlag": false
     }
   },
-  "version": "0.5.131"
+  "version": "0.5.133"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oclif/plugin-test-esbuild",
-  "version": "0.5.131",
+  "version": "0.5.133",
   "description": "Bundled plugin for testing",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/plugin-test-esbuild/issues",
@@ -25,7 +25,7 @@
     "chai": "^4",
     "esbuild": "^0.28.0",
     "eslint": "^9.39.4",
-    "eslint-config-oclif": "^6.0.157",
+    "eslint-config-oclif": "^6.0.159",
     "eslint-config-prettier": "^10.1.8",
     "mocha": "^10",
     "oclif": "^4.23.0",