Bump the npm group with 3 updates (#2303)

* ---
updated-dependencies:
- dependency-name: "@typescript-eslint/eslint-plugin"
  dependency-type: direct:development
  update-type: version-update:semver-minor
  dependency-group: npm
- dependency-name: "@typescript-eslint/parser"
  dependency-type: direct:development
  update-type: version-update:semver-minor
  dependency-group: npm
- dependency-name: sinon
  dependency-type: direct:development
  update-type: version-update:semver-major
  dependency-group: npm
...

Signed-off-by: dependabot[bot] <support@github.com>

* Update checked-in dependencies

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

node_modules/sinon/lib/create-sinon-api.js

@@ -25,7 +25,6 @@ module.exports = function createApi(opts = { sinonXhrLib: nise }) {
         restoreObject: require("./sinon/restore-object"),
 
         expectation: require("./sinon/mock-expectation"),
-        defaultConfig: require("./sinon/util/core/default-config"),
 
         // fake timers
         timers: fakeTimers.timers,

node_modules/sinon/lib/sinon/default-behaviors.js

@@ -30,90 +30,64 @@ function throwsException(fake, error, message) {
     }
 }
 
-const SKIP_OPTIONS_FOR_YIELDS = {
-    skipReturn: true,
-    skipThrows: true,
-};
-
-function clear(fake, options) {
-    fake.fakeFn = undefined;
-
-    fake.callsThrough = undefined;
-    fake.callsThroughWithNew = undefined;
-
-    if (!options || !options.skipThrows) {
-        fake.exception = undefined;
-        fake.exceptionCreator = undefined;
-        fake.throwArgAt = undefined;
-    }
-
-    fake.callArgAt = undefined;
-    fake.callbackArguments = undefined;
-    fake.callbackContext = undefined;
-    fake.callArgProp = undefined;
-    fake.callbackAsync = undefined;
-
-    if (!options || !options.skipReturn) {
-        fake.returnValue = undefined;
-        fake.returnValueDefined = undefined;
-        fake.returnArgAt = undefined;
-        fake.returnThis = undefined;
-    }
-
-    fake.resolve = undefined;
-    fake.resolveThis = undefined;
-    fake.resolveArgAt = undefined;
-
-    fake.reject = undefined;
-}
-
 const defaultBehaviors = {
     callsFake: function callsFake(fake, fn) {
-        clear(fake);
-
         fake.fakeFn = fn;
+        fake.exception = undefined;
+        fake.exceptionCreator = undefined;
+        fake.callsThrough = false;
     },
 
     callsArg: function callsArg(fake, index) {
         if (typeof index !== "number") {
             throw new TypeError("argument index is not number");
         }
-        clear(fake);
 
         fake.callArgAt = index;
         fake.callbackArguments = [];
+        fake.callbackContext = undefined;
+        fake.callArgProp = undefined;
+        fake.callbackAsync = false;
+        fake.callsThrough = false;
     },
 
     callsArgOn: function callsArgOn(fake, index, context) {
         if (typeof index !== "number") {
             throw new TypeError("argument index is not number");
         }
-        clear(fake);
 
         fake.callArgAt = index;
         fake.callbackArguments = [];
         fake.callbackContext = context;
+        fake.callArgProp = undefined;
+        fake.callbackAsync = false;
+        fake.callsThrough = false;
     },
 
     callsArgWith: function callsArgWith(fake, index) {
         if (typeof index !== "number") {
             throw new TypeError("argument index is not number");
         }
-        clear(fake);
 
         fake.callArgAt = index;
         fake.callbackArguments = slice(arguments, 2);
+        fake.callbackContext = undefined;
+        fake.callArgProp = undefined;
+        fake.callbackAsync = false;
+        fake.callsThrough = false;
     },
 
     callsArgOnWith: function callsArgWith(fake, index, context) {
         if (typeof index !== "number") {
             throw new TypeError("argument index is not number");
         }
-        clear(fake);
 
         fake.callArgAt = index;
         fake.callbackArguments = slice(arguments, 3);
         fake.callbackContext = context;
+        fake.callArgProp = undefined;
+        fake.callbackAsync = false;
+        fake.callsThrough = false;
     },
 
     usingPromise: function usingPromise(fake, promiseLibrary) {
@@ -121,59 +95,73 @@ const defaultBehaviors = {
     },
 
     yields: function (fake) {
-        clear(fake, SKIP_OPTIONS_FOR_YIELDS);
-
         fake.callArgAt = useLeftMostCallback;
         fake.callbackArguments = slice(arguments, 1);
+        fake.callbackContext = undefined;
+        fake.callArgProp = undefined;
+        fake.callbackAsync = false;
+        fake.fakeFn = undefined;
+        fake.callsThrough = false;
     },
 
     yieldsRight: function (fake) {
-        clear(fake, SKIP_OPTIONS_FOR_YIELDS);
-
         fake.callArgAt = useRightMostCallback;
         fake.callbackArguments = slice(arguments, 1);
+        fake.callbackContext = undefined;
+        fake.callArgProp = undefined;
+        fake.callbackAsync = false;
+        fake.callsThrough = false;
+        fake.fakeFn = undefined;
     },
 
     yieldsOn: function (fake, context) {
-        clear(fake, SKIP_OPTIONS_FOR_YIELDS);
-
         fake.callArgAt = useLeftMostCallback;
         fake.callbackArguments = slice(arguments, 2);
         fake.callbackContext = context;
+        fake.callArgProp = undefined;
+        fake.callbackAsync = false;
+        fake.callsThrough = false;
+        fake.fakeFn = undefined;
     },
 
     yieldsTo: function (fake, prop) {
-        clear(fake, SKIP_OPTIONS_FOR_YIELDS);
-
         fake.callArgAt = useLeftMostCallback;
         fake.callbackArguments = slice(arguments, 2);
+        fake.callbackContext = undefined;
         fake.callArgProp = prop;
+        fake.callbackAsync = false;
+        fake.callsThrough = false;
+        fake.fakeFn = undefined;
     },
 
     yieldsToOn: function (fake, prop, context) {
-        clear(fake, SKIP_OPTIONS_FOR_YIELDS);
-
         fake.callArgAt = useLeftMostCallback;
         fake.callbackArguments = slice(arguments, 3);
         fake.callbackContext = context;
         fake.callArgProp = prop;
+        fake.callbackAsync = false;
+        fake.fakeFn = undefined;
     },
 
     throws: throwsException,
     throwsException: throwsException,
 
     returns: function returns(fake, value) {
-        clear(fake);
-
+        fake.callsThrough = false;
         fake.returnValue = value;
+        fake.resolve = false;
+        fake.reject = false;
         fake.returnValueDefined = true;
+        fake.exception = undefined;
+        fake.exceptionCreator = undefined;
+        fake.fakeFn = undefined;
     },
 
     returnsArg: function returnsArg(fake, index) {
         if (typeof index !== "number") {
             throw new TypeError("argument index is not number");
         }
-        clear(fake);
+        fake.callsThrough = false;
 
         fake.returnArgAt = index;
     },
@@ -182,33 +170,42 @@ const defaultBehaviors = {
         if (typeof index !== "number") {
             throw new TypeError("argument index is not number");
         }
-        clear(fake);
+        fake.callsThrough = false;
 
         fake.throwArgAt = index;
     },
 
     returnsThis: function returnsThis(fake) {
-        clear(fake);
-
         fake.returnThis = true;
+        fake.callsThrough = false;
     },
 
     resolves: function resolves(fake, value) {
-        clear(fake);
-
         fake.returnValue = value;
         fake.resolve = true;
+        fake.resolveThis = false;
+        fake.reject = false;
         fake.returnValueDefined = true;
+        fake.exception = undefined;
+        fake.exceptionCreator = undefined;
+        fake.fakeFn = undefined;
+        fake.callsThrough = false;
     },
 
     resolvesArg: function resolvesArg(fake, index) {
         if (typeof index !== "number") {
             throw new TypeError("argument index is not number");
         }
-        clear(fake);
-
         fake.resolveArgAt = index;
+        fake.returnValue = undefined;
         fake.resolve = true;
+        fake.resolveThis = false;
+        fake.reject = false;
+        fake.returnValueDefined = false;
+        fake.exception = undefined;
+        fake.exceptionCreator = undefined;
+        fake.fakeFn = undefined;
+        fake.callsThrough = false;
     },
 
     rejects: function rejects(fake, error, message) {
@@ -221,30 +218,36 @@ const defaultBehaviors = {
         } else {
             reason = error;
         }
-        clear(fake);
-
         fake.returnValue = reason;
+        fake.resolve = false;
+        fake.resolveThis = false;
         fake.reject = true;
         fake.returnValueDefined = true;
+        fake.exception = undefined;
+        fake.exceptionCreator = undefined;
+        fake.fakeFn = undefined;
+        fake.callsThrough = false;
 
         return fake;
     },
 
     resolvesThis: function resolvesThis(fake) {
-        clear(fake);
-
+        fake.returnValue = undefined;
+        fake.resolve = false;
         fake.resolveThis = true;
+        fake.reject = false;
+        fake.returnValueDefined = false;
+        fake.exception = undefined;
+        fake.exceptionCreator = undefined;
+        fake.fakeFn = undefined;
+        fake.callsThrough = false;
     },
 
     callThrough: function callThrough(fake) {
-        clear(fake);
-
         fake.callsThrough = true;
     },
 
     callThroughWithNew: function callThroughWithNew(fake) {
-        clear(fake);
-
         fake.callsThroughWithNew = true;
     },
 

node_modules/sinon/lib/sinon/fake.js

@@ -134,7 +134,7 @@ fake.resolves = function resolves(value) {
  * var f1 = sinon.fake.rejects(":(");
  *
  * try {
- *   await ft();
+ *   await f1();
  * } catch (error) {
  *   console.log(error);
  *   // ":("

node_modules/sinon/lib/sinon/sandbox.js

@@ -243,7 +243,7 @@ function Sandbox(opts = {}) {
      */
     function getFakeRestorer(object, property, forceAssignment = false) {
         const descriptor = getPropertyDescriptor(object, property);
-        const value = object[property];
+        const value = forceAssignment && object[property];
 
         function restorer() {
             if (forceAssignment) {

node_modules/sinon/lib/sinon/util/core/default-config.js

@@ -1,21 +0,0 @@
-"use strict";
-
-module.exports = {
-    injectInto: null,
-    properties: [
-        "spy",
-        "stub",
-        "mock",
-        "clock",
-        "server",
-        "requests",
-        "fake",
-        "define",
-        "replace",
-        "replaceSetter",
-        "replaceGetter",
-        "createStubInstance",
-    ],
-    useFakeTimers: true,
-    useFakeServer: true,
-};

node_modules/sinon/lib/sinon/util/core/extend.js

@@ -114,7 +114,7 @@ module.exports = function extend(target, ...sources) {
                 enumerable: sourceOwnPropertyDescriptor.enumerable,
             };
             /*
-                if the sorce has an Accessor property copy over the accessor functions (get and set)
+                if the source has an Accessor property copy over the accessor functions (get and set)
                 data properties has writable attribute where as accessor property don't
                 REF: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#properties
             */

node_modules/sinon/lib/sinon/util/core/get-property-descriptor.js

@@ -1,8 +1,18 @@
 "use strict";
 
-/* eslint-disable jsdoc/valid-types */
+/**
+ * @typedef {object} PropertyDescriptor
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#description
+ * @property {boolean} configurable defaults to false
+ * @property {boolean} enumerable   defaults to false
+ * @property {boolean} writable     defaults to false
+ * @property {*} value defaults to undefined
+ * @property {Function} get defaults to undefined
+ * @property {Function} set defaults to undefined
+ */
+
 /*
- * The following type def is strictly an illegal JSDoc, but the expression forms a
+ * The following type def is strictly speaking illegal in JSDoc, but the expression forms a
  * legal Typescript union type and is understood by Visual Studio and the IntelliJ
  * family of editors. The "TS" flavor of JSDoc is becoming the de-facto standard these
  * days for that reason (and the fact that JSDoc is essentially unmaintained)
@@ -13,7 +23,6 @@
  * a slightly enriched property descriptor
  * @property {boolean} isOwn true if the descriptor is owned by this object, false if it comes from the prototype
  */
-/* eslint-enable jsdoc/valid-types */
 
 /**
  * Returns a slightly modified property descriptor that one can tell is from the object or the prototype