@serenity-js/assertions 3.41.2 → 3.42.0

package/esm/expectations/contain.js

@@ -0,0 +1,28 @@
+import { Expectation } from '@serenity-js/core';
+import { equal } from 'tiny-types/lib/objects/index.js';
+/**
+ * Produces an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the actual array of `Item[]` contains
+ * at least one `Item` that is equal to the resolved value of `expected`.
+ *
+ * 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 array contains the given item
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, and, startsWith, endsWith } from '@serenity-js/assertions'
+ *
+ * const items = [ { name: 'apples' }, { name: 'bananas' } ]
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(items, contain({ name: 'bananas' })),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+export const contain = Expectation.define('contain', 'contain', (actual, expected) => actual.some(item => equal(item, expected)));
+//# sourceMappingURL=contain.js.map

package/esm/expectations/contain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contain.js","sourceRoot":"","sources":["../../src/expectations/contain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,KAAK,EAAE,MAAM,iCAAiC,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,CACrC,SAAS,EAAE,SAAS,EACpB,CAAO,MAAc,EAAE,QAAc,EAAE,EAAE,CACrC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CACjD,CAAC"}

package/esm/expectations/containAtLeastOneItemThat.d.ts

@@ -0,0 +1,24 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Produces an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the actual array of `Item[]` contains
+ * at least one `Item` for which the `expectation` is met.
+ *
+ * ## Ensuring that at least one item in an array meets the expectation
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, containAtLeastOneItemThat, isGreaterThan } from '@serenity-js/assertions'
+ *
+ * const items = [ 10, 15, 20 ]
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(items, containAtLeastOneItemThat(isGreaterThan(18))),
+ * )
+ * ```
+ *
+ * @param expectation
+ *
+ * @group Expectations
+ */
+export declare function containAtLeastOneItemThat<Item>(expectation: Expectation<Item>): Expectation<Item[]>;
+//# sourceMappingURL=containAtLeastOneItemThat.d.ts.map

package/esm/expectations/containAtLeastOneItemThat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"containAtLeastOneItemThat.d.ts","sourceRoot":"","sources":["../../src/expectations/containAtLeastOneItemThat.ts"],"names":[],"mappings":"AACA,OAAO,EAAK,WAAW,EAAqE,MAAM,mBAAmB,CAAC;AAEtH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,WAAW,EAAE,WAAW,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC,CAEnG"}

package/esm/expectations/containAtLeastOneItemThat.js

@@ -0,0 +1,53 @@
+import { d, Expectation, ExpectationDetails, ExpectationMet, ExpectationNotMet, Unanswered } from '@serenity-js/core';
+/**
+ * Produces an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the actual array of `Item[]` contains
+ * at least one `Item` for which the `expectation` is met.
+ *
+ * ## Ensuring that at least one item in an array meets the expectation
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, containAtLeastOneItemThat, isGreaterThan } from '@serenity-js/assertions'
+ *
+ * const items = [ 10, 15, 20 ]
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(items, containAtLeastOneItemThat(isGreaterThan(18))),
+ * )
+ * ```
+ *
+ * @param expectation
+ *
+ * @group Expectations
+ */
+export function containAtLeastOneItemThat(expectation) {
+    return new ContainAtLeastOneItemThatMeetsExpectation(expectation);
+}
+/**
+ * @package
+ */
+class ContainAtLeastOneItemThatMeetsExpectation extends Expectation {
+    expectation;
+    static descriptionFor(expectation) {
+        return d `contain at least one item that does ${expectation}`;
+    }
+    constructor(expectation) {
+        super('containAtLeastOneItemThat', ContainAtLeastOneItemThatMeetsExpectation.descriptionFor(expectation), async (actor, actual) => {
+            const items = await actor.answer(actual);
+            if (!items || items.length === 0) {
+                const unanswered = new Unanswered();
+                return new ExpectationNotMet(ContainAtLeastOneItemThatMeetsExpectation.descriptionFor(expectation), ExpectationDetails.of('containAtLeastOneItemThat', unanswered), unanswered, items);
+            }
+            let outcome;
+            for (const item of items) {
+                outcome = await actor.answer(expectation.isMetFor(item));
+                if (outcome instanceof ExpectationMet) {
+                    return new ExpectationMet(ContainAtLeastOneItemThatMeetsExpectation.descriptionFor(expectation), ExpectationDetails.of('containAtLeastOneItemThat', outcome.expectation), outcome.expected, items);
+                }
+            }
+            return new ExpectationNotMet(ContainAtLeastOneItemThatMeetsExpectation.descriptionFor(expectation), ExpectationDetails.of('containAtLeastOneItemThat', outcome.expectation), outcome.expected, items);
+        });
+        this.expectation = expectation;
+    }
+}
+//# sourceMappingURL=containAtLeastOneItemThat.js.map

package/esm/expectations/containAtLeastOneItemThat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"containAtLeastOneItemThat.js","sourceRoot":"","sources":["../../src/expectations/containAtLeastOneItemThat.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,kBAAkB,EAAE,cAAc,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEtH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,yBAAyB,CAAO,WAA8B;IAC1E,OAAO,IAAI,yCAAyC,CAAC,WAAW,CAAC,CAAC;AACtE,CAAC;AAED;;GAEG;AACH,MAAM,yCAAgD,SAAQ,WAAmB;IAMhD;IAJrB,MAAM,CAAC,cAAc,CAAC,WAA6B;QACvD,OAAO,CAAC,CAAA,uCAAwC,WAAY,EAAE,CAAC;IACnE,CAAC;IAED,YAA6B,WAA8B;QACvD,KAAK,CACD,2BAA2B,EAC3B,yCAAyC,CAAC,cAAc,CAAC,WAAW,CAAC,EACrE,KAAK,EAAE,KAAuB,EAAE,MAA0B,EAAE,EAAE;YAE1D,MAAM,KAAK,GAAW,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAEjD,IAAI,CAAE,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAChC,MAAM,UAAU,GAAG,IAAI,UAAU,EAAE,CAAC;gBACpC,OAAO,IAAI,iBAAiB,CACxB,yCAAyC,CAAC,cAAc,CAAC,WAAW,CAAC,EACrE,kBAAkB,CAAC,EAAE,CAAC,2BAA2B,EAAE,UAAU,CAAC,EAC9D,UAAU,EACV,KAAK,CACR,CAAC;YACN,CAAC;YAED,IAAI,OAA2B,CAAC;YAEhC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBAEvB,OAAO,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAA;gBAExD,IAAI,OAAO,YAAY,cAAc,EAAE,CAAC;oBACpC,OAAO,IAAI,cAAc,CACrB,yCAAyC,CAAC,cAAc,CAAC,WAAW,CAAC,EACrE,kBAAkB,CAAC,EAAE,CAAC,2BAA2B,EAAE,OAAO,CAAC,WAAW,CAAC,EACvE,OAAO,CAAC,QAAQ,EAChB,KAAK,CACR,CAAC;gBACN,CAAC;YACL,CAAC;YAED,OAAO,IAAI,iBAAiB,CACxB,yCAAyC,CAAC,cAAc,CAAC,WAAW,CAAC,EACrE,kBAAkB,CAAC,EAAE,CAAC,2BAA2B,EAAE,OAAO,CAAC,WAAW,CAAC,EACvE,OAAO,CAAC,QAAQ,EAChB,KAAK,CACR,CAAC;QACN,CAAC,CACJ,CAAC;QAzCuB,gBAAW,GAAX,WAAW,CAAmB;IA0C3D,CAAC;CACJ"}

package/esm/expectations/containItemsWhereEachItem.d.ts

@@ -0,0 +1,24 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Produces an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when all the items of the actual array of `Item[]`
+ * meet the `expectation`.
+ *
+ * ## Ensuring that all the items in an array meet the expectation
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, containItemsWhereEachItem, endsWith } from '@serenity-js/assertions'
+ *
+ * const items = [ 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday' ]
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(items, containItemsWhereEachItem(endsWith('day'))),
+ * )
+ * ```
+ *
+ * @param expectation
+ *
+ * @group Expectations
+ */
+export declare function containItemsWhereEachItem<Actual>(expectation: Expectation<Actual>): Expectation<Actual[]>;
+//# sourceMappingURL=containItemsWhereEachItem.d.ts.map

package/esm/expectations/containItemsWhereEachItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"containItemsWhereEachItem.d.ts","sourceRoot":"","sources":["../../src/expectations/containItemsWhereEachItem.ts"],"names":[],"mappings":"AACA,OAAO,EAAK,WAAW,EAAqE,MAAM,mBAAmB,CAAC;AAEtH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,CAEzG"}

package/esm/expectations/containItemsWhereEachItem.js

@@ -0,0 +1,53 @@
+import { d, Expectation, ExpectationDetails, ExpectationMet, ExpectationNotMet, Unanswered } from '@serenity-js/core';
+/**
+ * Produces an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when all the items of the actual array of `Item[]`
+ * meet the `expectation`.
+ *
+ * ## Ensuring that all the items in an array meet the expectation
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, containItemsWhereEachItem, endsWith } from '@serenity-js/assertions'
+ *
+ * const items = [ 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday' ]
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(items, containItemsWhereEachItem(endsWith('day'))),
+ * )
+ * ```
+ *
+ * @param expectation
+ *
+ * @group Expectations
+ */
+export function containItemsWhereEachItem(expectation) {
+    return new ContainItemsWhereEachItemMeetsExpectation(expectation);
+}
+/**
+ * @package
+ */
+class ContainItemsWhereEachItemMeetsExpectation extends Expectation {
+    expectation;
+    static descriptionFor(expectation) {
+        return d `contain items where each item does ${expectation}`;
+    }
+    constructor(expectation) {
+        super('containItemsWhereEachItem', ContainItemsWhereEachItemMeetsExpectation.descriptionFor(expectation), async (actor, actual) => {
+            const items = await actor.answer(actual);
+            if (!items || items.length === 0) {
+                const unanswered = new Unanswered();
+                return new ExpectationNotMet(ContainItemsWhereEachItemMeetsExpectation.descriptionFor(expectation), ExpectationDetails.of('containItemsWhereEachItem', unanswered), unanswered, items);
+            }
+            let outcome;
+            for (const item of items) {
+                outcome = await actor.answer(expectation.isMetFor(item));
+                if (outcome instanceof ExpectationNotMet) {
+                    return new ExpectationNotMet(ContainItemsWhereEachItemMeetsExpectation.descriptionFor(expectation), ExpectationDetails.of('containItemsWhereEachItem', outcome.expectation), outcome.expected, items);
+                }
+            }
+            return new ExpectationMet(ContainItemsWhereEachItemMeetsExpectation.descriptionFor(expectation), ExpectationDetails.of('containItemsWhereEachItem', outcome.expectation), outcome.expected, items);
+        });
+        this.expectation = expectation;
+    }
+}
+//# sourceMappingURL=containItemsWhereEachItem.js.map

package/esm/expectations/containItemsWhereEachItem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"containItemsWhereEachItem.js","sourceRoot":"","sources":["../../src/expectations/containItemsWhereEachItem.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,kBAAkB,EAAE,cAAc,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEtH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,yBAAyB,CAAS,WAAgC;IAC9E,OAAO,IAAI,yCAAyC,CAAC,WAAW,CAAC,CAAC;AACtE,CAAC;AAED;;GAEG;AACH,MAAM,yCAAkD,SAAQ,WAAqB;IAMpD;IAJrB,MAAM,CAAC,cAAc,CAAC,WAA6B;QACvD,OAAO,CAAC,CAAA,sCAAuC,WAAY,EAAE,CAAC;IAClE,CAAC;IAED,YAA6B,WAAgC;QACzD,KAAK,CACD,2BAA2B,EAC3B,yCAAyC,CAAC,cAAc,CAAC,WAAW,CAAC,EACrE,KAAK,EAAE,KAAuB,EAAE,MAA4B,EAAE,EAAE;YAE5D,MAAM,KAAK,GAAa,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAEnD,IAAI,CAAE,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAChC,MAAM,UAAU,GAAG,IAAI,UAAU,EAAE,CAAC;gBACpC,OAAO,IAAI,iBAAiB,CACxB,yCAAyC,CAAC,cAAc,CAAC,WAAW,CAAC,EACrE,kBAAkB,CAAC,EAAE,CAAC,2BAA2B,EAAE,UAAU,CAAC,EAC9D,UAAU,EACV,KAAK,CACR,CAAC;YACN,CAAC;YAED,IAAI,OAA2B,CAAC;YAEhC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBAEvB,OAAO,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAA;gBAExD,IAAI,OAAO,YAAY,iBAAiB,EAAE,CAAC;oBACvC,OAAO,IAAI,iBAAiB,CACxB,yCAAyC,CAAC,cAAc,CAAC,WAAW,CAAC,EACrE,kBAAkB,CAAC,EAAE,CAAC,2BAA2B,EAAE,OAAO,CAAC,WAAW,CAAC,EACvE,OAAO,CAAC,QAAQ,EAChB,KAAK,CACR,CAAC;gBACN,CAAC;YACL,CAAC;YAED,OAAO,IAAI,cAAc,CACrB,yCAAyC,CAAC,cAAc,CAAC,WAAW,CAAC,EACrE,kBAAkB,CAAC,EAAE,CAAC,2BAA2B,EAAE,OAAO,CAAC,WAAW,CAAC,EACvE,OAAO,CAAC,QAAQ,EAChB,KAAK,CACR,CAAC;QACN,CAAC,CACJ,CAAC;QAzCuB,gBAAW,GAAX,WAAW,CAAqB;IA0C7D,CAAC;CACJ"}

package/esm/expectations/endsWith.d.ts

@@ -0,0 +1,22 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/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
+ */
+export declare const endsWith: (expected: import("@serenity-js/core").Answerable<string>) => Expectation<string>;
+//# sourceMappingURL=endsWith.d.ts.map

package/esm/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/esm/expectations/endsWith.js

@@ -0,0 +1,22 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/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
+ */
+export const endsWith = Expectation.define('endsWith', 'end with', (actual, expected) => actual.endsWith(expected));
+//# sourceMappingURL=endsWith.js.map

package/esm/expectations/endsWith.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"endsWith.js","sourceRoot":"","sources":["../../src/expectations/endsWith.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,WAAW,CAAC,MAAM,CACtC,UAAU,EAAE,UAAU,EACtB,CAAC,MAAc,EAAE,QAAgB,EAAE,EAAE,CACjC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAChC,CAAA"}

package/esm/expectations/equals.d.ts

@@ -0,0 +1,28 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Produces an [expectation](https://serenity-js.org/api/core/class/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/esm/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,GAEd,CAAC,wEAEL,CAAC"}

package/esm/expectations/equals.js

@@ -0,0 +1,29 @@
+import { Expectation } from '@serenity-js/core';
+import { equal } from 'tiny-types/lib/objects/index.js';
+/**
+ * Produces an [expectation](https://serenity-js.org/api/core/class/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 const equals = Expectation.define('equals', 'equal', (actual, expected) => equal(actual, expected));
+//# sourceMappingURL=equals.js.map

package/esm/expectations/equals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"equals.js","sourceRoot":"","sources":["../../src/expectations/equals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,KAAK,EAAE,MAAM,iCAAiC,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CACpC,QAAQ,EAAE,OAAO,EACjB,CAAI,MAAS,EAAE,QAAW,EAAE,EAAE,CAC1B,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,CAC9B,CAAC"}

package/esm/expectations/includes.d.ts

@@ -0,0 +1,41 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/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')),
+ * )
+ * ```
+ *
+ * ## Ensuring that page URL includes the expected substring
+ *
+ * [`Page.current().url()`](https://serenity-js.org/api/web/class/Page/#url) returns a [`QuestionAdapter<URL>`](https://serenity-js.org/api/core/#QuestionAdapter)
+ * a proxy object around the standard Node.js [URL](https://nodejs.org/api/url.html) class,
+ * offering access to `string` properties such as [`hostname`](https://nodejs.org/api/url.html#urlobjecthostname),
+ * [`pathname`](https://nodejs.org/api/url.html#urlobjectpathname), and so on.
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, includes } from '@serenity-js/assertions'
+ * import { Navigate, Page } from '@serenity-js/web'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Navigate.to('https://serenity-js.org/handbook'),
+ *   Ensure.that(Page.current().url().hostname, includes('serenity-js')),
+ *   Ensure.that(Page.current().url().pathname, includes('book')),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+export declare const includes: (expected: import("@serenity-js/core").Answerable<string>) => Expectation<string>;
+//# sourceMappingURL=includes.d.ts.map

package/esm/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,QAAQ,mFAIpB,CAAC"}

package/esm/expectations/includes.js

@@ -0,0 +1,41 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/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')),
+ * )
+ * ```
+ *
+ * ## Ensuring that page URL includes the expected substring
+ *
+ * [`Page.current().url()`](https://serenity-js.org/api/web/class/Page/#url) returns a [`QuestionAdapter<URL>`](https://serenity-js.org/api/core/#QuestionAdapter)
+ * a proxy object around the standard Node.js [URL](https://nodejs.org/api/url.html) class,
+ * offering access to `string` properties such as [`hostname`](https://nodejs.org/api/url.html#urlobjecthostname),
+ * [`pathname`](https://nodejs.org/api/url.html#urlobjectpathname), and so on.
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, includes } from '@serenity-js/assertions'
+ * import { Navigate, Page } from '@serenity-js/web'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Navigate.to('https://serenity-js.org/handbook'),
+ *   Ensure.that(Page.current().url().hostname, includes('serenity-js')),
+ *   Ensure.that(Page.current().url().pathname, includes('book')),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+export const includes = Expectation.define('includes', 'include', (actual, expected) => actual.includes(expected));
+//# sourceMappingURL=includes.js.map

package/esm/expectations/includes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"includes.js","sourceRoot":"","sources":["../../src/expectations/includes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,WAAW,CAAC,MAAM,CACtC,UAAU,EAAE,SAAS,EACrB,CAAC,MAAc,EAAE,QAAgB,EAAE,EAAE,CACjC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAChC,CAAC"}

package/esm/expectations/index.d.ts

@@ -0,0 +1,21 @@
+export * from './and.js';
+export * from './contain.js';
+export * from './containAtLeastOneItemThat.js';
+export * from './containItemsWhereEachItem.js';
+export * from './endsWith.js';
+export * from './equals.js';
+export * from './includes.js';
+export * from './isAfter.js';
+export * from './isBefore.js';
+export * from './isCloseTo.js';
+export * from './isFalse.js';
+export * from './isGreaterThan.js';
+export * from './isLessThan.js';
+export * from './isPresent.js';
+export * from './isTrue.js';
+export * from './matches.js';
+export * from './not.js';
+export * from './or.js';
+export * from './property.js';
+export * from './startsWith.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/expectations/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}

package/esm/expectations/index.js

@@ -0,0 +1,21 @@
+export * from './and.js';
+export * from './contain.js';
+export * from './containAtLeastOneItemThat.js';
+export * from './containItemsWhereEachItem.js';
+export * from './endsWith.js';
+export * from './equals.js';
+export * from './includes.js';
+export * from './isAfter.js';
+export * from './isBefore.js';
+export * from './isCloseTo.js';
+export * from './isFalse.js';
+export * from './isGreaterThan.js';
+export * from './isLessThan.js';
+export * from './isPresent.js';
+export * from './isTrue.js';
+export * from './matches.js';
+export * from './not.js';
+export * from './or.js';
+export * from './property.js';
+export * from './startsWith.js';
+//# sourceMappingURL=index.js.map

package/esm/expectations/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/expectations/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}

package/esm/expectations/isAfter.d.ts

@@ -0,0 +1,42 @@
+import { Expectation, type Timestamp } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/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<Timestamp | Date>) => Expectation<Timestamp | Date>;
+//# sourceMappingURL=isAfter.d.ts.map

package/esm/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,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,OAAO,uGAanB,CAAC"}

package/esm/expectations/isAfter.js

@@ -0,0 +1,50 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/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 const isAfter = Expectation.define('isAfter', 'have value that is after', (actual, expected) => {
+    const actualInMilliseconds = actual instanceof Date
+        ? actual.getTime()
+        : actual.toMilliseconds();
+    const expectedInMilliseconds = expected instanceof Date
+        ? expected.getTime()
+        : expected.toMilliseconds();
+    return actualInMilliseconds > expectedInMilliseconds;
+});
+//# sourceMappingURL=isAfter.js.map

package/esm/expectations/isAfter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isAfter.js","sourceRoot":"","sources":["../../src/expectations/isAfter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,CACrC,SAAS,EAAE,0BAA0B,EACrC,CAAC,MAAwB,EAAE,QAA0B,EAAE,EAAE;IACrD,MAAM,oBAAoB,GAAG,MAAM,YAAY,IAAI;QAC/C,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE;QAClB,CAAC,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;IAE9B,MAAM,sBAAsB,GAAG,QAAQ,YAAY,IAAI;QACnD,CAAC,CAAC,QAAQ,CAAC,OAAO,EAAE;QACpB,CAAC,CAAC,QAAQ,CAAC,cAAc,EAAE,CAAC;IAEhC,OAAO,oBAAoB,GAAG,sBAAsB,CAAC;AACzD,CAAC,CACJ,CAAC"}

package/esm/expectations/isBefore.d.ts

@@ -0,0 +1,42 @@
+import { Expectation, type Timestamp } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/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<Timestamp | Date>) => Expectation<Timestamp | Date>;
+//# sourceMappingURL=isBefore.d.ts.map

package/esm/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,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,QAAQ,uGAcpB,CAAC"}