jasmine-core 7.0.0-pre.0 → 7.0.0-pre.1

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/jasmine-html.js

@@ -305,11 +305,9 @@ getJasmineHtmlRequireObj().Banner = function(j$, private$) {
 
   class Banner {
     #navigateWithNewParam;
-    #omitHideDisabled;
 
-    constructor(navigateWithNewParam, omitHideDisabled) {
+    constructor(navigateWithNewParam) {
       this.#navigateWithNewParam = navigateWithNewParam;
-      this.#omitHideDisabled = omitHideDisabled;
       this.rootEl = createDom(
         'div',
         { className: 'jasmine-banner' },
@@ -372,25 +370,6 @@ getJasmineHtmlRequireObj().Banner = function(j$, private$) {
         )
       ];
 
-      if (!this.#omitHideDisabled) {
-        items.push(
-          createDom(
-            'div',
-            { className: 'jasmine-hide-disabled' },
-            createDom('input', {
-              className: 'jasmine-disabled',
-              id: 'jasmine-hide-disabled',
-              type: 'checkbox'
-            }),
-            createDom(
-              'label',
-              { className: 'jasmine-label', for: 'jasmine-hide-disabled' },
-              'hide disabled tests'
-            )
-          )
-        );
-      }
-
       const optionsMenuDom = createDom(
         'div',
         { className: 'jasmine-run-options' },
@@ -428,19 +407,9 @@ getJasmineHtmlRequireObj().Banner = function(j$, private$) {
         this.#navigateWithNewParam('random', !config.random);
       };
 
-      if (!this.#omitHideDisabled) {
-        const hideDisabled = optionsMenuDom.querySelector(
-          '#jasmine-hide-disabled'
-        );
-        hideDisabled.checked = config.hideDisabled;
-        hideDisabled.onclick = () => {
-          this.#navigateWithNewParam('hideDisabled', !config.hideDisabled);
-        };
-      }
-
-      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)) {
@@ -766,8 +735,7 @@ getJasmineHtmlRequireObj().HtmlReporterV2 = function(j$, private$) {
 
       this.#progress = new ProgressView();
       this.#banner = new private$.Banner(
-        this.#queryString.navigateWithNewParam.bind(this.#queryString),
-        true
+        this.#queryString.navigateWithNewParam.bind(this.#queryString)
       );
       this.#failures = new private$.FailuresView(this.#urlBuilder);
       this.#htmlReporterMain = createDom(

package/lib/jasmine-core/jasmine.js

@@ -173,43 +173,43 @@ getJasmineRequireObj().requireMatchers = function(jRequire, j$, private$) {
   '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$, private$);
@@ -754,8 +754,8 @@ getJasmineRequireObj().util = function(j$, private$) {
 
   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)) {
@@ -769,8 +769,8 @@ getJasmineRequireObj().util = function(j$, private$) {
   };
 
   util.getPropertyDescriptor = function(obj, methodName) {
-    let descriptor,
-      proto = obj;
+    let descriptor;
+    let proto = obj;
 
     do {
       descriptor = Object.getOwnPropertyDescriptor(proto, methodName);
@@ -1196,10 +1196,12 @@ getJasmineRequireObj().Spec = function(j$, private$) {
   }
 
   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);
   };
@@ -1332,7 +1334,11 @@ getJasmineRequireObj().Env = function(j$, private$) {
     let runner;
     let parallelLoadingState = null; // 'specs', 'helpers', or null for non-parallel
 
-    const config = new private$.Configuration();
+    const config = new private$.Configuration({
+      deprecated: function() {
+        return self.deprecated.apply(self, arguments);
+      }
+    });
 
     if (!envOptions.suppressLoadErrors) {
       installGlobalErrors();
@@ -3326,17 +3332,6 @@ getJasmineRequireObj().Configuration = function(j$, private$) {
       return true;
     },
 
-    // TODO: remove hideDisabled when HtmlReporter is removed
-    /**
-     * Whether reporters should hide disabled specs from their output.
-     * Currently only supported by Jasmine's HTMLReporter
-     * @name Configuration#hideDisabled
-     * @since 3.3.0
-     * @type Boolean
-     * @default false
-     * @deprecated
-     */
-    hideDisabled: false,
     /**
      * Clean closures when a suite is done running (done by clearing the stored function reference).
      * This prevents memory leaks, but you won't be able to run jasmine multiple times.
@@ -3407,25 +3402,25 @@ getJasmineRequireObj().Configuration = function(j$, private$) {
 
     /**
      * The strategy to use in Safari and similar browsers to determine how often
-     * to yield control by calling setTimeout. If set to "count", the default,
-     * the frequency of setTimeout calls is based on the number of relevant
-     * function calls. If set to "time", the frequency of setTimeout calls is
-     * based on elapsed time. Using "time" may provide a significant performance
-     * improvement, but as of 6.0 it hasn't been tested with a wide variety of
-     * workloads and should be considered experimental.
+     * to yield control by calling setTimeout. If set to "time", the default,
+     * the frequency of setTimeout calls is based on elapsed time. If set to
+     * "count", the frequency of setTimeout calls is based on the number of
+     * relevant function calls.
      * @name Configuration#safariYieldStrategy
      * @since 6.0.0
      * @type 'count' | 'time'
-     * @default 'count'
+     * @default 'time'
      */
-    safariYieldStrategy: 'count'
+    safariYieldStrategy: 'time'
   };
   Object.freeze(defaultConfig);
 
   class Configuration {
+    #deprecated;
     #values;
 
-    constructor() {
+    constructor(options) {
+      this.#deprecated = options.deprecated;
       this.#values = { ...defaultConfig };
 
       for (const k of Object.keys(defaultConfig)) {
@@ -3446,7 +3441,6 @@ getJasmineRequireObj().Configuration = function(j$, private$) {
       const booleanProps = [
         'random',
         'failSpecWithNoExpectations',
-        'hideDisabled',
         'stopOnSpecFailure',
         'stopSpecOnExpectationFailure',
         'autoCleanClosures',
@@ -3485,6 +3479,12 @@ getJasmineRequireObj().Configuration = function(j$, private$) {
 
         if (v === 'count' || v === 'time') {
           this.#values.safariYieldStrategy = v;
+
+          if (v === 'count') {
+            this.#deprecated(
+              'safariYieldStrategy: "count" is deprecated. If you need this option, please submit a bug report.'
+            );
+          }
         } else {
           throw new Error(
             "Invalid safariYieldStrategy value. Valid values are 'count' and 'time'."
@@ -4988,6 +4988,71 @@ getJasmineRequireObj().toBeRejectedWithError = function(j$, private$) {
   }
 };
 
+getJasmineRequireObj().toBeRejectedWithMatching = function(j$, private$) {
+  'use strict';
+
+  const usageError = 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 (!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$, private$) {
   'use strict';
 
@@ -5292,14 +5357,14 @@ getJasmineRequireObj().MatchersUtil = function(j$, private$) {
   };
 
   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 ' +
@@ -5681,8 +5746,8 @@ getJasmineRequireObj().MatchersUtil = function(j$, private$) {
     } 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) &&
@@ -5788,11 +5853,11 @@ getJasmineRequireObj().MatchersUtil = function(j$, private$) {
   }
 
   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';
@@ -6050,14 +6115,15 @@ getJasmineRequireObj().requireAsyncMatchers = function(jRequire, j$, private$) {
   '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$, private$);
@@ -6663,11 +6729,11 @@ getJasmineRequireObj().toEqual = function(j$, private$) {
     return {
       compare: function(actual, expected) {
         const result = {
-            pass: false
-          },
-          diffBuilder = new private$.DiffBuilder({
-            prettyPrinter: matchersUtil.pp
-          });
+          pass: false
+        };
+        const diffBuilder = new private$.DiffBuilder({
+          prettyPrinter: matchersUtil.pp
+        });
 
         result.pass = matchersUtil.equals(actual, expected, diffBuilder);
 
@@ -6852,9 +6918,9 @@ getJasmineRequireObj().toHaveBeenCalledOnceWith = function(j$, private$) {
   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(
@@ -6971,8 +7037,8 @@ getJasmineRequireObj().toHaveBeenCalledTimes = function(j$, private$) {
           );
         }
 
-        const args = Array.prototype.slice.call(arguments, 0),
-          result = { pass: false };
+        const args = Array.prototype.slice.call(arguments, 0);
+        const result = { pass: false };
 
         if (!private$.isNumber(expected)) {
           throw new Error(
@@ -7041,10 +7107,10 @@ getJasmineRequireObj().toHaveBeenCalledWith = function(j$, private$) {
   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(
@@ -9924,22 +9990,22 @@ getJasmineRequireObj().Spy = function(j$, private$) {
     };
     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 private$.CallTracker();
+        customStrategies: customStrategies
+      },
+      matchersUtil
+    );
+    const callTracker = new private$.CallTracker();
 
     function makeFunc(length, fn) {
       switch (length) {
@@ -10383,10 +10449,10 @@ getJasmineRequireObj().SpyRegistry = function(j$, private$) {
         );
       }
 
-      let pointer = obj,
-        propsToSpyOn = [],
-        properties,
-        propertiesToSkip = [];
+      let pointer = obj;
+      let propsToSpyOn = [];
+      let properties;
+      let propertiesToSkip = [];
 
       while (
         pointer &&
@@ -11670,9 +11736,9 @@ getJasmineRequireObj().SuiteBuilder = function(j$, private$) {
 
   function beforeAndAfterFns(targetSuite) {
     return function() {
-      let befores = [],
-        afters = [],
-        suite = targetSuite;
+      let befores = [];
+      let afters = [];
+      let suite = targetSuite;
 
       while (suite) {
         befores = befores.concat(suite.beforeFns);
@@ -11887,15 +11953,15 @@ getJasmineRequireObj().TreeProcessor = function(j$, private$) {
 
   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 (
@@ -11906,9 +11972,9 @@ getJasmineRequireObj().TreeProcessor = function(j$, private$) {
     }
 
     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 = {
@@ -11931,12 +11997,12 @@ getJasmineRequireObj().TreeProcessor = function(j$, private$) {
   }
 
   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];
@@ -12280,7 +12346,7 @@ getJasmineRequireObj().UserContext = function(j$, private$) {
 };
 
 getJasmineRequireObj().version = function() {
-  return '7.0.0-pre.0';
+  return '7.0.0-pre.1';
 };
 
 (function() {

package/lib/jasmine-core.js

@@ -39,11 +39,11 @@ function reset() {
   rebindInterface(env);
 }
 
-const rootPath = path.join(__dirname, 'jasmine-core'),
-  bootFiles = ['boot.js'],
-  cssFiles = [],
-  jsFiles = [],
-  jsFilesToSkip = ['jasmine.js'].concat(bootFiles);
+const rootPath = path.join(__dirname, 'jasmine-core');
+const bootFiles = ['boot.js'];
+const cssFiles = [];
+const jsFiles = [];
+const jsFilesToSkip = ['jasmine.js'].concat(bootFiles);
 
 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": "7.0.0-pre.0",
+  "version": "7.0.0-pre.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/jasmine/jasmine.git"
@@ -55,8 +55,8 @@
     "sass": "^1.58.3"
   },
   "browserslist": [
-    "Safari >= 16",
-    "Firefox >= 102",
+    "Safari >= 26",
+    "Firefox >= 140",
     "last 2 Chrome versions",
     "last 2 Edge versions"
   ]