jasmine-core 6.1.0 → 6.2.0

package/README.md

@@ -32,7 +32,7 @@ Microsoft Edge) as well as Node.
 | Node              | 20, 22, 24                       |
 | Safari            | 26*                              |
 | Chrome            | Evergreen                        |
-| Firefox           | Evergreen, 102*, 115*, 128*, 140 |
+| Firefox           | Evergreen, 140                   |
 | Edge              | Evergreen                        |
 
 For evergreen browsers, each version of Jasmine is tested against the version of the browser that is available to us

package/lib/jasmine-core/boot0.js

@@ -38,8 +38,8 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    *
    * Require Jasmine's core files. Specifically, this requires and attaches all of Jasmine's code to the `jasmine` reference.
    */
-  const jasmine = jasmineRequire.core(jasmineRequire),
-    global = jasmine.getGlobal();
+  const jasmine = jasmineRequire.core(jasmineRequire);
+  const global = jasmine.getGlobal();
   global.jasmine = jasmine;
 
   /**

package/lib/jasmine-core/jasmine-html.js

@@ -707,9 +707,9 @@ jasmineRequire.Banner = function(j$) {
         };
       }
 
-      const optionsTrigger = optionsMenuDom.querySelector('.jasmine-trigger'),
-        optionsPayload = optionsMenuDom.querySelector('.jasmine-payload'),
-        isOpen = /\bjasmine-open\b/;
+      const optionsTrigger = optionsMenuDom.querySelector('.jasmine-trigger');
+      const optionsPayload = optionsMenuDom.querySelector('.jasmine-payload');
+      const isOpen = /\bjasmine-open\b/;
 
       optionsTrigger.onclick = function() {
         if (isOpen.test(optionsPayload.className)) {

package/lib/jasmine-core/jasmine.js

@@ -153,43 +153,43 @@ getJasmineRequireObj().requireMatchers = function(jRequire, j$) {
   'use strict';
 
   const availableMatchers = [
-      'nothing',
-      'toBe',
-      'toBeCloseTo',
-      'toBeDefined',
-      'toBeInstanceOf',
-      'toBeFalse',
-      'toBeFalsy',
-      'toBeGreaterThan',
-      'toBeGreaterThanOrEqual',
-      'toBeLessThan',
-      'toBeLessThanOrEqual',
-      'toBeNaN',
-      'toBeNegativeInfinity',
-      'toBeNull',
-      'toBePositiveInfinity',
-      'toBeTrue',
-      'toBeTruthy',
-      'toBeUndefined',
-      'toBeNullish',
-      'toContain',
-      'toEqual',
-      'toHaveSize',
-      'toHaveBeenCalled',
-      'toHaveBeenCalledBefore',
-      'toHaveBeenCalledOnceWith',
-      'toHaveBeenCalledTimes',
-      'toHaveBeenCalledWith',
-      'toHaveClass',
-      'toHaveClasses',
-      'toHaveSpyInteractions',
-      'toHaveNoOtherSpyInteractions',
-      'toMatch',
-      'toThrow',
-      'toThrowError',
-      'toThrowMatching'
-    ],
-    matchers = {};
+    'nothing',
+    'toBe',
+    'toBeCloseTo',
+    'toBeDefined',
+    'toBeInstanceOf',
+    'toBeFalse',
+    'toBeFalsy',
+    'toBeGreaterThan',
+    'toBeGreaterThanOrEqual',
+    'toBeLessThan',
+    'toBeLessThanOrEqual',
+    'toBeNaN',
+    'toBeNegativeInfinity',
+    'toBeNull',
+    'toBePositiveInfinity',
+    'toBeTrue',
+    'toBeTruthy',
+    'toBeUndefined',
+    'toBeNullish',
+    'toContain',
+    'toEqual',
+    'toHaveSize',
+    'toHaveBeenCalled',
+    'toHaveBeenCalledBefore',
+    'toHaveBeenCalledOnceWith',
+    'toHaveBeenCalledTimes',
+    'toHaveBeenCalledWith',
+    'toHaveClass',
+    'toHaveClasses',
+    'toHaveSpyInteractions',
+    'toHaveNoOtherSpyInteractions',
+    'toMatch',
+    'toThrow',
+    'toThrowError',
+    'toThrowMatching'
+  ];
+  const matchers = {};
 
   for (const name of availableMatchers) {
     matchers[name] = jRequire[name](j$);
@@ -733,8 +733,8 @@ getJasmineRequireObj().util = function(j$) {
 
   util.cloneArgs = function(args) {
     return Array.from(args).map(function(arg) {
-      const str = Object.prototype.toString.apply(arg),
-        primitives = /^\[object (Boolean|String|RegExp|Number)/;
+      const str = Object.prototype.toString.apply(arg);
+      const primitives = /^\[object (Boolean|String|RegExp|Number)/;
 
       // All falsey values are either primitives, `null`, or `undefined.
       if (!arg || str.match(primitives)) {
@@ -748,8 +748,8 @@ getJasmineRequireObj().util = function(j$) {
   };
 
   util.getPropertyDescriptor = function(obj, methodName) {
-    let descriptor,
-      proto = obj;
+    let descriptor;
+    let proto = obj;
 
     do {
       descriptor = Object.getOwnPropertyDescriptor(proto, methodName);
@@ -1175,10 +1175,12 @@ getJasmineRequireObj().Spec = function(j$) {
   }
 
   const extractCustomPendingMessage = function(e) {
-    const fullMessage = e.toString(),
-      boilerplateStart = fullMessage.indexOf(Spec.pendingSpecExceptionMessage),
-      boilerplateEnd =
-        boilerplateStart + Spec.pendingSpecExceptionMessage.length;
+    const fullMessage = e.toString();
+    const boilerplateStart = fullMessage.indexOf(
+      Spec.pendingSpecExceptionMessage
+    );
+    const boilerplateEnd =
+      boilerplateStart + Spec.pendingSpecExceptionMessage.length;
 
     return fullMessage.slice(boilerplateEnd);
   };
@@ -2139,8 +2141,8 @@ getJasmineRequireObj().JsApiReporter = function(j$) {
       return status;
     };
 
-    const suites = [],
-      suites_hash = {};
+    const suites = [];
+    const suites_hash = {};
 
     this.suiteStarted = function(result) {
       suites_hash[result.id] = result;
@@ -5122,6 +5124,71 @@ getJasmineRequireObj().toBeRejectedWithError = function(j$) {
   }
 };
 
+getJasmineRequireObj().toBeRejectedWithMatching = function(j$) {
+  'use strict';
+
+  const usageError = j$.private.formatErrorMsg(
+    '<toBeRejectedWithMatching>',
+    'expect(function() {<expectation>}).toBeRejectedWithMatching(<Predicate>)'
+  );
+
+  /**
+   * Expect a promise to be rejected with a value matching a predicate.
+   * @function
+   * @async
+   * @name async-matchers#toBeRejectedWithMatching
+   * @since 6.2.0
+   * @param {Function} predicate - A function that takes the rejected promise value as its parameter and returns true if it matches.
+   * @example
+   * await expectAsync(aPromise).toBeRejectedWithMatching((error) => error.message === 'Some error');
+   * @example
+   * return expectAsync(aPromise).toBeRejectedWithMatching((error) => error.message === 'Some error');
+   */
+  return function toBeRejectedWithMatching() {
+    return {
+      compare: function(actualPromise, predicate) {
+        if (!j$.private.isPromiseLike(actualPromise)) {
+          throw new Error(
+            `Expected toBeRejectedWithMatching to be called on a promise but was on a ${typeof actualPromise}.`
+          );
+        }
+
+        if (typeof predicate !== 'function') {
+          throw new Error(usageError('Predicate is not a Function'));
+        }
+
+        function prefix(passed) {
+          return (
+            'Expected a promise ' +
+            (passed ? 'not ' : '') +
+            'to be rejected matching a predicate'
+          );
+        }
+
+        return actualPromise.then(
+          function() {
+            return {
+              pass: false,
+              message: prefix(false) + ', but it was resolved.'
+            };
+          },
+          function(actualValue) {
+            const result = predicate(actualValue);
+            return {
+              pass: Boolean(result),
+              message:
+                prefix(result) +
+                ', but the predicate returned "' +
+                result +
+                '".'
+            };
+          }
+        );
+      }
+    };
+  };
+};
+
 getJasmineRequireObj().toBeResolved = function(j$) {
   'use strict';
 
@@ -5426,14 +5493,14 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
   };
 
   MatchersUtil.prototype.buildFailureMessage = function() {
-    const args = Array.prototype.slice.call(arguments, 0),
-      matcherName = args[0],
-      isNot = args[1],
-      actual = args[2],
-      expected = args.slice(3),
-      englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) {
-        return ' ' + s.toLowerCase();
-      });
+    const args = Array.prototype.slice.call(arguments, 0);
+    const matcherName = args[0];
+    const isNot = args[1];
+    const actual = args[2];
+    const expected = args.slice(3);
+    const englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) {
+      return ' ' + s.toLowerCase();
+    });
 
     let message =
       'Expected ' +
@@ -5815,8 +5882,8 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
     } else {
       // Objects with different constructors are not equivalent, but `Object`s
       // or `Array`s from different frames are.
-      const aCtor = a.constructor,
-        bCtor = b.constructor;
+      const aCtor = a.constructor;
+      const bCtor = b.constructor;
       if (
         aCtor !== bCtor &&
         isFunction(aCtor) &&
@@ -5922,11 +5989,11 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
   }
 
   function objectKeysAreDifferentFormatter(pp, actual, expected, path) {
-    const missingProperties = extraKeysAndValues(expected, actual),
-      extraProperties = extraKeysAndValues(actual, expected),
-      missingPropertiesMessage = formatKeyValuePairs(pp, missingProperties),
-      extraPropertiesMessage = formatKeyValuePairs(pp, extraProperties),
-      messages = [];
+    const missingProperties = extraKeysAndValues(expected, actual);
+    const extraProperties = extraKeysAndValues(actual, expected);
+    const missingPropertiesMessage = formatKeyValuePairs(pp, missingProperties);
+    const extraPropertiesMessage = formatKeyValuePairs(pp, extraProperties);
+    const messages = [];
 
     if (!path.depth()) {
       path = 'object';
@@ -6184,14 +6251,15 @@ getJasmineRequireObj().requireAsyncMatchers = function(jRequire, j$) {
   'use strict';
 
   const availableMatchers = [
-      'toBePending',
-      'toBeResolved',
-      'toBeRejected',
-      'toBeResolvedTo',
-      'toBeRejectedWith',
-      'toBeRejectedWithError'
-    ],
-    matchers = {};
+    'toBePending',
+    'toBeResolved',
+    'toBeRejected',
+    'toBeResolvedTo',
+    'toBeRejectedWith',
+    'toBeRejectedWithError',
+    'toBeRejectedWithMatching'
+  ];
+  const matchers = {};
 
   for (const name of availableMatchers) {
     matchers[name] = jRequire[name](j$);
@@ -6797,11 +6865,11 @@ getJasmineRequireObj().toEqual = function(j$) {
     return {
       compare: function(actual, expected) {
         const result = {
-            pass: false
-          },
-          diffBuilder = new j$.private.DiffBuilder({
-            prettyPrinter: matchersUtil.pp
-          });
+          pass: false
+        };
+        const diffBuilder = new j$.private.DiffBuilder({
+          prettyPrinter: matchersUtil.pp
+        });
 
         result.pass = matchersUtil.equals(actual, expected, diffBuilder);
 
@@ -6986,9 +7054,9 @@ getJasmineRequireObj().toHaveBeenCalledOnceWith = function(j$) {
   function toHaveBeenCalledOnceWith(matchersUtil) {
     return {
       compare: function() {
-        const args = Array.prototype.slice.call(arguments, 0),
-          actual = args[0],
-          expectedArgs = args.slice(1);
+        const args = Array.prototype.slice.call(arguments, 0);
+        const actual = args[0];
+        const expectedArgs = args.slice(1);
 
         if (!j$.isSpy(actual)) {
           throw new Error(
@@ -7105,8 +7173,8 @@ getJasmineRequireObj().toHaveBeenCalledTimes = function(j$) {
           );
         }
 
-        const args = Array.prototype.slice.call(arguments, 0),
-          result = { pass: false };
+        const args = Array.prototype.slice.call(arguments, 0);
+        const result = { pass: false };
 
         if (!j$.private.isNumber(expected)) {
           throw new Error(
@@ -7175,10 +7243,10 @@ getJasmineRequireObj().toHaveBeenCalledWith = function(j$) {
   function toHaveBeenCalledWith(matchersUtil) {
     return {
       compare: function() {
-        const args = Array.prototype.slice.call(arguments, 0),
-          actual = args[0],
-          expectedArgs = args.slice(1),
-          result = { pass: false };
+        const args = Array.prototype.slice.call(arguments, 0);
+        const actual = args[0];
+        const expectedArgs = args.slice(1);
+        const result = { pass: false };
 
         if (!j$.isSpy(actual)) {
           throw new Error(
@@ -10067,22 +10135,22 @@ getJasmineRequireObj().Spy = function(j$) {
     };
     const { originalFn, customStrategies, defaultStrategyFn } = optionals || {};
 
-    const numArgs = typeof originalFn === 'function' ? originalFn.length : 0,
-      wrapper = makeFunc(numArgs, function(context, args, invokeNew) {
-        return spy(context, args, invokeNew);
-      }),
-      strategyDispatcher = new SpyStrategyDispatcher(
-        {
-          name: name,
-          fn: originalFn,
-          getSpy: function() {
-            return wrapper;
-          },
-          customStrategies: customStrategies
+    const numArgs = typeof originalFn === 'function' ? originalFn.length : 0;
+    const wrapper = makeFunc(numArgs, function(context, args, invokeNew) {
+      return spy(context, args, invokeNew);
+    });
+    const strategyDispatcher = new SpyStrategyDispatcher(
+      {
+        name: name,
+        fn: originalFn,
+        getSpy: function() {
+          return wrapper;
         },
-        matchersUtil
-      ),
-      callTracker = new j$.private.CallTracker();
+        customStrategies: customStrategies
+      },
+      matchersUtil
+    );
+    const callTracker = new j$.private.CallTracker();
 
     function makeFunc(length, fn) {
       switch (length) {
@@ -10529,10 +10597,10 @@ getJasmineRequireObj().SpyRegistry = function(j$) {
         );
       }
 
-      let pointer = obj,
-        propsToSpyOn = [],
-        properties,
-        propertiesToSkip = [];
+      let pointer = obj;
+      let propsToSpyOn = [];
+      let properties;
+      let propertiesToSkip = [];
 
       while (
         pointer &&
@@ -11816,9 +11884,9 @@ getJasmineRequireObj().SuiteBuilder = function(j$) {
 
   function beforeAndAfterFns(targetSuite) {
     return function() {
-      let befores = [],
-        afters = [],
-        suite = targetSuite;
+      let befores = [];
+      let afters = [];
+      let suite = targetSuite;
 
       while (suite) {
         befores = befores.concat(suite.beforeFns);
@@ -12029,15 +12097,15 @@ getJasmineRequireObj().TreeProcessor = function(j$) {
 
   function segmentChildren(node, orderedChildren, stats, executableIndex) {
     let currentSegment = {
-        index: 0,
-        owner: node,
-        nodes: [],
-        min: startingMin(executableIndex),
-        max: startingMax(executableIndex)
-      },
-      result = [currentSegment],
-      lastMax = defaultMax,
-      orderedChildSegments = orderChildSegments(orderedChildren, stats);
+      index: 0,
+      owner: node,
+      nodes: [],
+      min: startingMin(executableIndex),
+      max: startingMax(executableIndex)
+    };
+    let result = [currentSegment];
+    let lastMax = defaultMax;
+    let orderedChildSegments = orderChildSegments(orderedChildren, stats);
 
     function isSegmentBoundary(minIndex) {
       return (
@@ -12048,9 +12116,9 @@ getJasmineRequireObj().TreeProcessor = function(j$) {
     }
 
     for (let i = 0; i < orderedChildSegments.length; i++) {
-      const childSegment = orderedChildSegments[i],
-        maxIndex = childSegment.max,
-        minIndex = childSegment.min;
+      const childSegment = orderedChildSegments[i];
+      const maxIndex = childSegment.max;
+      const minIndex = childSegment.min;
 
       if (isSegmentBoundary(minIndex)) {
         currentSegment = {
@@ -12073,12 +12141,12 @@ getJasmineRequireObj().TreeProcessor = function(j$) {
   }
 
   function orderChildSegments(children, stats) {
-    const specifiedOrder = [],
-      unspecifiedOrder = [];
+    const specifiedOrder = [];
+    const unspecifiedOrder = [];
 
     for (let i = 0; i < children.length; i++) {
-      const child = children[i],
-        segments = stats[child.id].segments;
+      const child = children[i];
+      const segments = stats[child.id].segments;
 
       for (let j = 0; j < segments.length; j++) {
         const seg = segments[j];
@@ -12422,5 +12490,5 @@ getJasmineRequireObj().UserContext = function(j$) {
 };
 
 getJasmineRequireObj().version = function() {
-  return '6.1.0';
+  return '6.2.0';
 };

package/lib/jasmine-core.js

@@ -79,15 +79,15 @@ module.exports.noGlobals = function() {
   return jasmineInterface;
 };
 
-const path = require('path'),
-  fs = require('fs');
-
-const rootPath = path.join(__dirname, 'jasmine-core'),
-  bootFiles = ['boot0.js', 'boot1.js'],
-  legacyBootFiles = ['boot.js'],
-  cssFiles = [],
-  jsFiles = [],
-  jsFilesToSkip = ['jasmine.js'].concat(bootFiles, legacyBootFiles);
+const path = require('path');
+const fs = require('fs');
+
+const rootPath = path.join(__dirname, 'jasmine-core');
+const bootFiles = ['boot0.js', 'boot1.js'];
+const legacyBootFiles = ['boot.js'];
+const cssFiles = [];
+const jsFiles = [];
+const jsFilesToSkip = ['jasmine.js'].concat(bootFiles, legacyBootFiles);
 
 fs.readdirSync(rootPath).forEach(function(file) {
   if (fs.statSync(path.join(rootPath, file)).isFile()) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jasmine-core",
   "license": "MIT",
-  "version": "6.1.0",
+  "version": "6.2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/jasmine/jasmine.git"
@@ -52,8 +52,8 @@
     "sass": "^1.58.3"
   },
   "browserslist": [
-    "Safari >= 16",
-    "Firefox >= 102",
+    "Safari >= 26",
+    "Firefox >= 140",
     "last 2 Chrome versions",
     "last 2 Edge versions"
   ]