@serenity-js/assertions 3.0.0-rc.8 → 3.0.0

package/lib/expectations/endsWith.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endsWith.d.ts","sourceRoot":"","sources":["../../src/expectations/endsWith.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,QAAQ,mFAIpB,CAAA"}

package/lib/expectations/endsWith.js

@@ -2,9 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.endsWith = void 0;
 const core_1 = require("@serenity-js/core");
-function endsWith(expected) {
-    return core_1.Expectation.thatActualShould('end with', expected)
-        .soThat((actualValue, expectedValue) => actualValue.endsWith(expectedValue));
-}
-exports.endsWith = endsWith;
+/**
+ * Creates an {@apilink Expectation|expectation} that is met when the actual `string` value
+ * ends with the resolved value of `expected`.
+ *
+ * ## Ensuring that a given string ends with an expected substring
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, endsWith } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that('Hello World!', endsWith('!')),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+exports.endsWith = core_1.Expectation.define('endsWith', 'end with', (actual, expected) => actual.endsWith(expected));
 //# sourceMappingURL=endsWith.js.map

package/lib/expectations/endsWith.js.map

@@ -1 +1 @@
-{"version":3,"file":"endsWith.js","sourceRoot":"","sources":["../../src/expectations/endsWith.ts"],"names":[],"mappings":";;;AAAA,4CAA4D;AAE5D,SAAgB,QAAQ,CAAC,QAA4B;IACjD,OAAO,kBAAW,CAAC,gBAAgB,CAAiB,UAAU,EAAE,QAAQ,CAAC;SACpE,MAAM,CAAC,CAAC,WAAW,EAAE,aAAa,EAAE,EAAE,CAAC,WAAW,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC;AACrF,CAAC;AAHD,4BAGC"}
+{"version":3,"file":"endsWith.js","sourceRoot":"","sources":["../../src/expectations/endsWith.ts"],"names":[],"mappings":";;;AAAA,4CAAgD;AAEhD;;;;;;;;;;;;;;;;;;GAkBG;AACU,QAAA,QAAQ,GAAG,kBAAW,CAAC,MAAM,CACtC,UAAU,EAAE,UAAU,EACtB,CAAC,MAAc,EAAE,QAAgB,EAAE,EAAE,CACjC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAChC,CAAA"}

package/lib/expectations/equals.d.ts

@@ -1,2 +1,28 @@
-import { Answerable, Expectation } from '@serenity-js/core';
-export declare function equals<Expected>(expectedValue: Answerable<Expected>): Expectation<Expected>;
+import { Expectation } from '@serenity-js/core';
+/**
+ * Produces an {@apilink Expectation|expectation} that is met when the actual value
+ * is equal to the resolved value of `expectedValue`.
+ *
+ * Note that the equality check performs comparison **by value**
+ * using [TinyTypes `equal`](https://github.com/jan-molak/tiny-types/blob/master/src/objects/equal.ts).
+ *
+ * ## Ensuring that the actual value equals expected value
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, equals } from '@serenity-js/assertions'
+ *
+ * const actual   = { name: 'apples' }
+ * const expected = { name: 'apples' }
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(actual, equals(expected)),
+ * )
+ * ```
+ *
+ * @param expectedValue
+ *
+ * @group Expectations
+ */
+export declare const equals: <T>(expected: import("@serenity-js/core").Answerable<T>) => Expectation<T>;
+//# sourceMappingURL=equals.d.ts.map

package/lib/expectations/equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equals.d.ts","sourceRoot":"","sources":["../../src/expectations/equals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,MAAM,4EAIlB,CAAC"}

package/lib/expectations/equals.js

@@ -3,9 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.equals = void 0;
 const core_1 = require("@serenity-js/core");
 const objects_1 = require("tiny-types/lib/objects");
-function equals(expectedValue) {
-    return core_1.Expectation.thatActualShould('equal', expectedValue)
-        .soThat((actual, expected) => (0, objects_1.equal)(actual, expected));
-}
-exports.equals = equals;
+/**
+ * Produces an {@apilink Expectation|expectation} that is met when the actual value
+ * is equal to the resolved value of `expectedValue`.
+ *
+ * Note that the equality check performs comparison **by value**
+ * using [TinyTypes `equal`](https://github.com/jan-molak/tiny-types/blob/master/src/objects/equal.ts).
+ *
+ * ## Ensuring that the actual value equals expected value
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, equals } from '@serenity-js/assertions'
+ *
+ * const actual   = { name: 'apples' }
+ * const expected = { name: 'apples' }
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(actual, equals(expected)),
+ * )
+ * ```
+ *
+ * @param expectedValue
+ *
+ * @group Expectations
+ */
+exports.equals = core_1.Expectation.define('equals', 'equal', (actual, expected) => (0, objects_1.equal)(actual, expected));
 //# sourceMappingURL=equals.js.map

package/lib/expectations/equals.js.map

@@ -1 +1 @@
-{"version":3,"file":"equals.js","sourceRoot":"","sources":["../../src/expectations/equals.ts"],"names":[],"mappings":";;;AAAA,4CAA4D;AAC5D,oDAA+C;AAE/C,SAAgB,MAAM,CAAW,aAAmC;IAChE,OAAO,kBAAW,CAAC,gBAAgB,CAAqB,OAAO,EAAE,aAAa,CAAC;SAC1E,MAAM,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC,IAAA,eAAK,EAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;AAC/D,CAAC;AAHD,wBAGC"}
+{"version":3,"file":"equals.js","sourceRoot":"","sources":["../../src/expectations/equals.ts"],"names":[],"mappings":";;;AAAA,4CAAgD;AAChD,oDAA+C;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACU,QAAA,MAAM,GAAG,kBAAW,CAAC,MAAM,CACpC,QAAQ,EAAE,OAAO,EACjB,CAAI,MAAS,EAAE,QAAW,EAAE,EAAE,CAC1B,IAAA,eAAK,EAAC,MAAM,EAAE,QAAQ,CAAC,CAC9B,CAAC"}

package/lib/expectations/includes.d.ts

@@ -1,2 +1,22 @@
-import { Answerable, Expectation } from '@serenity-js/core';
-export declare function includes(expected: Answerable<string>): Expectation<string>;
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an {@apilink Expectation|expectation} that is met when the actual `string` value
+ * includes a substring of `expected`.
+ *
+ * ## Ensuring that a given string includes the expected substring
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, includes } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that('Hello World!', includes('World')),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+export declare const includes: (expected: import("@serenity-js/core").Answerable<string>) => Expectation<string>;
+//# sourceMappingURL=includes.d.ts.map

package/lib/expectations/includes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"includes.d.ts","sourceRoot":"","sources":["../../src/expectations/includes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,QAAQ,mFAIpB,CAAC"}

package/lib/expectations/includes.js

@@ -2,9 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.includes = void 0;
 const core_1 = require("@serenity-js/core");
-function includes(expected) {
-    return core_1.Expectation.thatActualShould('include', expected)
-        .soThat((actualValue, expectedValue) => actualValue.includes(expectedValue));
-}
-exports.includes = includes;
+/**
+ * Creates an {@apilink Expectation|expectation} that is met when the actual `string` value
+ * includes a substring of `expected`.
+ *
+ * ## Ensuring that a given string includes the expected substring
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, includes } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that('Hello World!', includes('World')),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+exports.includes = core_1.Expectation.define('includes', 'include', (actual, expected) => actual.includes(expected));
 //# sourceMappingURL=includes.js.map

package/lib/expectations/includes.js.map

@@ -1 +1 @@
-{"version":3,"file":"includes.js","sourceRoot":"","sources":["../../src/expectations/includes.ts"],"names":[],"mappings":";;;AAAA,4CAA4D;AAE5D,SAAgB,QAAQ,CAAC,QAA4B;IACjD,OAAO,kBAAW,CAAC,gBAAgB,CAAiB,SAAS,EAAE,QAAQ,CAAC;SACnE,MAAM,CAAC,CAAC,WAAW,EAAE,aAAa,EAAE,EAAE,CAAC,WAAW,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC;AACrF,CAAC;AAHD,4BAGC"}
+{"version":3,"file":"includes.js","sourceRoot":"","sources":["../../src/expectations/includes.ts"],"names":[],"mappings":";;;AAAA,4CAAgD;AAEhD;;;;;;;;;;;;;;;;;;GAkBG;AACU,QAAA,QAAQ,GAAG,kBAAW,CAAC,MAAM,CACtC,UAAU,EAAE,SAAS,EACrB,CAAC,MAAc,EAAE,QAAgB,EAAE,EAAE,CACjC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAChC,CAAC"}

package/lib/expectations/index.d.ts

@@ -7,6 +7,7 @@ export * from './equals';
 export * from './includes';
 export * from './isAfter';
 export * from './isBefore';
+export * from './isCloseTo';
 export * from './isFalse';
 export * from './isGreaterThan';
 export * from './isLessThan';
@@ -15,4 +16,6 @@ export * from './isTrue';
 export * from './matches';
 export * from './not';
 export * from './or';
+export * from './property';
 export * from './startsWith';
+//# sourceMappingURL=index.d.ts.map

package/lib/expectations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/expectations/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,WAAW,CAAC;AAC1B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,OAAO,CAAC;AACtB,cAAc,MAAM,CAAC;AACrB,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC"}

package/lib/expectations/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -19,6 +23,7 @@ __exportStar(require("./equals"), exports);
 __exportStar(require("./includes"), exports);
 __exportStar(require("./isAfter"), exports);
 __exportStar(require("./isBefore"), exports);
+__exportStar(require("./isCloseTo"), exports);
 __exportStar(require("./isFalse"), exports);
 __exportStar(require("./isGreaterThan"), exports);
 __exportStar(require("./isLessThan"), exports);
@@ -27,5 +32,6 @@ __exportStar(require("./isTrue"), exports);
 __exportStar(require("./matches"), exports);
 __exportStar(require("./not"), exports);
 __exportStar(require("./or"), exports);
+__exportStar(require("./property"), exports);
 __exportStar(require("./startsWith"), exports);
 //# sourceMappingURL=index.js.map

package/lib/expectations/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/expectations/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,wCAAsB;AACtB,4CAA0B;AAC1B,8DAA4C;AAC5C,8DAA4C;AAC5C,6CAA2B;AAC3B,2CAAyB;AACzB,6CAA2B;AAC3B,4CAA0B;AAC1B,6CAA2B;AAC3B,4CAA0B;AAC1B,kDAAgC;AAChC,+CAA6B;AAC7B,8CAA4B;AAC5B,2CAAyB;AACzB,4CAA0B;AAC1B,wCAAsB;AACtB,uCAAqB;AACrB,+CAA6B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/expectations/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wCAAsB;AACtB,4CAA0B;AAC1B,8DAA4C;AAC5C,8DAA4C;AAC5C,6CAA2B;AAC3B,2CAAyB;AACzB,6CAA2B;AAC3B,4CAA0B;AAC1B,6CAA2B;AAC3B,8CAA4B;AAC5B,4CAA0B;AAC1B,kDAAgC;AAChC,+CAA6B;AAC7B,8CAA4B;AAC5B,2CAAyB;AACzB,4CAA0B;AAC1B,wCAAsB;AACtB,uCAAqB;AACrB,6CAA2B;AAC3B,+CAA6B"}

package/lib/expectations/isAfter.d.ts

@@ -1,2 +1,42 @@
-import { Answerable, Expectation } from '@serenity-js/core';
-export declare function isAfter(expected: Answerable<Date>): Expectation<Date>;
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an {@apilink Expectation|expectation} that is met when the actual value of type `Date`
+ * is after the expected `Date`.
+ *
+ * ## Ensuring that a given date is after the expected date
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, isAfter } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(new Date('2022-01-01'), isAfter(new Date('1995-01-01'))),
+ * )
+ * ```
+ *
+ * ## Ensuring that a given date is within the expected date range
+ *
+ * ```ts
+ * import { actorCalled, Expectation, d } from '@serenity-js/core'
+ * import { Ensure, and, isAfter, isBefore } from '@serenity-js/assertions'
+ *
+ * const isWithinDateRange = (lowerBound: Answerable<Date>, upperBound: Answerable<Date>) =>
+ *   Expectation.to(d`have value that is between ${ lowerBound } and ${ upperBound }`)
+ *     .soThatActual(
+ *       and(isAfter(lowerBound), isBefore(upperBound))
+ *     ),
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(
+ *     new Date('2022-01-01'),
+ *     isWithinDateRange(new Date('1995-01-01'), new Date('2025-01-01'))
+ *   ),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+export declare const isAfter: (expected: import("@serenity-js/core").Answerable<Date>) => Expectation<Date>;
+//# sourceMappingURL=isAfter.d.ts.map

package/lib/expectations/isAfter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isAfter.d.ts","sourceRoot":"","sources":["../../src/expectations/isAfter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,OAAO,+EAInB,CAAC"}

package/lib/expectations/isAfter.js

@@ -2,9 +2,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isAfter = void 0;
 const core_1 = require("@serenity-js/core");
-function isAfter(expected) {
-    return core_1.Expectation.thatActualShould('have value that is after', expected)
-        .soThat((actualValue, expectedValue) => actualValue.getTime() > expectedValue.getTime());
-}
-exports.isAfter = isAfter;
+/**
+ * Creates an {@apilink Expectation|expectation} that is met when the actual value of type `Date`
+ * is after the expected `Date`.
+ *
+ * ## Ensuring that a given date is after the expected date
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, isAfter } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(new Date('2022-01-01'), isAfter(new Date('1995-01-01'))),
+ * )
+ * ```
+ *
+ * ## Ensuring that a given date is within the expected date range
+ *
+ * ```ts
+ * import { actorCalled, Expectation, d } from '@serenity-js/core'
+ * import { Ensure, and, isAfter, isBefore } from '@serenity-js/assertions'
+ *
+ * const isWithinDateRange = (lowerBound: Answerable<Date>, upperBound: Answerable<Date>) =>
+ *   Expectation.to(d`have value that is between ${ lowerBound } and ${ upperBound }`)
+ *     .soThatActual(
+ *       and(isAfter(lowerBound), isBefore(upperBound))
+ *     ),
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(
+ *     new Date('2022-01-01'),
+ *     isWithinDateRange(new Date('1995-01-01'), new Date('2025-01-01'))
+ *   ),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+exports.isAfter = core_1.Expectation.define('isAfter', 'have value that is after', (actual, expected) => actual.getTime() > expected.getTime());
 //# sourceMappingURL=isAfter.js.map

package/lib/expectations/isAfter.js.map

@@ -1 +1 @@
-{"version":3,"file":"isAfter.js","sourceRoot":"","sources":["../../src/expectations/isAfter.ts"],"names":[],"mappings":";;;AAAA,4CAA4D;AAE5D,SAAgB,OAAO,CAAC,QAA0B;IAC9C,OAAO,kBAAW,CAAC,gBAAgB,CAAa,0BAA0B,EAAE,QAAQ,CAAC;SAChF,MAAM,CAAC,CAAC,WAAW,EAAE,aAAa,EAAE,EAAE,CAAC,WAAW,CAAC,OAAO,EAAE,GAAG,aAAa,CAAC,OAAO,EAAE,CAAC,CAAC;AACjG,CAAC;AAHD,0BAGC"}
+{"version":3,"file":"isAfter.js","sourceRoot":"","sources":["../../src/expectations/isAfter.ts"],"names":[],"mappings":";;;AAAA,4CAAgD;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACU,QAAA,OAAO,GAAG,kBAAW,CAAC,MAAM,CACrC,SAAS,EAAE,0BAA0B,EACrC,CAAC,MAAY,EAAE,QAAc,EAAE,EAAE,CAC7B,MAAM,CAAC,OAAO,EAAE,GAAG,QAAQ,CAAC,OAAO,EAAE,CAC5C,CAAC"}

package/lib/expectations/isBefore.d.ts

@@ -1,2 +1,42 @@
-import { Answerable, Expectation } from '@serenity-js/core';
-export declare function isBefore(expected: Answerable<Date>): Expectation<Date>;
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an {@apilink Expectation|expectation} that is met when the actual value of type `Date`
+ * is before the expected `Date`.
+ *
+ * ## Ensuring that a given date is after the expected date
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, isBefore } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(new Date('1995-01-01'), isBefore(new Date('2022-01-01'))),
+ * )
+ * ```
+ *
+ * ## Ensuring that a given date is within the expected date range
+ *
+ * ```ts
+ * import { actorCalled, Expectation, d } from '@serenity-js/core'
+ * import { Ensure, and, isAfter, isBefore } from '@serenity-js/assertions'
+ *
+ * const isWithinDateRange = (lowerBound: Answerable<Date>, upperBound: Answerable<Date>) =>
+ *   Expectation.to(d`have value that is between ${ lowerBound } and ${ upperBound }`)
+ *     .soThatActual(
+ *       and(isAfter(lowerBound), isBefore(upperBound))
+ *     ),
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(
+ *     new Date('2022-01-01'),
+ *     isWithinDateRange(new Date('1995-01-01'), new Date('2025-01-01'))
+ *   ),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+export declare const isBefore: (expected: import("@serenity-js/core").Answerable<Date>) => Expectation<Date>;
+//# sourceMappingURL=isBefore.d.ts.map

package/lib/expectations/isBefore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBefore.d.ts","sourceRoot":"","sources":["../../src/expectations/isBefore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,QAAQ,+EAIpB,CAAC"}

package/lib/expectations/isBefore.js

@@ -2,9 +2,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isBefore = void 0;
 const core_1 = require("@serenity-js/core");
-function isBefore(expected) {
-    return core_1.Expectation.thatActualShould('have value that is before', expected)
-        .soThat((actualValue, expectedValue) => actualValue.getTime() < expectedValue.getTime());
-}
-exports.isBefore = isBefore;
+/**
+ * Creates an {@apilink Expectation|expectation} that is met when the actual value of type `Date`
+ * is before the expected `Date`.
+ *
+ * ## Ensuring that a given date is after the expected date
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, isBefore } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(new Date('1995-01-01'), isBefore(new Date('2022-01-01'))),
+ * )
+ * ```
+ *
+ * ## Ensuring that a given date is within the expected date range
+ *
+ * ```ts
+ * import { actorCalled, Expectation, d } from '@serenity-js/core'
+ * import { Ensure, and, isAfter, isBefore } from '@serenity-js/assertions'
+ *
+ * const isWithinDateRange = (lowerBound: Answerable<Date>, upperBound: Answerable<Date>) =>
+ *   Expectation.to(d`have value that is between ${ lowerBound } and ${ upperBound }`)
+ *     .soThatActual(
+ *       and(isAfter(lowerBound), isBefore(upperBound))
+ *     ),
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(
+ *     new Date('2022-01-01'),
+ *     isWithinDateRange(new Date('1995-01-01'), new Date('2025-01-01'))
+ *   ),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+exports.isBefore = core_1.Expectation.define('isBefore', 'have value that is before', (actual, expected) => actual.getTime() < expected.getTime());
 //# sourceMappingURL=isBefore.js.map

package/lib/expectations/isBefore.js.map

@@ -1 +1 @@
-{"version":3,"file":"isBefore.js","sourceRoot":"","sources":["../../src/expectations/isBefore.ts"],"names":[],"mappings":";;;AAAA,4CAA4D;AAE5D,SAAgB,QAAQ,CAAC,QAA0B;IAC/C,OAAO,kBAAW,CAAC,gBAAgB,CAAa,2BAA2B,EAAE,QAAQ,CAAC;SACjF,MAAM,CAAC,CAAC,WAAW,EAAE,aAAa,EAAE,EAAE,CAAC,WAAW,CAAC,OAAO,EAAE,GAAG,aAAa,CAAC,OAAO,EAAE,CAAC,CAAC;AACjG,CAAC;AAHD,4BAGC"}
+{"version":3,"file":"isBefore.js","sourceRoot":"","sources":["../../src/expectations/isBefore.ts"],"names":[],"mappings":";;;AAAA,4CAAgD;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACU,QAAA,QAAQ,GAAG,kBAAW,CAAC,MAAM,CACtC,UAAU,EAAE,2BAA2B,EACvC,CAAC,MAAY,EAAE,QAAc,EAAE,EAAE,CAC7B,MAAM,CAAC,OAAO,EAAE,GAAG,QAAQ,CAAC,OAAO,EAAE,CAC5C,CAAC"}

package/lib/expectations/isCloseTo.d.ts

@@ -0,0 +1,24 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Produces an {@apilink Expectation|expectation} that is met when the actual value
+ * is within a given ± `absoluteTolerance` range of the `expected` value.
+ *
+ * ## Ensuring that a given floating point number is close to the expected number
+ *
+ * ```ts
+ *  import { actorCalled } from '@serenity-js/core'
+ *  import { Ensure, isCloseTo } from '@serenity-js/assertions'
+ *
+ *  await actorCalled('Iris').attemptsTo(
+ *      Ensure.that(10.123, isCloseTo(10, 0.2))
+ *  )
+ * ```
+ *
+ * @param expected
+ * @param [absoluteTolerance=1e-9]
+ *  Absolute ± tolerance range, defaults to `1e-9`
+ *
+ * @group Expectations
+ */
+export declare const isCloseTo: (...answerableArguments: unknown[]) => Expectation<number>;
+//# sourceMappingURL=isCloseTo.d.ts.map

package/lib/expectations/isCloseTo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isCloseTo.d.ts","sourceRoot":"","sources":["../../src/expectations/isCloseTo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,SAAS,4DAgBrB,CAAA"}

package/lib/expectations/isCloseTo.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCloseTo = void 0;
+const core_1 = require("@serenity-js/core");
+/**
+ * Produces an {@apilink Expectation|expectation} that is met when the actual value
+ * is within a given ± `absoluteTolerance` range of the `expected` value.
+ *
+ * ## Ensuring that a given floating point number is close to the expected number
+ *
+ * ```ts
+ *  import { actorCalled } from '@serenity-js/core'
+ *  import { Ensure, isCloseTo } from '@serenity-js/assertions'
+ *
+ *  await actorCalled('Iris').attemptsTo(
+ *      Ensure.that(10.123, isCloseTo(10, 0.2))
+ *  )
+ * ```
+ *
+ * @param expected
+ * @param [absoluteTolerance=1e-9]
+ *  Absolute ± tolerance range, defaults to `1e-9`
+ *
+ * @group Expectations
+ */
+exports.isCloseTo = core_1.Expectation.define('isCloseTo', (expected, absoluteTolerance = 1e-9) => (0, core_1.d) `have value close to ${expected} ±${absoluteTolerance}`, (actual, expected, absoluteTolerance = 1e-9) => {
+    // short-circuit exact equality
+    if (actual === expected) {
+        return true;
+    }
+    if (!(Number.isFinite(actual) && Number.isFinite(expected))) {
+        return false;
+    }
+    const difference = Math.abs(actual - expected);
+    return difference <= absoluteTolerance;
+});
+//# sourceMappingURL=isCloseTo.js.map

package/lib/expectations/isCloseTo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isCloseTo.js","sourceRoot":"","sources":["../../src/expectations/isCloseTo.ts"],"names":[],"mappings":";;;AAAA,4CAAmD;AAEnD;;;;;;;;;;;;;;;;;;;;GAoBG;AACU,QAAA,SAAS,GAAG,kBAAW,CAAC,MAAM,CACvC,WAAW,EAAE,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,EAAE,EAAE,CAAC,IAAA,QAAC,EAAA,uBAAwB,QAAS,KAAM,iBAAkB,EAAE,EACjH,CAAC,MAAc,EAAE,QAAgB,EAAE,iBAAiB,GAAG,IAAI,EAAE,EAAE;IAC3D,+BAA+B;IAC/B,IAAI,MAAM,KAAK,QAAQ,EAAE;QACrB,OAAO,IAAI,CAAC;KACf;IAED,IAAI,CAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE;QAC1D,OAAO,KAAK,CAAC;KAChB;IAED,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAA;IAE9C,OAAO,UAAU,IAAI,iBAAiB,CAAC;AAC3C,CAAC,CACJ,CAAA"}

package/lib/expectations/isFalse.d.ts

@@ -1,2 +1,21 @@
 import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an {@apilink Expectation|expectation} that is met when the actual `boolean` value
+ * is `false`.
+ *
+ * ## Ensuring that a given value is false
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, isFalse } from '@serenity-js/assertions'
+ * import { Cookie } from '@serenity-js/web'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(Cookie.called('example-regular-cookie').isSecure(), isFalse()),
+ * )
+ * ```
+ *
+ * @group Expectations
+ */
 export declare function isFalse(): Expectation<boolean>;
+//# sourceMappingURL=isFalse.d.ts.map

package/lib/expectations/isFalse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isFalse.d.ts","sourceRoot":"","sources":["../../src/expectations/isFalse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIhD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,CAE9C"}

package/lib/expectations/isFalse.js

@@ -3,6 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isFalse = void 0;
 const core_1 = require("@serenity-js/core");
 const equals_1 = require("./equals");
+/**
+ * Creates an {@apilink Expectation|expectation} that is met when the actual `boolean` value
+ * is `false`.
+ *
+ * ## Ensuring that a given value is false
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, isFalse } from '@serenity-js/assertions'
+ * import { Cookie } from '@serenity-js/web'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(Cookie.called('example-regular-cookie').isSecure(), isFalse()),
+ * )
+ * ```
+ *
+ * @group Expectations
+ */
 function isFalse() {
     return core_1.Expectation.to(`equal false`).soThatActual((0, equals_1.equals)(false));
 }

package/lib/expectations/isFalse.js.map

@@ -1 +1 @@
-{"version":3,"file":"isFalse.js","sourceRoot":"","sources":["../../src/expectations/isFalse.ts"],"names":[],"mappings":";;;AAAA,4CAAgD;AAEhD,qCAAkC;AAElC,SAAgB,OAAO;IACnB,OAAO,kBAAW,CAAC,EAAE,CAAiB,aAAa,CAAC,CAAC,YAAY,CAAC,IAAA,eAAM,EAAC,KAAK,CAAC,CAAC,CAAC;AACrF,CAAC;AAFD,0BAEC"}
+{"version":3,"file":"isFalse.js","sourceRoot":"","sources":["../../src/expectations/isFalse.ts"],"names":[],"mappings":";;;AAAA,4CAAgD;AAEhD,qCAAkC;AAElC;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,OAAO;IACnB,OAAO,kBAAW,CAAC,EAAE,CAAU,aAAa,CAAC,CAAC,YAAY,CAAC,IAAA,eAAM,EAAC,KAAK,CAAC,CAAC,CAAC;AAC9E,CAAC;AAFD,0BAEC"}

package/lib/expectations/isGreaterThan.d.ts

@@ -1,2 +1,45 @@
-import { Answerable, Expectation } from '@serenity-js/core';
-export declare function isGreaterThan(expected: Answerable<number>): Expectation<number>;
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an {@apilink Expectation|expectation} that is met when the actual value of type `number`
+ * is greater than the expected `number`.
+ *
+ * ## Ensuring that a given number is greater than the expected number
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, isGreaterThan } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(10, isGreaterThan(5)),
+ * )
+ * ```
+ *
+ * ## Ensuring that a given number is within the expected range
+ *
+ * ```ts
+ * import { actorCalled, Expectation, d } from '@serenity-js/core'
+ * import { Ensure, and, equals, isGreaterThan, isLessThan, or } from '@serenity-js/assertions'
+ *
+ * const isWithinRange = (lowerBound: Answerable<number>, upperBound: Answerable<number>) =>
+ *   Expectation.to(d`have value that is between ${ lowerBound } and ${ upperBound }`)
+ *     .soThatActual(
+ *       and(
+ *         or(equals(lowerBound), isGreaterThan(lowerBound)),
+ *         or(equals(upperBound), isLessThan(upperBound)),
+ *       )
+ *     ),
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(
+ *     7,
+ *     isWithinRange(5, 10)
+ *   ),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+export declare const isGreaterThan: (expected: import("@serenity-js/core").Answerable<number>) => Expectation<number>;
+//# sourceMappingURL=isGreaterThan.d.ts.map

package/lib/expectations/isGreaterThan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isGreaterThan.d.ts","sourceRoot":"","sources":["../../src/expectations/isGreaterThan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,aAAa,mFAIzB,CAAA"}