'a'

mh-two-thousand-and-two

2024-04-12 44d2c92345cd156a59fc327b3060292a282d2893

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
'use strict';
 
Object.defineProperty(exports, '__esModule', {
  value: true
});
exports.setMatchers = exports.getMatchers = exports.setState = exports.getState = exports.INTERNAL_MATCHER_FLAG = void 0;
 
var _asymmetricMatchers = require('./asymmetricMatchers');
 
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
// Global matchers object holds the list of available matchers and
// the state, that can hold matcher specific values that change over time.
const JEST_MATCHERS_OBJECT = Symbol.for('$$jest-matchers-object'); // Notes a built-in/internal Jest matcher.
// Jest may override the stack trace of Errors thrown by internal matchers.
 
const INTERNAL_MATCHER_FLAG = Symbol.for('$$jest-internal-matcher');
exports.INTERNAL_MATCHER_FLAG = INTERNAL_MATCHER_FLAG;
 
if (!global.hasOwnProperty(JEST_MATCHERS_OBJECT)) {
  Object.defineProperty(global, JEST_MATCHERS_OBJECT, {
    value: {
      matchers: Object.create(null),
      state: {
        assertionCalls: 0,
        expectedAssertionsNumber: null,
        isExpectingAssertions: false,
        suppressedErrors: [] // errors that are not thrown immediately.
      }
    }
  });
}
 
const getState = () => global[JEST_MATCHERS_OBJECT].state;
 
exports.getState = getState;
 
const setState = state => {
  Object.assign(global[JEST_MATCHERS_OBJECT].state, state);
};
 
exports.setState = setState;
 
const getMatchers = () => global[JEST_MATCHERS_OBJECT].matchers;
 
exports.getMatchers = getMatchers;
 
const setMatchers = (matchers, isInternal, expect) => {
  Object.keys(matchers).forEach(key => {
    const matcher = matchers[key];
    Object.defineProperty(matcher, INTERNAL_MATCHER_FLAG, {
      value: isInternal
    });
 
    if (!isInternal) {
      // expect is defined
      class CustomMatcher extends _asymmetricMatchers.AsymmetricMatcher {
        constructor(inverse = false, ...sample) {
          super(sample);
          this.inverse = inverse;
        }
 
        asymmetricMatch(other) {
          const {pass} = matcher(other, ...this.sample);
          return this.inverse ? !pass : pass;
        }
 
        toString() {
          return `${this.inverse ? 'not.' : ''}${key}`;
        }
 
        getExpectedType() {
          return 'any';
        }
 
        toAsymmetricMatcher() {
          return `${this.toString()}<${this.sample.map(String).join(', ')}>`;
        }
      }
 
      expect[key] = (...sample) => new CustomMatcher(false, ...sample);
 
      if (!expect.not) {
        expect.not = {};
      }
 
      expect.not[key] = (...sample) => new CustomMatcher(true, ...sample);
    }
  });
  Object.assign(global[JEST_MATCHERS_OBJECT].matchers, matchers);
};
 
exports.setMatchers = setMatchers;