strong-mock 7.2.1 → 8.0.0-beta.1

package/dist/index.js

@@ -1,144 +1,777 @@
-'use strict';
+var jestMatcherUtils = require('jest-matcher-utils');
+var lodash = require('lodash');
 
-Object.defineProperty(exports, '__esModule', { value: true });
+const MATCHER_SYMBOL = Symbol('matcher');
+/**
+ * Used to test if an expectation on an argument is a custom matcher.
+ */
 
-var jestMatcherUtils = require('jest-matcher-utils');
-var isEqual = require('lodash/isEqual');
-var isMatchWith = require('lodash/isMatchWith');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var isEqual__default = /*#__PURE__*/_interopDefaultLegacy(isEqual);
-var isMatchWith__default = /*#__PURE__*/_interopDefaultLegacy(isMatchWith);
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise */
-
-var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-    if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-function __read(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-}
-
-function __spreadArray(to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
+function isMatcher(f) {
+  return !!(f && f[MATCHER_SYMBOL]);
 }
 
 /**
  * Special symbol denoting the call of a function.
- */
-var ApplyProp = Symbol('apply');
+ */
+const ApplyProp = Symbol('apply');
+
+const printProperty = property => {
+  if (property === ApplyProp) {
+    return '';
+  }
+
+  if (typeof property === 'symbol') {
+    return `[${property.toString()}]`;
+  }
+
+  return `.${property}`;
+};
+const printArg = arg => // Call toJSON on matchers directly to avoid wrapping them in quotes.
+isMatcher(arg) ? arg.toJSON() : jestMatcherUtils.printExpected(arg);
+const printCall = (property, args) => {
+  const prettyArgs = args.map(arg => printArg(arg)).join(', ');
+  const prettyProperty = printProperty(property);
+  return `${prettyProperty}(${prettyArgs})`;
+};
+const printReturns = ({
+  isError,
+  isPromise,
+  value
+}, min, max) => {
+  let thenPrefix = '';
+
+  if (isPromise) {
+    if (isError) {
+      thenPrefix += 'thenReject';
+    } else {
+      thenPrefix += 'thenResolve';
+    }
+  } else if (isError) {
+    thenPrefix += 'thenThrow';
+  } else {
+    thenPrefix += 'thenReturn';
+  }
+
+  return `.${thenPrefix}(${jestMatcherUtils.printExpected(value)}).between(${min}, ${max})`;
+};
+const printWhen = (property, args) => {
+  if (args) {
+    return `when(() => ${jestMatcherUtils.EXPECTED_COLOR(`mock${printCall(property, args)}`)})`;
+  }
+
+  return `when(() => ${jestMatcherUtils.EXPECTED_COLOR(`mock${printProperty(property)}`)})`;
+};
+const printExpectation = (property, args, returnValue, min, max) => `${printWhen(property, args)}${printReturns(returnValue, min, max)}`;
+const printRemainingExpectations = expectations => expectations.length ? `Remaining unmet expectations:
+ - ${expectations.map(e => e.toJSON()).join('\n - ')}` : 'There are no remaining unmet expectations.';
+
+class UnfinishedExpectation extends Error {
+  constructor(pendingExpectation) {
+    super(`There is an unfinished pending expectation:
+
+${pendingExpectation.toJSON()}
+
+Please finish it by setting a return value even if the value
+is undefined.`);
+  }
+
+}
+class MissingWhen extends Error {
+  constructor() {
+    super(`You tried setting a return value without an expectation.
+
+Every call to set a return value must be preceded by an expectation.`);
+  }
+
+}
+class UnexpectedAccess extends Error {
+  constructor(property, expectations) {
+    super(`Didn't expect ${jestMatcherUtils.EXPECTED_COLOR(`mock${printProperty(property)}`)} to be accessed.
+
+If you expect this property to be accessed then please
+set an expectation for it.
+
+${printRemainingExpectations(expectations)}`);
+  }
+
+}
+class UnexpectedCall extends Error {
+  constructor(property, args, expectations) {
+    super(`Didn't expect ${jestMatcherUtils.EXPECTED_COLOR(`mock${printCall(property, args)}`)} to be called.
+
+${printRemainingExpectations(expectations)}`);
+  }
+
+}
+class NotAMock extends Error {
+  constructor() {
+    super(`We couldn't find the mock.
+
+Make sure you're passing in an actual mock.`);
+  }
+
+}
+class UnmetExpectations extends Error {
+  constructor(expectations) {
+    super(`There are unmet expectations:
+
+ - ${expectations.map(e => e.toJSON()).join('\n - ')}`);
+  }
+
+}
+/**
+ * Merge property accesses and method calls for the same property
+ * into a single call.
+ *
+ * @example
+ * mergeCalls({ foo: [{ arguments: undefined }, { arguments: [1, 2, 3] }] }
+ * // returns { foo: [{ arguments: [1, 2, 3] } }
+ */
+
+const mergeCalls = callMap => new Map(Array.from(callMap.entries()).map(([property, calls]) => {
+  const hasMethodCalls = calls.some(call => call.arguments);
+  const hasPropertyAccesses = calls.some(call => !call.arguments);
+
+  if (hasMethodCalls && hasPropertyAccesses) {
+    return [property, calls.filter(call => call.arguments)];
+  }
+
+  return [property, calls];
+}));
+
+class UnexpectedCalls extends Error {
+  constructor(unexpectedCalls, expectations) {
+    const printedCalls = Array.from(mergeCalls(unexpectedCalls).entries()).map(([property, calls]) => calls.map(call => call.arguments ? jestMatcherUtils.EXPECTED_COLOR(`mock${printCall(property, call.arguments)}`) : jestMatcherUtils.EXPECTED_COLOR(`mock${printProperty(property)}`)).join('\n - ')).join('\n - ');
+    super(`The following calls were unexpected:
+
+ - ${printedCalls}
+
+${printRemainingExpectations(expectations)}`);
+  }
+
+}
+class NestedWhen extends Error {
+  constructor(parentProp, childProp) {
+    const snippet = `
+const parentMock = mock<T1>();
+const childMock = mock<T2>();
+
+when(() => childMock${printProperty(childProp)}).thenReturn(...);
+when(() => parentMock${printProperty(parentProp)}).thenReturn(childMock)
+`;
+    super(`Setting an expectation on a nested property is not supported.
+
+You can return an object directly when the first property is accessed,
+or you can even return a separate mock:
+${snippet}`);
+  }
+
+}
 
 /**
- * Use to test if an expectation on an argument is a custom matcher.
- */
-function isMatcher(f) {
-    return !!(f && f.__isMatcher);
-}
+ * Controls what happens when a property is accessed, or a call is made,
+ * and there are no expectations set for it.
+ */
+exports.Strictness = void 0;
+
+(function (Strictness) {
+  /**
+   * Any property that's accessed, or any call that's made, without a matching
+   * expectation, will throw immediately.
+   *
+   * @example
+   * type Service = { foo: (x: number) => number };
+   * const service = mock<Service>();
+   *
+   * // This will throw.
+   * const { foo } = service;
+   *
+   * // Will throw "Didn't expect foo to be accessed",
+   * // without printing the arguments.
+   * foo(42);
+   */
+  Strictness[Strictness["SUPER_STRICT"] = 0] = "SUPER_STRICT";
+  /**
+   * Properties with unmatched expectations will return functions that will
+   * throw if called. This can be useful if your code destructures a function
+   * but never calls it.
+   *
+   * It will also improve error messages for unexpected calls because arguments
+   * will be captured instead of throwing immediately on the property access.
+   *
+   * @example
+   * type Service = { foo: (x: number) => number };
+   * const service = mock<Service>();
+   *
+   * // This will not throw.
+   * const { foo } = service;
+   *
+   * // Will throw "Didn't expect foo(42) to be called".
+   * foo(42);
+   */
+
+  Strictness[Strictness["STRICT"] = 1] = "STRICT";
+})(exports.Strictness || (exports.Strictness = {}));
+
+const createProxy = traps => // eslint-disable-next-line no-empty-function
+new Proxy(
+/* istanbul ignore next */
+() => {}, {
+  get: (target, prop) => {
+    if (prop === 'bind') {
+      return (thisArg, ...args) => (...moreArgs) => traps.apply([...args, ...moreArgs]);
+    }
+
+    if (prop === 'apply') {
+      return (thisArg, args) => traps.apply(args || []);
+    }
+
+    if (prop === 'call') {
+      return (thisArg, ...args) => traps.apply(args);
+    }
+
+    return traps.property(prop);
+  },
+  apply: (target, thisArg, args) => traps.apply(args),
+  ownKeys: () => traps.ownKeys(),
+
+  getOwnPropertyDescriptor(target, prop) {
+    const keys = traps.ownKeys();
+
+    if (keys.includes(prop)) {
+      return {
+        configurable: true,
+        enumerable: true
+      };
+    }
+
+    return undefined;
+  }
+
+});
+
 /**
- * The default matcher that checks for deep equality.
- */
-var deepEquals = function (expected) {
-    return ({
-        matches: function (received) { return isEqual__default['default'](received, expected); },
-        __isMatcher: true,
-        toJSON: function () {
-            return printArg(expected);
-        },
-    });
-};
+ * Since `when` doesn't receive the mock subject (because we can't make it
+ * consistently return it from `mock()`, `mock.foo` and `mock.bar()`) we need
+ * to store a global state for the currently active mock.
+ *
+ * We also want to throw in the following case:
+ *
+ * ```
+ * when(() => mock()) // forgot returns here
+ * when(() => mock()) // should throw
+ * ```
+ *
+ * For that reason we can't just store the currently active mock, but also
+ * whether we finished the expectation or not.
+ */
+
+let activeMock;
+const setActiveMock = mock => {
+  activeMock = mock;
+};
+const getActiveMock = () => activeMock;
 /**
- * Match any value, including `undefined` and `null`.
+ * Store a global map of all mocks created and their state.
  *
- * @example
- * const fn = mock<(x: number, y: string) => number>();
- * when(fn(It.isAny(), It.isAny()).thenReturn(1);
+ * This is needed because we can't reliably pass the state between `when`
+ * and `thenReturn`.
+ */
+
+const mockMap = new Map();
+const getMockState = mock => {
+  if (mockMap.has(mock)) {
+    return mockMap.get(mock);
+  }
+
+  throw new NotAMock();
+};
+const setMockState = (mock, state) => {
+  mockMap.set(mock, state);
+};
+const getAllMocks = () => Array.from(mockMap.entries());
+
+/**
+ * Return the expectation's return value.
+ *
+ * If the value is an error then throw it.
+ *
+ * If the value is a promise then resolve/reject it.
+ */
+
+const returnOrThrow = ({
+  isError,
+  isPromise,
+  value
+}) => {
+  if (isError) {
+    if (isPromise) {
+      return Promise.reject(value);
+    }
+
+    if (value instanceof Error) {
+      throw value;
+    }
+
+    throw new Error(value);
+  }
+
+  if (isPromise) {
+    return Promise.resolve(value);
+  }
+
+  return value;
+};
+const createStub = (repo, pendingExpectation, getCurrentMode, concreteMatcher) => {
+  const stub = createProxy({
+    property: property => {
+      if (getCurrentMode() === Mode.CALL) {
+        return returnOrThrow(repo.get(property));
+      }
+
+      setActiveMock(stub);
+      pendingExpectation.start(repo, concreteMatcher); // eslint-disable-next-line no-param-reassign
+
+      pendingExpectation.property = property;
+      return createProxy({
+        property: childProp => {
+          pendingExpectation.clear();
+          throw new NestedWhen(property, childProp);
+        },
+        apply: args => {
+          // eslint-disable-next-line no-param-reassign
+          pendingExpectation.args = args;
+        },
+        ownKeys: () => {
+          throw new Error('Spreading during an expectation is not supported.');
+        }
+      });
+    },
+    apply: args => {
+      if (getCurrentMode() === Mode.CALL) {
+        return repo.apply(args);
+      }
+
+      setActiveMock(stub);
+      pendingExpectation.start(repo, concreteMatcher); // eslint-disable-next-line no-param-reassign
+
+      pendingExpectation.property = ApplyProp; // eslint-disable-next-line no-param-reassign
+
+      pendingExpectation.args = args;
+      return undefined;
+    },
+    ownKeys: () => {
+      if (getCurrentMode() === Mode.CALL) {
+        return repo.getAllProperties();
+      }
+
+      throw new Error('Spreading during an expectation is not supported.');
+    }
+  });
+  return stub;
+};
+
+/**
+ * An expectation repository for configurable levels of strictness.
+ */
+
+class FlexibleRepository {
+  constructor(strictness = exports.Strictness.SUPER_STRICT) {
+    this.strictness = void 0;
+    this.expectations = new Map();
+    this.expectedCallStats = new Map();
+    this.unexpectedCallStats = new Map();
+
+    this.apply = args => this.get(ApplyProp).value(...args);
+
+    this.handlePropertyWithMatchingExpectations = (property, expectations) => {
+      // Avoid recording call stats for function calls, since the property is an
+      // internal detail.
+      if (property !== ApplyProp) {
+        // An unexpected call could still happen later, if the property returns a
+        // function that will not match the given args.
+        this.recordExpected(property, undefined);
+      }
+
+      const propertyExpectation = expectations.find(e => e.expectation.matches(undefined));
+
+      if (propertyExpectation) {
+        this.countAndConsume(propertyExpectation);
+        return propertyExpectation.expectation.returnValue;
+      }
+
+      return {
+        value: (...args) => {
+          const callExpectation = expectations.find(e => e.expectation.matches(args));
+
+          if (callExpectation) {
+            this.recordExpected(property, args);
+            this.countAndConsume(callExpectation); // TODO: this is duplicated in stub
+
+            return returnOrThrow(callExpectation.expectation.returnValue);
+          }
+
+          return this.getValueForUnexpectedCall(property, args);
+        }
+      };
+    };
+
+    this.handlePropertyWithNoExpectations = property => {
+      switch (property) {
+        case 'toString':
+          return {
+            value: () => 'mock'
+          };
+
+        case '@@toStringTag':
+        case Symbol.toStringTag:
+        case 'name':
+          return {
+            value: 'mock'
+          };
+        // pretty-format
+
+        case '$$typeof':
+        case 'constructor':
+        case '@@__IMMUTABLE_ITERABLE__@@':
+        case '@@__IMMUTABLE_RECORD__@@':
+          return {
+            value: null
+          };
+
+        case MATCHER_SYMBOL:
+          return {
+            value: false
+          };
+
+        case ApplyProp:
+          return {
+            value: (...args) => this.getValueForUnexpectedCall(property, args)
+          };
+
+        default:
+          return this.getValueForUnexpectedAccess(property);
+      }
+    };
+
+    this.strictness = strictness;
+  }
+
+  add(expectation) {
+    const {
+      property
+    } = expectation;
+    const expectations = this.expectations.get(property) || [];
+    this.expectations.set(property, [...expectations, {
+      expectation,
+      matchCount: 0
+    }]);
+  }
+
+  clear() {
+    this.expectations.clear();
+    this.expectedCallStats.clear();
+    this.unexpectedCallStats.clear();
+  }
+
+  get(property) {
+    const expectations = this.expectations.get(property);
+
+    if (expectations && expectations.length) {
+      return this.handlePropertyWithMatchingExpectations(property, expectations);
+    }
+
+    return this.handlePropertyWithNoExpectations(property);
+  }
+
+  getAllProperties() {
+    return Array.from(this.expectations.keys());
+  }
+
+  getCallStats() {
+    return {
+      expected: this.expectedCallStats,
+      unexpected: this.unexpectedCallStats
+    };
+  }
+
+  getUnmet() {
+    return [].concat(...Array.from(this.expectations.values()).map(expectations => expectations.filter(e => e.expectation.min > e.matchCount).map(e => e.expectation)));
+  }
+
+  recordExpected(property, args) {
+    const calls = this.expectedCallStats.get(property) || [];
+    this.expectedCallStats.set(property, [...calls, {
+      arguments: args
+    }]);
+  }
+
+  recordUnexpected(property, args) {
+    const calls = this.unexpectedCallStats.get(property) || [];
+    this.unexpectedCallStats.set(property, [...calls, {
+      arguments: args
+    }]);
+  }
+
+  countAndConsume(expectation) {
+    // eslint-disable-next-line no-param-reassign
+    expectation.matchCount++;
+    this.consumeExpectation(expectation);
+  }
+
+  consumeExpectation(expectation) {
+    const {
+      property,
+      max
+    } = expectation.expectation;
+    const expectations = this.expectations.get(property);
+
+    if (expectation.matchCount === max) {
+      this.expectations.set(property, expectations.filter(e => e !== expectation));
+    }
+  }
+
+  getValueForUnexpectedCall(property, args) {
+    this.recordUnexpected(property, args);
+    throw new UnexpectedCall(property, args, this.getUnmet());
+  }
+
+  getValueForUnexpectedAccess(property) {
+    if (this.strictness === exports.Strictness.SUPER_STRICT) {
+      this.recordUnexpected(property, undefined);
+      throw new UnexpectedAccess(property, this.getUnmet());
+    }
+
+    return {
+      value: (...args) => {
+        this.recordUnexpected(property, args);
+        throw new UnexpectedCall(property, args, this.getUnmet());
+      }
+    };
+  }
+
+}
+
+/**
+ * Matches a call with more parameters than expected because it is assumed the
+ * compiler will check that those parameters are optional.
  *
- * instance(fn)(23, 'foobar') === 1
- */
-var isAny = function () { return ({
-    matches: function () { return true; },
-    __isMatcher: true,
-    /**
-     * Used by `pretty-format`.
-     */
-    toJSON: function () {
-        return 'anything';
-    },
-}); };
+ * @example
+ * new StrongExpectation(
+ *   'bar',
+ *   deepEquals([1, 2, 3]),
+ *   23
+ * ).matches('bar', [1, 2, 3]) === true;
+ */
+
+class StrongExpectation {
+  constructor(property, args, returnValue) {
+    this.property = void 0;
+    this.args = void 0;
+    this.returnValue = void 0;
+    this.matched = 0;
+    this.min = 1;
+    this.max = 1;
+    this.property = property;
+    this.args = args;
+    this.returnValue = returnValue;
+  }
+
+  setInvocationCount(min, max = 1) {
+    this.min = min;
+    this.max = max;
+  }
+
+  matches(args) {
+    if (!this.matchesArgs(args)) {
+      return false;
+    }
+
+    this.matched++;
+    return this.max === 0 || this.matched <= this.max;
+  }
+
+  isUnmet() {
+    return this.matched < this.min;
+  }
+
+  matchesArgs(received) {
+    if (this.args === undefined) {
+      return !received;
+    }
+
+    if (!received) {
+      return false;
+    }
+
+    return this.args.every((arg, i) => arg.matches(received[i]));
+  }
+
+  toJSON() {
+    return printExpectation(this.property, this.args, this.returnValue, this.min, this.max);
+  }
+
+}
+
+class RepoSideEffectPendingExpectation {
+  constructor(createExpectation) {
+    this.createExpectation = void 0;
+    this._repo = void 0;
+    this._concreteMatcher = void 0;
+    this._args = void 0;
+    this._property = '';
+    this.createExpectation = createExpectation;
+  }
+
+  start(repo, concreteMatcher) {
+    if (this._repo) {
+      throw new UnfinishedExpectation(this);
+    }
+
+    this.clear();
+    this._repo = repo;
+    this._concreteMatcher = concreteMatcher;
+  }
+
+  set property(value) {
+    this._property = value;
+  }
+
+  set args(value) {
+    this._args = value;
+  }
+
+  finish(returnValue) {
+    if (!this._repo || !this._concreteMatcher) {
+      throw new MissingWhen();
+    }
+
+    const expectation = this.createExpectation(this._property, this._args, returnValue, this._concreteMatcher);
+
+    this._repo.add(expectation);
+
+    this.clear();
+    return expectation;
+  }
+
+  clear() {
+    this._repo = undefined;
+    this._args = undefined;
+    this._property = '';
+  }
+
+  toJSON() {
+    return printWhen(this._property, this._args);
+  }
+
+}
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
 /**
  * Match a custom predicate.
  *
  * @param cb Will receive the value and returns whether it matches.
+ * @param toJSON An optional function that should return a string that will be
+ *   used when the matcher needs to be printed in an error message. By default,
+ *   it stringifies `cb`.
  *
  * @example
  * const fn = mock<(x: number) => number>();
- * when(fn(It.matches(x => x >= 0)).returns(42);
+ * when(() => fn(It.matches(x => x >= 0))).returns(42);
+ *
+ * fn(2) === 42
+ * fn(-1) // throws
+ */
+
+const matches = (cb, {
+  toJSON = () => `matches(${cb.toString()})`
+} = {}) => {
+  const matcher = {
+    [MATCHER_SYMBOL]: true,
+    matches: arg => cb(arg),
+    toJSON
+  };
+  return matcher;
+};
+
+const removeUndefined = object => {
+  if (Array.isArray(object)) {
+    return object.map(x => removeUndefined(x));
+  }
+
+  if (!lodash.isObjectLike(object)) {
+    return object;
+  }
+
+  return lodash.omitBy(object, lodash.isUndefined);
+};
+/**
+ * Compare values using deep equality.
+ *
+ * @param expected
+ * @param strict By default, this matcher will treat a missing key in an object
+ *   and a key with the value `undefined` as not equal. It will also consider
+ *   non `Object` instances with different constructors as not equal. Setting
+ *   this to `false` will consider the objects in both cases as equal.
+ *
+ * @see It.is A matcher that uses strict equality.
+ */
+
+
+const deepEquals = (expected, {
+  strict = true
+} = {}) => matches(actual => {
+  if (strict) {
+    return lodash.isEqual(actual, expected);
+  }
+
+  return lodash.isEqual(removeUndefined(actual), removeUndefined(expected));
+}, {
+  toJSON: () => printArg(expected)
+});
+/**
+ * Compare values using `Object.is`.
+ *
+ * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
  *
- * instance(fn)(2) === 42
- * instance(fn)(-1) // throws
- */
-var matches = function (cb) {
-    return ({
-        matches: function (arg) { return cb(arg); },
-        __isMatcher: true,
-        toJSON: function () {
-            return "matches(" + cb.toString() + ")";
-        },
-    });
-};
+ * @see It.deepEquals A matcher that uses deep equality.
+ */
+
+
+const is = expected => matches(actual => Object.is(actual, expected), {
+  toJSON: () => `${jestMatcherUtils.printExpected(expected)}`
+});
+/**
+ * Match any value, including `undefined` and `null`.
+ *
+ * @example
+ * const fn = mock<(x: number, y: string) => number>();
+ * when(() => fn(It.isAny(), It.isAny())).thenReturn(1);
+ *
+ * fn(23, 'foobar') === 1
+ */
+
+
+const isAny = () => matches(() => true, {
+  toJSON: () => 'anything'
+});
 /**
  * Recursively match an object.
  *
@@ -148,48 +781,41 @@ var matches = function (cb) {
  *
  * @example
  * const fn = mock<(foo: { x: number, y: number }) => number>();
- * when(fn(It.isObject({ x: 23 }).returns(42);
+ * when(() => fn(It.isObject({ x: 23 }))).returns(42);
  *
- * instance(fn)({ x: 100, y: 200 }) // throws
- * instance(fn)({ x: 23, y: 200 }) // returns 42
+ * fn({ x: 100, y: 200 }) // throws
+ * fn({ x: 23, y: 200 }) // returns 42
  *
  * @example
  * It.isObject({ foo: It.isString() })
- */
-var isObject = function (partial) {
-    return ({
-        __isMatcher: true,
-        matches: function (arg) {
-            return isMatchWith__default['default'](arg, partial || {}, function (argValue, partialValue) {
-                if (isMatcher(partialValue)) {
-                    return partialValue.matches(argValue);
-                }
-                // Let lodash handle it otherwise.
-                return undefined;
-            });
-        },
-        toJSON: function () {
-            return partial ? "object(" + jestMatcherUtils.printExpected(partial) + ")" : 'object';
-        },
-    });
-};
+ */
+
+
+const isObject = partial => matches(actual => lodash.isMatchWith(actual, partial || {}, (argValue, partialValue) => {
+  if (isMatcher(partialValue)) {
+    return partialValue.matches(argValue);
+  } // Let lodash handle it otherwise.
+
+
+  return undefined;
+}), {
+  toJSON: () => partial ? `object(${jestMatcherUtils.printExpected(partial)})` : 'object'
+});
 /**
  * Match any number.
  *
  * @example
  * const fn = mock<(x: number) => number>();
- * when(fn(It.isNumber()).returns(42);
+ * when(() => fn(It.isNumber())).returns(42);
  *
- * instance(fn)(20.5) === 42
- * instance(fn)(NaN) // throws
- */
-var isNumber = function () {
-    return ({
-        __isMatcher: true,
-        matches: function (arg) { return typeof arg === 'number' && !Number.isNaN(arg); },
-        toJSON: function () { return 'number'; },
-    });
-};
+ * fn(20.5) === 42
+ * fn(NaN) // throws
+ */
+
+
+const isNumber = () => matches(actual => typeof actual === 'number' && !Number.isNaN(actual), {
+  toJSON: () => 'number'
+});
 /**
  * Match a string, potentially by a pattern.
  *
@@ -198,35 +824,37 @@ var isNumber = function () {
  *
  * @example
  * const fn = mock<(x: string, y: string) => number>();
- * when(fn(It.isString(), It.isString({ containing: 'bar' }).returns(42);
+ * when(() => fn(It.isString(), It.isString({ containing: 'bar' }))).returns(42);
  *
- * instance(fn)('foo', 'baz') // throws
- * instance(fn)('foo', 'bar') === 42
- */
-var isString = function (_a) {
-    var _b = _a === void 0 ? {} : _a, matching = _b.matching, containing = _b.containing;
-    if (matching && containing) {
-        throw new Error('You can only pass `matching` or `containing`, not both.');
-    }
-    return {
-        __isMatcher: true,
-        matches: function (arg) {
-            var _a;
-            if (typeof arg !== 'string') {
-                return false;
-            }
-            if (containing) {
-                return arg.indexOf(containing) !== -1;
-            }
-            return (_a = matching === null || matching === void 0 ? void 0 : matching.test(arg)) !== null && _a !== void 0 ? _a : true;
-        },
-        toJSON: function () {
-            return containing || matching
-                ? "string(" + jestMatcherUtils.printExpected(containing || matching) + ")"
-                : 'string';
-        },
-    };
-};
+ * fn('foo', 'baz') // throws
+ * fn('foo', 'bar') === 42
+ */
+
+
+const isString = ({
+  matching,
+  containing
+} = {}) => {
+  if (matching && containing) {
+    throw new Error('You can only pass `matching` or `containing`, not both.');
+  }
+
+  return matches(actual => {
+    var _matching$test;
+
+    if (typeof actual !== 'string') {
+      return false;
+    }
+
+    if (containing) {
+      return actual.indexOf(containing) !== -1;
+    }
+
+    return (_matching$test = matching == null ? void 0 : matching.test(actual)) != null ? _matching$test : true;
+  }, {
+    toJSON: () => containing || matching ? `string(${jestMatcherUtils.printExpected(containing || matching)})` : 'string'
+  });
+};
 /**
  * Match an array.
  *
@@ -237,45 +865,42 @@ var isString = function (_a) {
  *
  * @example
  * const fn = mock<(arr: number[]) => number>();
- * when(fn(It.isArray())).thenReturn(1);
- * when(fn(It.isArray([2, 3))).thenReturn(2);
+ * when(() => fn(It.isArray())).thenReturn(1);
+ * when(() => fn(It.isArray([2, 3]))).thenReturn(2);
  *
- * instance(fn)({ length: 1, 0: 42 }) // throws
- * instance(fn)([]]) === 1
- * instance(fn)([3, 2, 1) === 2
+ * fn({ length: 1, 0: 42 }) // throws
+ * fn([]) === 1
+ * fn([3, 2, 1]) === 2
  *
  * @example
- * It.isArray([It.isString({ containing: 'foobar' }))
- */
-var isArray = function (containing) {
-    return ({
-        __isMatcher: true,
-        matches: function (arg) {
-            if (!Array.isArray(arg)) {
-                return false;
-            }
-            if (!containing) {
-                return true;
-            }
-            return containing.every(function (x) {
-                return arg.find(function (y) {
-                    if (isMatcher(x)) {
-                        return x.matches(y);
-                    }
-                    return isEqual__default['default'](x, y);
-                }) !== undefined;
-            });
-        },
-        toJSON: function () {
-            return containing ? "array(" + jestMatcherUtils.printExpected(containing) + ")" : 'array';
-        },
-    });
-};
+ * It.isArray([It.isString({ containing: 'foobar' })])
+ */
+
+
+const isArray = containing => matches(actual => {
+  if (!Array.isArray(actual)) {
+    return false;
+  }
+
+  if (!containing) {
+    return true;
+  }
+
+  return containing.every(x => actual.find(y => {
+    if (isMatcher(x)) {
+      return x.matches(y);
+    }
+
+    return deepEquals(x).matches(y);
+  }) !== undefined);
+}, {
+  toJSON: () => containing ? `array(${jestMatcherUtils.printExpected(containing)})` : 'array'
+});
 /**
  * Matches anything and stores the received value.
  *
  * This should not be needed for most cases, but can be useful if you need
- * access to a complex argument outside of the expectation e.g. to test a
+ * access to a complex argument outside the expectation e.g. to test a
  * callback.
  *
  * @param name If given, this name will be printed in error messages.
@@ -283,629 +908,253 @@ var isArray = function (containing) {
  * @example
  * const fn = mock<(cb: (value: number) => number) => void>();
  * const matcher = It.willCapture();
- * when(fn(matcher)).thenReturn();
+ * when(() => fn(matcher)).thenReturn();
  *
- * instance(fn)(x => x + 1);
+ * fn(x => x + 1);
  * matcher.value?.(3) === 4
- */
-var willCapture = function (name) {
-    var capturedValue;
-    return {
-        __isMatcher: true,
-        matches: function (value) {
-            capturedValue = value;
-            return true;
-        },
-        toJSON: function () {
-            return name !== null && name !== void 0 ? name : 'captures';
-        },
-        get value() {
-            return capturedValue;
-        },
-    };
-};
+ */
+
+
+const willCapture = name => {
+  let capturedValue;
+  const matcher = {
+    [MATCHER_SYMBOL]: true,
+    matches: actual => {
+      capturedValue = actual;
+      return true;
+    },
+    toJSON: () => name != null ? name : 'captures',
+
+    get value() {
+      return capturedValue;
+    }
+
+  };
+  return matcher;
+};
 /**
  * Contains argument matchers that can be used to ignore arguments in an
  * expectation or to match complex arguments.
- */
-var It = {
-    isAny: isAny,
-    matches: matches,
-    isObject: isObject,
-    isNumber: isNumber,
-    isString: isString,
-    isArray: isArray,
-    willCapture: willCapture,
-};
+ */
+
 
-var printProperty = function (property) {
-    if (property === ApplyProp) {
-        return '';
-    }
-    if (typeof property === 'symbol') {
-        return "[" + property.toString() + "]";
-    }
-    return "." + property;
-};
-var printArg = function (arg) {
-    // Call toJSON on matchers directly to avoid wrapping them in quotes.
-    return isMatcher(arg) ? arg.toJSON() : jestMatcherUtils.printExpected(arg);
-};
-var printCall = function (property, args) {
-    // TODO: don't leak the matcher concept here
-    var prettyArgs = args.map(function (arg) { return printArg(arg); }).join(', ');
-    var prettyProperty = printProperty(property);
-    return prettyProperty + "(" + prettyArgs + ")";
-};
-var printReturns = function (_a, min, max) {
-    var isError = _a.isError, isPromise = _a.isPromise, value = _a.value;
-    var thenPrefix = '';
-    if (isPromise) {
-        if (isError) {
-            thenPrefix += 'thenReject';
-        }
-        else {
-            thenPrefix += 'thenResolve';
-        }
-    }
-    else if (isError) {
-        thenPrefix += 'thenThrow';
-    }
-    else {
-        thenPrefix += 'thenReturn';
-    }
-    return "." + thenPrefix + "(" + jestMatcherUtils.printExpected(value) + ").between(" + min + ", " + max + ")";
-};
-var printWhen = function (property, args) {
-    if (args) {
-        return "when(" + jestMatcherUtils.EXPECTED_COLOR("mock" + printCall(property, args)) + ")";
-    }
-    return "when(" + jestMatcherUtils.EXPECTED_COLOR("mock" + printProperty(property)) + ")";
-};
-var printExpectation = function (property, args, returnValue, min, max) { return "" + printWhen(property, args) + printReturns(returnValue, min, max); };
-var printRemainingExpectations = function (expectations) {
-    return expectations.length
-        ? "Remaining unmet expectations:\n - " + expectations.map(function (e) { return e.toJSON(); }).join('\n - ')
-        : 'There are no remaining unmet expectations.';
+const It = {
+  matches,
+  deepEquals,
+  is,
+  isAny,
+  isObject,
+  isNumber,
+  isString,
+  isArray,
+  willCapture
 };
 
-var UnfinishedExpectation = /** @class */ (function (_super) {
-    __extends(UnfinishedExpectation, _super);
-    function UnfinishedExpectation(pendingExpectation) {
-        return _super.call(this, "There is an unfinished pending expectation:\n\n" + pendingExpectation.toJSON() + "\n\nPlease finish it by setting a return value even if the value\nis undefined.\n\nThis may have been caused by using the mock without getting\nan instance from it first. Please use instance(mock) and use\nthat value in the code you're testing.") || this;
-    }
-    return UnfinishedExpectation;
-}(Error));
-var MissingWhen = /** @class */ (function (_super) {
-    __extends(MissingWhen, _super);
-    function MissingWhen() {
-        return _super.call(this, "You tried setting a return value without an expectation.\n\nEvery call to set a return value must be preceded by an expectation.") || this;
-    }
-    return MissingWhen;
-}(Error));
-var UnexpectedAccess = /** @class */ (function (_super) {
-    __extends(UnexpectedAccess, _super);
-    function UnexpectedAccess(property, expectations) {
-        return _super.call(this, "Didn't expect " + jestMatcherUtils.EXPECTED_COLOR("mock" + printProperty(property)) + " to be accessed.\n\nIf you expect this property to be accessed then please\nset an expectation for it.\n\n" + printRemainingExpectations(expectations)) || this;
-    }
-    return UnexpectedAccess;
-}(Error));
-var UnexpectedCall = /** @class */ (function (_super) {
-    __extends(UnexpectedCall, _super);
-    function UnexpectedCall(property, args, expectations) {
-        return _super.call(this, "Didn't expect " + jestMatcherUtils.EXPECTED_COLOR("mock" + printCall(property, args)) + " to be called.\n\n" + printRemainingExpectations(expectations)) || this;
-    }
-    return UnexpectedCall;
-}(Error));
-var NotAMock = /** @class */ (function (_super) {
-    __extends(NotAMock, _super);
-    function NotAMock() {
-        return _super.call(this, "We couldn't find the mock.\n\nMake sure you're passing in an actual mock.") || this;
-    }
-    return NotAMock;
-}(Error));
-var UnmetExpectations = /** @class */ (function (_super) {
-    __extends(UnmetExpectations, _super);
-    function UnmetExpectations(expectations) {
-        return _super.call(this, "There are unmet expectations:\n\n - " + expectations.map(function (e) { return e.toJSON(); }).join('\n - ')) || this;
-    }
-    return UnmetExpectations;
-}(Error));
+const defaults = {
+  concreteMatcher: It.deepEquals,
+  strictness: exports.Strictness.STRICT
+};
+let currentDefaults = defaults;
 /**
- * Merge property accesses and method calls for the same property
- * into a single call.
+ * Override strong-mock's defaults.
  *
- * @example
- * mergeCalls({ foo: [{ arguments: undefined }, { arguments: [1, 2, 3] }] }
- * // returns { foo: [{ arguments: [1, 2, 3] } }
- */
-var mergeCalls = function (callMap) {
-    return new Map(Array.from(callMap.entries()).map(function (_a) {
-        var _b = __read(_a, 2), property = _b[0], calls = _b[1];
-        var hasMethodCalls = calls.some(function (call) { return call.arguments; });
-        var hasPropertyAccesses = calls.some(function (call) { return !call.arguments; });
-        if (hasMethodCalls && hasPropertyAccesses) {
-            return [property, calls.filter(function (call) { return call.arguments; })];
-        }
-        return [property, calls];
-    }));
-};
-var UnexpectedCalls = /** @class */ (function (_super) {
-    __extends(UnexpectedCalls, _super);
-    function UnexpectedCalls(unexpectedCalls, expectations) {
-        var _this = this;
-        var printedCalls = Array.from(mergeCalls(unexpectedCalls).entries())
-            .map(function (_a) {
-            var _b = __read(_a, 2), property = _b[0], calls = _b[1];
-            return calls
-                .map(function (call) {
-                return call.arguments
-                    ? jestMatcherUtils.EXPECTED_COLOR("mock" + printCall(property, call.arguments))
-                    : jestMatcherUtils.EXPECTED_COLOR("mock" + printProperty(property));
-            })
-                .join('\n - ');
-        })
-            .join('\n - ');
-        _this = _super.call(this, "The following calls were unexpected:\n\n - " + printedCalls + "\n\n" + printRemainingExpectations(expectations)) || this;
-        return _this;
-    }
-    return UnexpectedCalls;
-}(Error));
-var NestedWhen = /** @class */ (function (_super) {
-    __extends(NestedWhen, _super);
-    function NestedWhen(parentProp, childProp) {
-        var _this = this;
-        var snippet = "\nconst parentMock = mock<T1>();\nconst childMock = mock<T2>();\n\nwhen(childMock" + printProperty(childProp) + ").thenReturn(...);\nwhen(parentMock" + printProperty(parentProp) + ").thenReturn(instance(childMock))\n";
-        _this = _super.call(this, "Setting an expectation on a nested property is not supported.\n\nYou can return an object directly when the first property is accessed,\nor you can even return a separate mock:\n" + snippet) || this;
-        return _this;
-    }
-    return NestedWhen;
-}(Error));
+ * @param newDefaults These will be applied to the library defaults. Multiple
+ *   calls don't stack e.g. calling this with `{}` will clear any previously
+ *   applied defaults.
+ */
+
+const setDefaults = newDefaults => {
+  currentDefaults = _extends({}, defaults, newDefaults);
+};
 
+const strongExpectationFactory = (property, args, returnValue, concreteMatcher) => new StrongExpectation(property, // Wrap every non-matcher in the default matcher.
+args == null ? void 0 : args.map(arg => isMatcher(arg) ? arg : concreteMatcher(arg)), returnValue);
+
+var Mode;
+
+(function (Mode) {
+  Mode[Mode["EXPECT"] = 0] = "EXPECT";
+  Mode[Mode["CALL"] = 1] = "CALL";
+})(Mode || (Mode = {}));
+
+let currentMode = Mode.CALL;
+const setMode = mode => {
+  currentMode = mode;
+};
 /**
- * Since `when()` doesn't receive the mock subject (because we can't make it
- * consistently return it from `mock()`, `mock.foo` and `mock.bar()`) we need
- * to store a global state for the currently active mock.
+ * Create a type safe mock.
  *
- * We also want to throw in the following case:
+ * @see {@link when} Set expectations on the mock using `when`.
  *
- * ```
- * when(mock()) // forgot returns here
- * when(mock()) // should throw
- * ```
+ * @param options Configure the options for this specific mock, overriding any
+ *   defaults that were set with {@link setDefaults}.
+ * @param options.strictness Controls what happens when a property is accessed,
+ *   or a call is made, and there are no expectations set for it.
+ * @param options.concreteMatcher The matcher that will be used when one isn't specified explicitly.
  *
- * For that reason we can't just store the currently active mock, but also
- * whether we finished the expectation or not.
- */
-var activeMock;
-var setActiveMock = function (mock) {
-    activeMock = mock;
-};
-var getActiveMock = function () { return activeMock; };
-/**
- * Store a global map of all mocks created and their state.
+ * @example
+ * const fn = mock<() => number>();
  *
- * This is needed because we can't reliably pass the state between `when`,
- * `thenReturn` and `instance`.
- */
-var mockMap = new Map();
-var getMockState = function (mock) {
-    if (mockMap.has(mock)) {
-        return mockMap.get(mock);
-    }
-    throw new NotAMock();
-};
-var setMockState = function (mock, state) {
-    mockMap.set(mock, state);
-};
-var getAllMocks = function () {
-    return Array.from(mockMap.entries());
-};
+ * when(() => fn()).thenReturn(23);
+ *
+ * fn() === 23;
+ */
 
-var createProxy = function (traps) {
-    // eslint-disable-next-line no-empty-function
-    return new Proxy(/* istanbul ignore next */ function () { }, {
-        get: function (target, prop) {
-            if (prop === 'bind') {
-                return function (thisArg) {
-                    var args = [];
-                    for (var _i = 1; _i < arguments.length; _i++) {
-                        args[_i - 1] = arguments[_i];
-                    }
-                    return function () {
-                        var moreArgs = [];
-                        for (var _i = 0; _i < arguments.length; _i++) {
-                            moreArgs[_i] = arguments[_i];
-                        }
-                        return traps.apply(__spreadArray(__spreadArray([], __read(args), false), __read(moreArgs)));
-                    };
-                };
-            }
-            if (prop === 'apply') {
-                return function (thisArg, args) {
-                    return traps.apply(args || []);
-                };
-            }
-            if (prop === 'call') {
-                return function (thisArg) {
-                    var args = [];
-                    for (var _i = 1; _i < arguments.length; _i++) {
-                        args[_i - 1] = arguments[_i];
-                    }
-                    return traps.apply(args);
-                };
-            }
-            return traps.property(prop);
-        },
-        apply: function (target, thisArg, args) { return traps.apply(args); },
-        ownKeys: function () { return traps.ownKeys(); },
-        getOwnPropertyDescriptor: function (target, prop) {
-            var keys = traps.ownKeys();
-            if (keys.includes(prop)) {
-                return {
-                    configurable: true,
-                    enumerable: true,
-                };
-            }
-            return undefined;
-        },
-    });
+const mock = ({
+  strictness,
+  concreteMatcher
+} = {}) => {
+  const pendingExpectation = new RepoSideEffectPendingExpectation(strongExpectationFactory);
+  const options = {
+    strictness: strictness != null ? strictness : currentDefaults.strictness,
+    concreteMatcher: concreteMatcher != null ? concreteMatcher : currentDefaults.concreteMatcher
+  };
+  const repository = new FlexibleRepository(options.strictness);
+  const stub = createStub(repository, pendingExpectation, () => currentMode, options.concreteMatcher);
+  setMockState(stub, {
+    repository,
+    pendingExpectation,
+    options
+  });
+  return stub;
 };
 
-// Keep a cache of all mock instances so that we can return a stable reference
-// if `instance` is used multiple times.
-var cache = new Map();
-/**
- * Return the expectation's return value.
- *
- * If the value is an error then throw it.
- *
- * If the value is a promise then resolve/reject it.
- */
-var returnOrThrow = function (_a) {
-    var isError = _a.isError, isPromise = _a.isPromise, value = _a.value;
-    if (isError) {
-        if (isPromise) {
-            return Promise.reject(value);
-        }
-        if (value instanceof Error) {
-            throw value;
-        }
-        throw new Error(value);
-    }
-    if (isPromise) {
-        return Promise.resolve(value);
-    }
-    return value;
-};
+const createInvocationCount = expectation => ({
+  between(min, max) {
+    expectation.setInvocationCount(min, max);
+  },
+
+  /* istanbul ignore next */
+  times(exact) {
+    expectation.setInvocationCount(exact, exact);
+  },
+
+  /* istanbul ignore next */
+  anyTimes() {
+    expectation.setInvocationCount(0, 0);
+  },
+
+  /* istanbul ignore next */
+  atLeast(min) {
+    expectation.setInvocationCount(min, Infinity);
+  },
+
+  /* istanbul ignore next */
+  atMost(max) {
+    expectation.setInvocationCount(0, max);
+  },
+
+  /* istanbul ignore next */
+  once() {
+    expectation.setInvocationCount(1, 1);
+  },
+
+  /* istanbul ignore next */
+  twice() {
+    expectation.setInvocationCount(2, 2);
+  }
+  /* eslint-enable no-param-reassign, no-multi-assign */
+
+
+});
+
 /**
- * Get a real instance from the mock that you can pass to your code under test.
- */
-var instance = function (mock) {
-    if (cache.has(mock)) {
-        return cache.get(mock);
-    }
-    var repository = getMockState(mock).repository;
-    var proxy = createProxy({
-        property: function (property) { return returnOrThrow(repository.get(property)); },
-        apply: function (args) {
-            var fn = repository.get(ApplyProp);
-            // This is not using `returnOrThrow` because the repo will use it.
-            return fn.value.apply(fn, __spreadArray([], __read(args)));
-        },
-        ownKeys: function () { return repository.getAllProperties(); },
-    });
-    cache.set(mock, proxy);
-    return proxy;
+ * Set a return value for the currently pending expectation.
+ */
+
+const finishPendingExpectation = (returnValue, pendingExpectation) => {
+  const finishedExpectation = pendingExpectation.finish(returnValue);
+  pendingExpectation.clear();
+  return createInvocationCount(finishedExpectation);
 };
 
-var RepoSideEffectPendingExpectation = /** @class */ (function () {
-    function RepoSideEffectPendingExpectation(createExpectation) {
-        this.createExpectation = createExpectation;
-        this._property = '';
-    }
-    RepoSideEffectPendingExpectation.prototype.start = function (repo) {
-        if (this._repo) {
-            throw new UnfinishedExpectation(this);
-        }
-        this.clear();
-        this._repo = repo;
-    };
-    Object.defineProperty(RepoSideEffectPendingExpectation.prototype, "property", {
-        set: function (value) {
-            this._property = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RepoSideEffectPendingExpectation.prototype, "args", {
-        set: function (value) {
-            this._args = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    RepoSideEffectPendingExpectation.prototype.finish = function (returnValue) {
-        if (!this._repo) {
-            throw new MissingWhen();
-        }
-        var expectation = this.createExpectation(this._property, this._args, returnValue);
-        this._repo.add(expectation);
-        this.clear();
-        return expectation;
-    };
-    RepoSideEffectPendingExpectation.prototype.clear = function () {
-        this._repo = undefined;
-        this._args = undefined;
-        this._property = '';
-    };
-    RepoSideEffectPendingExpectation.prototype.toJSON = function () {
-        return printWhen(this._property, this._args);
-    };
-    return RepoSideEffectPendingExpectation;
-}());
+const getError = errorOrMessage => {
+  if (typeof errorOrMessage === 'string') {
+    return new Error(errorOrMessage);
+  }
 
-/**
- * Compare received arguments against matchers.
- *
- * Matches a call with more parameters than expected because it is assumed the
- * compiler will check that those parameters are optional.
- *
- * @example
- * new MatcherExpectation(
- *   'bar',
- *   deepEquals([1, 2, 3]),
- *   23
- * ).matches('bar', [1, 2, 3]) === true;
- */
-var MatcherExpectation = /** @class */ (function () {
-    function MatcherExpectation(property, args, returnValue) {
-        this.property = property;
-        this.args = args;
-        this.returnValue = returnValue;
-        this.matched = 0;
-        this.min = 1;
-        this.max = 1;
-    }
-    MatcherExpectation.prototype.setInvocationCount = function (min, max) {
-        if (max === void 0) { max = 1; }
-        this.min = min;
-        this.max = max;
-    };
-    MatcherExpectation.prototype.matches = function (args) {
-        if (!this.matchesArgs(args)) {
-            return false;
-        }
-        this.matched++;
-        return this.max === 0 || this.matched <= this.max;
-    };
-    MatcherExpectation.prototype.isUnmet = function () {
-        return this.matched < this.min;
-    };
-    MatcherExpectation.prototype.matchesArgs = function (received) {
-        if (this.args === undefined) {
-            return !received;
-        }
-        if (!received) {
-            return false;
-        }
-        return this.args.every(function (arg, i) { return arg.matches(received[i]); });
-    };
-    MatcherExpectation.prototype.toJSON = function () {
-        return printExpectation(this.property, this.args, this.returnValue, this.min, this.max);
-    };
-    return MatcherExpectation;
-}());
-
-var BaseRepository = /** @class */ (function () {
-    function BaseRepository() {
-        this.expectations = new Map();
-        this.expectedCallStats = new Map();
-        this.unexpectedCallStats = new Map();
-    }
-    BaseRepository.prototype.add = function (expectation) {
-        var property = expectation.property;
-        var expectations = this.expectations.get(property) || [];
-        this.expectations.set(property, __spreadArray(__spreadArray([], __read(expectations), false), [
-            {
-                expectation: expectation,
-                matchCount: 0,
-            },
-        ]));
-    };
-    BaseRepository.prototype.clear = function () {
-        this.expectations.clear();
-        this.expectedCallStats.clear();
-        this.unexpectedCallStats.clear();
-    };
-    BaseRepository.prototype.get = function (property) {
-        var _this = this;
-        var expectations = this.expectations.get(property);
-        if (expectations && expectations.length) {
-            // We record that an expected property access has happened, but an
-            // unexpected call could still happen later.
-            this.recordExpected(property, undefined);
-            var propertyExpectation = expectations.find(function (e) {
-                return e.expectation.matches(undefined);
-            });
-            if (propertyExpectation) {
-                this.countAndConsume(propertyExpectation);
-                return propertyExpectation.expectation.returnValue;
-            }
-            return {
-                value: function () {
-                    var args = [];
-                    for (var _i = 0; _i < arguments.length; _i++) {
-                        args[_i] = arguments[_i];
-                    }
-                    var callExpectation = expectations.find(function (e) {
-                        return e.expectation.matches(args);
-                    });
-                    if (callExpectation) {
-                        _this.recordExpected(property, args);
-                        _this.countAndConsume(callExpectation);
-                        // TODO: this is duplicated in instance
-                        return returnOrThrow(callExpectation.expectation.returnValue);
-                    }
-                    _this.recordUnexpected(property, args);
-                    return _this.getValueForUnexpectedCall(property, args);
-                },
-            };
-        }
-        switch (property) {
-            case 'toString':
-                return { value: function () { return 'mock'; } };
-            case '@@toStringTag':
-            case Symbol.toStringTag:
-            case 'name':
-                return { value: 'mock' };
-            // pretty-format
-            case '$$typeof':
-            case 'constructor':
-            case '@@__IMMUTABLE_ITERABLE__@@':
-            case '@@__IMMUTABLE_RECORD__@@':
-                return { value: null };
-            case '__isMatcher':
-                return { value: false };
-            case ApplyProp:
-                return {
-                    value: function () {
-                        var args = [];
-                        for (var _i = 0; _i < arguments.length; _i++) {
-                            args[_i] = arguments[_i];
-                        }
-                        _this.recordUnexpected(property, args);
-                        return _this.getValueForUnexpectedCall(property, args);
-                    },
-                };
-            default:
-                this.recordUnexpected(property, undefined);
-                return this.getValueForUnexpectedAccess(property);
-        }
-    };
-    BaseRepository.prototype.getAllProperties = function () {
-        return Array.from(this.expectations.keys());
-    };
-    BaseRepository.prototype.getCallStats = function () {
-        return {
-            expected: this.expectedCallStats,
-            unexpected: this.unexpectedCallStats,
-        };
-    };
-    BaseRepository.prototype.getUnmet = function () {
-        var _a;
-        return (_a = []).concat.apply(_a, __spreadArray([], __read(Array.from(this.expectations.values()).map(function (expectations) {
-            return expectations
-                .filter(function (e) { return e.expectation.min > e.matchCount; })
-                .map(function (e) { return e.expectation; });
-        }))));
-    };
-    /**
-     * Record an expected property access/method call.
-     */
-    BaseRepository.prototype.recordExpected = function (property, args) {
-        var calls = this.expectedCallStats.get(property) || [];
-        this.expectedCallStats.set(property, __spreadArray(__spreadArray([], __read(calls), false), [{ arguments: args }]));
-    };
-    /**
-     * Record an unexpected property access/method call.
-     */
-    BaseRepository.prototype.recordUnexpected = function (property, args) {
-        var calls = this.unexpectedCallStats.get(property) || [];
-        this.unexpectedCallStats.set(property, __spreadArray(__spreadArray([], __read(calls), false), [{ arguments: args }]));
-    };
-    BaseRepository.prototype.countAndConsume = function (expectation) {
-        // eslint-disable-next-line no-param-reassign
-        expectation.matchCount++;
-        this.consumeExpectation(expectation);
-    };
-    return BaseRepository;
-}());
+  if (errorOrMessage instanceof Error) {
+    return errorOrMessage;
+  }
 
-/**
- * Throw if no expectation matches.
- */
-var StrongRepository = /** @class */ (function (_super) {
-    __extends(StrongRepository, _super);
-    function StrongRepository() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    StrongRepository.prototype.consumeExpectation = function (expectation) {
-        var _a = expectation.expectation, property = _a.property, max = _a.max;
-        var expectations = this.expectations.get(property);
-        if (expectation.matchCount === max) {
-            this.expectations.set(property, expectations.filter(function (e) { return e !== expectation; }));
-        }
-    };
-    StrongRepository.prototype.getValueForUnexpectedCall = function (property, args) {
-        throw new UnexpectedCall(property, args, this.getUnmet());
-    };
-    StrongRepository.prototype.getValueForUnexpectedAccess = function (property) {
-        throw new UnexpectedAccess(property, this.getUnmet());
-    };
-    return StrongRepository;
-}(BaseRepository));
-
-var createStub = function (repo, pendingExpectation) {
-    var stub = createProxy({
-        property: function (property) {
-            setActiveMock(stub);
-            pendingExpectation.start(repo);
-            // eslint-disable-next-line no-param-reassign
-            pendingExpectation.property = property;
-            return createProxy({
-                property: function (childProp) {
-                    pendingExpectation.clear();
-                    throw new NestedWhen(property, childProp);
-                },
-                apply: function (args) {
-                    // eslint-disable-next-line no-param-reassign
-                    pendingExpectation.args = args;
-                },
-                ownKeys: function () {
-                    throw new Error('Spreading during an expectation is not supported.');
-                },
-            });
-        },
-        apply: function (args) {
-            setActiveMock(stub);
-            pendingExpectation.start(repo);
-            // eslint-disable-next-line no-param-reassign
-            pendingExpectation.property = ApplyProp;
-            // eslint-disable-next-line no-param-reassign
-            pendingExpectation.args = args;
-        },
-        ownKeys: function () {
-            throw new Error('Spreading during an expectation is not supported.');
-        },
-    });
-    return stub;
+  return new Error();
+};
+
+const createReturns = pendingExpectation => {
+  const nonPromiseStub = {
+    // TODO: merge this with the promise version
+    thenReturn:
+    /* istanbul ignore next: because this is overwritten by the promise version */
+    returnValue => finishPendingExpectation({
+      value: returnValue,
+      isError: false,
+      isPromise: false
+    }, pendingExpectation),
+    thenThrow: errorOrMessage => finishPendingExpectation({
+      value: getError(errorOrMessage),
+      isError: true,
+      isPromise: false
+    }, pendingExpectation)
+  };
+  const promiseStub = {
+    thenReturn: promise => finishPendingExpectation({
+      value: promise,
+      isError: false,
+      // We're setting this to false because we can't distinguish between a
+      // promise thenReturn and a normal thenReturn.
+      isPromise: false
+    }, pendingExpectation),
+    thenResolve: promiseValue => finishPendingExpectation({
+      value: promiseValue,
+      isError: false,
+      isPromise: true
+    }, pendingExpectation),
+    thenReject: errorOrMessage => finishPendingExpectation({
+      value: getError(errorOrMessage),
+      isError: true,
+      isPromise: true
+    }, pendingExpectation)
+  }; // @ts-expect-error because the return type is a conditional, and we're merging
+  // both branches here
+
+  return _extends({}, nonPromiseStub, promiseStub);
 };
 
-var strongExpectationFactory = function (property, args, returnValue) {
-    return new MatcherExpectation(property, 
-    // Wrap every non-matcher in the default matcher.
-    args === null || args === void 0 ? void 0 : args.map(function (arg) { return (isMatcher(arg) ? arg : deepEquals(arg)); }), returnValue);
-};
 /**
- * Create a type safe mock.
+ * Set an expectation on a mock.
+ *
+ * The expectation must be finished by setting a return value, even if the value
+ * is `undefined`.
+ *
+ * If a call happens that was not expected then the mock will throw an error.
+ * By default, the call is expected to only be made once. Use the invocation
+ * count helpers to expect a call multiple times.
  *
- * Set expectations on the mock using `when` and `thenReturn` and get an
- * instance from the mock using `instance`.
+ * @param expectation A callback to set the expectation on your mock. The
+ *   callback must return the value from the mock to properly infer types.
  *
  * @example
- * const fn = mock<() => number>();
+ * const fn = mock<() => void>();
+ * when(() => fn()).thenReturn(undefined);
  *
- * when(fn()).thenReturn(23);
+ * @example
+ * const fn = mock<() => number>();
+ * when(() => fn()).thenReturn(42).atMost(3);
  *
- * instance(fn) === 23;
- */
-var mock = function (_a) {
-    var _b = _a === void 0 ? {} : _a, _c = _b.repository, repository = _c === void 0 ? new StrongRepository() : _c, _d = _b.expectationFactory, expectationFactory = _d === void 0 ? strongExpectationFactory : _d;
-    var pendingExpectation = new RepoSideEffectPendingExpectation(expectationFactory);
-    var stub = createStub(repository, pendingExpectation);
-    setMockState(stub, { repository: repository, pendingExpectation: pendingExpectation });
-    return stub;
+ * @example
+ * const fn = mock<(x: number) => Promise<number>();
+ * when(() => fn(23)).thenResolve(42);
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars,no-unused-vars
+
+const when = expectation => {
+  setMode(Mode.EXPECT);
+  expectation();
+  setMode(Mode.CALL);
+  const {
+    pendingExpectation
+  } = getMockState(getActiveMock());
+  return createReturns(pendingExpectation);
 };
 
 /**
@@ -914,37 +1163,41 @@ var mock = function (_a) {
  * @example
  * const fn = mock<() => number>();
  *
- * when(fn()).thenReturn(23);
+ * when(() => fn()).thenReturn(23);
  *
  * reset(fn);
  *
- * instance(fn)(); // throws
- */
-var reset = function (mock) {
-    getMockState(mock).repository.clear();
-};
+ * fn(); // throws
+ */
+
+const reset = mock => {
+  getMockState(mock).repository.clear();
+};
 /**
  * Reset all existing mocks.
  *
  * @see reset
- */
-var resetAll = function () {
-    getAllMocks().forEach(function (_a) {
-        var _b = __read(_a, 1), mock = _b[0];
-        reset(mock);
-    });
+ */
+
+const resetAll = () => {
+  getAllMocks().forEach(([mock]) => {
+    reset(mock);
+  });
 };
 
-var verifyRepo = function (repository) {
-    var unmetExpectations = repository.getUnmet();
-    if (unmetExpectations.length) {
-        throw new UnmetExpectations(unmetExpectations);
-    }
-    var callStats = repository.getCallStats();
-    if (callStats.unexpected.size) {
-        throw new UnexpectedCalls(callStats.unexpected, unmetExpectations);
-    }
-};
+const verifyRepo = repository => {
+  const unmetExpectations = repository.getUnmet();
+
+  if (unmetExpectations.length) {
+    throw new UnmetExpectations(unmetExpectations);
+  }
+
+  const callStats = repository.getCallStats();
+
+  if (callStats.unexpected.size) {
+    throw new UnexpectedCalls(callStats.unexpected, unmetExpectations);
+  }
+};
 /**
  * Verify that all expectations on the given mock have been met.
  *
@@ -958,146 +1211,35 @@ var verifyRepo = function (repository) {
  * @example
  * const fn = mock<() => number>();
  *
- * when(fn()).thenReturn(23);
+ * when(() => fn()).thenReturn(23);
  *
  * verify(fn); // throws
- */
-var verify = function (mock) {
-    var repository = getMockState(mock).repository;
-    verifyRepo(repository);
-};
+ */
+
+const verify = mock => {
+  const {
+    repository
+  } = getMockState(mock);
+  verifyRepo(repository);
+};
 /**
  * Verify all existing mocks.
  *
  * @see verify
- */
-var verifyAll = function () {
-    getAllMocks().forEach(function (_a) {
-        var _b = __read(_a, 1), mock = _b[0];
-        verify(mock);
-    });
-};
-
-var createInvocationCount = function (expectation) { return ({
-    between: function (min, max) {
-        expectation.setInvocationCount(min, max);
-    },
-    /* istanbul ignore next */
-    times: function (exact) {
-        expectation.setInvocationCount(exact, exact);
-    },
-    /* istanbul ignore next */
-    anyTimes: function () {
-        expectation.setInvocationCount(0, 0);
-    },
-    /* istanbul ignore next */
-    atLeast: function (min) {
-        expectation.setInvocationCount(min, Infinity);
-    },
-    /* istanbul ignore next */
-    atMost: function (max) {
-        expectation.setInvocationCount(0, max);
-    },
-    /* istanbul ignore next */
-    once: function () {
-        expectation.setInvocationCount(1, 1);
-    },
-    /* istanbul ignore next */
-    twice: function () {
-        expectation.setInvocationCount(2, 2);
-    },
-    /* eslint-enable no-param-reassign, no-multi-assign */
-}); };
-
-/**
- * Set a return value for the currently pending expectation.
- */
-var finishPendingExpectation = function (returnValue, pendingExpectation) {
-    var finishedExpectation = pendingExpectation.finish(returnValue);
-    pendingExpectation.clear();
-    return createInvocationCount(finishedExpectation);
-};
-var getError = function (errorOrMessage) {
-    if (typeof errorOrMessage === 'string') {
-        return new Error(errorOrMessage);
-    }
-    if (errorOrMessage instanceof Error) {
-        return errorOrMessage;
-    }
-    return new Error();
-};
-var createReturns = function (pendingExpectation) {
-    var nonPromiseStub = {
-        // TODO: merge this with the promise version
-        thenReturn: /* istanbul ignore next: because this is overwritten by the promise version */ function (returnValue) {
-            return finishPendingExpectation({ value: returnValue, isError: false, isPromise: false }, pendingExpectation);
-        },
-        thenThrow: function (errorOrMessage) {
-            return finishPendingExpectation({ value: getError(errorOrMessage), isError: true, isPromise: false }, pendingExpectation);
-        },
-    };
-    var promiseStub = {
-        thenReturn: function (promise) {
-            return finishPendingExpectation({
-                value: promise,
-                isError: false,
-                // We're setting this to false because we can't distinguish between a
-                // promise thenReturn and a normal thenReturn.
-                isPromise: false,
-            }, pendingExpectation);
-        },
-        thenResolve: function (promiseValue) {
-            return finishPendingExpectation({
-                value: promiseValue,
-                isError: false,
-                isPromise: true,
-            }, pendingExpectation);
-        },
-        thenReject: function (errorOrMessage) {
-            return finishPendingExpectation({
-                value: getError(errorOrMessage),
-                isError: true,
-                isPromise: true,
-            }, pendingExpectation);
-        },
-    };
-    return __assign(__assign({}, nonPromiseStub), promiseStub);
-};
+ */
 
-/**
- * Set an expectation on a mock.
- *
- * The expectation must be finished by setting a return value, even if the value
- * is `undefined`.
- *
- * If a call happens that was not expected then the mock will throw an error.
- * By default, the call is expected to only be made once. Use the invocation
- * count helpers to expect a call multiple times.
- *
- * @param expectedCall Make a "real" call using the value returned by `mock()`.
- *
- * @example
- * const fn = mock<() => void>();
- * when(fn()).thenReturn(undefined);
- *
- * @example
- * const fn = mock<() => number>();
- * when(fn()).thenReturn(42).atMost(3);
- *
- * @example
- * const fn = mock<(x: number) => Promise<number>();
- * when(fn(23)).thenResolve(42);
- */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars,no-unused-vars
-var when = function (expectedCall) {
-    return createReturns(getMockState(getActiveMock()).pendingExpectation);
+const verifyAll = () => {
+  getAllMocks().forEach(([mock]) => {
+    verify(mock);
+  });
 };
 
 exports.It = It;
-exports.instance = instance;
 exports.mock = mock;
 exports.reset = reset;
 exports.resetAll = resetAll;
+exports.setDefaults = setDefaults;
 exports.verify = verify;
 exports.verifyAll = verifyAll;
 exports.when = when;
+//# sourceMappingURL=index.js.map