@serenity-js/core 2.32.7 → 3.0.0-rc.10

package/lib/screenplay/tasks/Loop.js

@@ -1,222 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Loop = void 0;
-const io_1 = require("../../io");
-const Question_1 = require("../Question");
-const Task_1 = require("../Task");
-/**
- * @desc
- *  Enables the {@link Actor} to iterate over a list of items produced by any {@link Answerable}.
- *
- *  You can think of `Loop` as a more sophisticated Screenplay-style equivalent of
- *  [`Array.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach).
- *  `Loop` is capable of working with both synchronous data structures,
- *  such as [`Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
- *  and `Question<Array<T>>`,
- *  as well as asynchronous ones, so `Promise<Array<T>>` and `Question<Promise<Array<T>>>`.
- *
- *  Use {@link Loop.item} to access the current item being processed by {@link Loop}, and {@link Loop.index}
- *  to access the index of {@link Loop.item} in the list.
- *
- * @example <caption>Basic scenario - Iterating over a static list of items</caption>
- *  import { actorCalled, Loop, Log } from '@serenity-js/core';
- *
- *  actorCalled('Joe').attemptsTo(
- *      Loop.over([ 'apple', 'banana', 'candy' ]).to(
- *          Log.the('current element', Loop.item<string>()),
- *          Log.the('current index', Loop.index()),
- *      ),
- *  );
- *
- * @example <caption>API scenario - Iterating over items in an API response</caption>
- *
- *  import { actorCalled, Loop } from '@serenity-js/core';
- *  import { Send, GetRequest, CallAnApi, LastResponse } from '@serenity-js/rest';
- *  import { Ensure, property, isGreaterThan } from '@serenity-js/assertions';
- *
- *  interface TodoItem {
- *      userId: number;
- *      id: number;
- *      title: string;
- *      completed: boolean;
- *  }
- *
- *  actorCalled('Joe').whoCan(
- *      CallAnApi.at('https://jsonplaceholder.typicode.com')
- *  ).attemptsTo(
- *      Send.a(GetRequest.to('/todos')),
- *      Loop.over(LastResponse.body<TodoItem[]>()).to(
- *          Ensure.that(
- *              Loop.item<TodoItem>(),
- *              property('userId', isGreaterThan(0)),
- *          ),
- *      )
- *  );
- *
- * @example <caption>UI scenario - Example widget</caption>
- *  <nav>
- *      <div data-test="cookies">
- *          <label for="functional-cookies">
- *              <input type="checkbox" id="functional-cookies" />Allow functional cookies
- *          </label>
- *          <label for="performance-cookies">
- *              <input type="checkbox" id="performance-cookies" />Allow performance cookies
- *          </label>
- *          <label for="advertising-cookies">
- *              <input type="checkbox" id="advertising-cookies" />Allow advertising cookies
- *          </label>
- *      </div>
- *  </nav>
- *
- * @example <caption>UI scenario - Lean Page Object</caption>
- *  import { Target } from '@serenity-js/protractor';
- *  import { browser, by } from 'protractor';
- *
- *  class Cookies {
- *      static labels = Target.all('cookie options')
- *          .located(by.css('[data-test="cookies"]'));
- *
- *      static checkbox = Target.the('checkbox')
- *          .located(by.tagName('input')),
- *  }
- *
- * @example <caption>UI scenario - Performing the same set of activities with each element</caption>
- *  import { actorCalled, Loop } from '@serenity-js/core';
- *  import { Click, Text, isSelected } from '@serenity-js/protractor';
- *  import { Ensure, startsWith } from '@serenity-js/assertions';
- *  import { protractor } from 'protractor';
- *
- *  actorCalled('Joe')
- *      .whoCan(BrowseTheWeb.using(protractor.browser))
- *      .attemptsTo(
- *          Loop.over(Cookies.labels).to(
- *               Ensure.that(
- *                  Text.of(Loop.item<ElementFinder>()),
- *                  startsWith('Allow'),
- *              ),
- *
- *              Click.on(Loop.item<ElementFinder>()),
- *              Ensure.that(
- *                  Cookies.checkbox.of(Loop.item<ElementFinder>()),
- *                  isSelected(),
- *              ),
- *          ),
- *      );
- *
- * @extends {Task}
- *
- * @see {@link Loop.item}
- * @see {@link Loop.index}
- * @see {@link Question}
- */
-class Loop extends Task_1.Task {
-    /**
-     * @param {Answerable<Reducible>} items
-     * @param {Activity[]} activities
-     */
-    constructor(items, activities) {
-        super();
-        this.items = items;
-        this.activities = activities;
-    }
-    /**
-     * @desc
-     *  Instantiates a {@link Task} to {@link Loop}
-     *  that enables the {@link Actor} to iterate over `items`
-     *  to perform some `activities`.
-     *
-     * @param {items: Answerable<ReducibleCollection>} items
-     * @returns {LoopBuilder}
-     */
-    static over(items) {
-        return {
-            to: (...activities) => new Loop(items, activities)
-        };
-    }
-    /**
-     * @desc
-     *  Returns the current item being processed by {@link Loop.over}.
-     *
-     *  **Please note** that in order for the TypeScript transpiler to understand the exact `ExpectedType`
-     *  of the {@link Question} produced by this method you can optionally configure it with
-     *  a [_type variable_](https://www.typescriptlang.org/docs/handbook/generics.html).
-     *
-     *  For example, configuring the method with type variable of `string`, so `Loop.item<string>()`,
-     *  tells the transpiler that a `Question<string>` will be returned.
-     *
-     *  If the type variable is not configured, the transpiler assumes that returned type is a
-     *  `Question<any>`. This means that while your code could still work, you'd miss out
-     *  on checking provided by TypeScript.
-     *
-     * @returns {Question<ExpectedType>}
-     */
-    static item() {
-        return Question_1.Question.about(`current loop item`, actor => Loop.currentItem);
-    }
-    /**
-     * @desc
-     *  Returns the index of current {@link Loop.item} in the `Answerable<Array>` given to {@link Loop.over}.
-     *
-     *  The index starts at `0`.
-     *
-     * @returns {Question<number>}
-     */
-    static index() {
-        return Question_1.Question.about(`current loop index`, actor => Loop.currentIndex);
-    }
-    /**
-     * @desc
-     *  Makes the provided {@link Actor}
-     *  perform this {@link Task}.
-     *
-     * @param {PerformsActivities & UsesAbilities & AnswersQuestions} actor
-     * @returns {Promise<void>}
-     *
-     * @see {@link Actor}
-     * @see {@link PerformsActivities}
-     * @see {@link UsesAbilities}
-     * @see {@link AnswersQuestions}
-     */
-    performAs(actor) {
-        return actor.answer(this.items)
-            .then(items => items.reduce((previous, current, index) => {
-            return previous.then(() => {
-                Loop.currentIndex = index;
-                Loop.currentItem = current;
-                return actor.attemptsTo(...this.activities);
-            });
-        }, Promise.resolve(void 0)));
-    }
-    /**
-     * @desc
-     *  Generates a description to be used when reporting this {@link Activity}.
-     *
-     * @returns {string}
-     */
-    toString() {
-        const description = Array.isArray(this.items)
-            ? `a list of ${this.items.length} item${this.items.length !== 1 ? 's' : ''}`
-            : (0, io_1.formatted) `${this.items}`;
-        return `#actor loops over ${description}`;
-    }
-}
-exports.Loop = Loop;
-Loop.currentItem = undefined;
-Loop.currentIndex = 0;
-/**
- * @typedef {Object} LoopBuilder
- * @property {function(...activities: Activity[]): Loop} to
- *
- * @example <caption>Basic scenario - Iterating over a static list of items</caption>
- *  import { actorCalled, Loop, Log } from '@serenity-js/core';
- *
- *  actorCalled('Joe').attemptsTo(
- *      Loop.over([ 'apple', 'banana', 'candy' ]).to(
- *          Log.the('current element', Loop.item<string>()),
- *      ),
- *  );
- *
- * @see {@link Loop}
- * @see {@link Loop.over}
- */
-//# sourceMappingURL=Loop.js.map

package/lib/screenplay/tasks/Loop.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Loop.js","sourceRoot":"","sources":["../../../src/screenplay/tasks/Loop.ts"],"names":[],"mappings":";;;AAAA,iCAAgD;AAIhD,0CAAuC;AACvC,kCAA+B;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwGG;AACH,MAAa,IAAW,SAAQ,WAAI;IAyDhC;;;OAGG;IACH,YACqB,KAA4B,EAC5B,UAAsB;QAEvC,KAAK,EAAE,CAAC;QAHS,UAAK,GAAL,KAAK,CAAuB;QAC5B,eAAU,GAAV,UAAU,CAAY;IAG3C,CAAC;IA9DD;;;;;;;;OAQG;IACH,MAAM,CAAC,IAAI,CAAI,KAA4B;QACvC,OAAO;YACH,EAAE,EAAE,CAAC,GAAG,UAAsB,EAAE,EAAE,CAC9B,IAAI,IAAI,CAAI,KAAK,EAAE,UAAU,CAAC;SACrC,CAAA;IACL,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,IAAI;QACP,OAAO,mBAAQ,CAAC,KAAK,CAAe,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAC7D,IAAI,CAAC,WAA2B,CACnC,CAAC;IACN,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,KAAK;QACR,OAAO,mBAAQ,CAAC,KAAK,CAAS,oBAAoB,EAAE,KAAK,CAAC,EAAE,CACxD,IAAI,CAAC,YAAY,CACpB,CAAC;IACN,CAAC;IAaD;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,KAA4D;QAClE,OAAO,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;aAC1B,IAAI,CAAC,KAAK,CAAC,EAAE,CACV,KAAK,CAAC,MAAM,CAAC,CAAC,QAAuB,EAAE,OAAa,EAAE,KAAa,EAAE,EAAE;YACnE,OAAO,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE;gBACtB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;gBAC1B,IAAI,CAAC,WAAW,GAAI,OAAO,CAAC;gBAE5B,OAAO,KAAK,CAAC,UAAU,CACnB,GAAG,IAAI,CAAC,UAAU,CACrB,CAAC;YACN,CAAC,CAAC,CAAC;QACP,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAC9B,CAAC;IACV,CAAC;IAED;;;;;OAKG;IACH,QAAQ;QACJ,MAAM,WAAW,GAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC;YAC1C,CAAC,CAAC,aAAc,IAAI,CAAC,KAAK,CAAC,MAAO,QAAS,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAG,EAAE;YAChF,CAAC,CAAC,IAAA,cAAS,EAAC,GAAI,IAAI,CAAC,KAAM,EAAE,CAAC;QAElC,OAAO,qBAAsB,WAAY,EAAE,CAAC;IAChD,CAAC;;AA7GL,oBA8GC;AA7GkB,gBAAW,GAAY,SAAS,CAAC;AACjC,iBAAY,GAAG,CAAC,CAAC;AA8GpC;;;;;;;;;;;;;;;GAeG"}

package/lib/screenplay/tasks/index.d.ts

@@ -1 +0,0 @@
-export * from './Loop';

package/lib/screenplay/tasks/index.js

@@ -1,14 +0,0 @@
-"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]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Loop"), exports);
-//# sourceMappingURL=index.js.map

package/lib/screenplay/tasks/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/screenplay/tasks/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,yCAAuB"}

package/lib/stage/DressingRoom.d.ts

@@ -1,37 +0,0 @@
-import { Ability, Actor } from '../screenplay';
-/**
- * @desc
- *  Prepares the {@link Actor} for the performance.
- *
- * @example <caption>A dressing room for actors interacting with a Web UI</caption>
- *
- *  import { serenity, Actor, DressingRoom } from '@serenity-js/core'
- *  import { BrowseTheWeb } from '@serenity-js/protractor'
- *  import { protractor } from 'protractor'
- *
- *  class UIActors implements DressingRoom {
- *      prepare(actor: Actor) {
- *          return actor.whoCan(BrowseTheWeb.using(protractor.browser));
- *      }
- *  }
- *
- *  const stage = serenity.callToStageFor(new UIActors());
- *
- * @see {@link Stage}
- * @see {@link Cast}
- * @interface
- *
- * @deprecated Please use the Cast instead
- */
-export declare abstract class DressingRoom {
-    /**
-     * @desc
-     *  Creates a generic `DressingRoom` implementation, where every actor
-     *  is given all the abilities specified when the method is called.
-     *
-     * @param {Ability[]} abilities
-     * @returns {DressingRoom}
-     */
-    static whereEveryoneCan(...abilities: Ability[]): DressingRoom;
-    abstract prepare(actor: Actor): Actor;
-}

package/lib/stage/DressingRoom.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DressingRoom = void 0;
-/**
- * @desc
- *  Prepares the {@link Actor} for the performance.
- *
- * @example <caption>A dressing room for actors interacting with a Web UI</caption>
- *
- *  import { serenity, Actor, DressingRoom } from '@serenity-js/core'
- *  import { BrowseTheWeb } from '@serenity-js/protractor'
- *  import { protractor } from 'protractor'
- *
- *  class UIActors implements DressingRoom {
- *      prepare(actor: Actor) {
- *          return actor.whoCan(BrowseTheWeb.using(protractor.browser));
- *      }
- *  }
- *
- *  const stage = serenity.callToStageFor(new UIActors());
- *
- * @see {@link Stage}
- * @see {@link Cast}
- * @interface
- *
- * @deprecated Please use the Cast instead
- */
-class DressingRoom {
-    /**
-     * @desc
-     *  Creates a generic `DressingRoom` implementation, where every actor
-     *  is given all the abilities specified when the method is called.
-     *
-     * @param {Ability[]} abilities
-     * @returns {DressingRoom}
-     */
-    static whereEveryoneCan(...abilities) {
-        return new GenericDressingRoom(abilities);
-    }
-}
-exports.DressingRoom = DressingRoom;
-/**
- * @package
- */
-class GenericDressingRoom {
-    constructor(abilities) {
-        this.abilities = abilities;
-    }
-    prepare(actor) {
-        return actor.whoCan(...this.abilities);
-    }
-}
-//# sourceMappingURL=DressingRoom.js.map

package/lib/stage/DressingRoom.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DressingRoom.js","sourceRoot":"","sources":["../../src/stage/DressingRoom.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAsB,YAAY;IAC9B;;;;;;;OAOG;IACH,MAAM,CAAC,gBAAgB,CAAC,GAAG,SAAoB;QAC3C,OAAO,IAAI,mBAAmB,CAAC,SAAS,CAAC,CAAC;IAC9C,CAAC;CAGJ;AAdD,oCAcC;AAED;;GAEG;AACH,MAAM,mBAAmB;IACrB,YAA6B,SAAoB;QAApB,cAAS,GAAT,SAAS,CAAW;IACjD,CAAC;IAED,OAAO,CAAC,KAAY;QAChB,OAAO,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;IAC3C,CAAC;CACJ"}

package/lib/stage/WithStage.d.ts

@@ -1,51 +0,0 @@
-import { Stage } from './Stage';
-/**
- * @desc Makes the {@link Stage} object setup in your test runner configuration visible
- * to test steps or test scenarios.
- *
- * When using Cucumber, the {@link Stage} is typically set up using the Cucumber World Constructor.
- * When using Jasmine, the {@link Stage} is typically set up in the `beforeEach` step.
- *
- * @see https://github.com/cucumber/cucumber-js/blob/v5.0.1/docs/support_files/api_reference.md
- * @see https://github.com/cucumber/cucumber-js/blob/v5.0.1/docs/support_files/step_definitions.md
- * @see https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters
- *
- * @example <caption>Usage with Cucumber.js</caption>
- * // features/support/configure_serenity.ts
- * import { WithStage } from '@serenity-js/core';
- * import { setWorldConstructor } from 'cucumber';
- *
- * setWorldConstructor(function (this: WithStage, { parameters }) {
- *   this.stage = serenity.callToStageFor(new SomeImplementationOfTheCastInterface());
- * });
- *
- * // features/step_definitions/some.steps.ts
- * import { WithStage } from '@serenity-js/cucumber';
- *
- * Given(/(.*?) is a registered customer/, function (this: WithStage, actorName: string) {
- *   return this.stage.actor(actorName).attemptsTo(
- *
- *   );
- * });
- *
- * @example <caption>Usage with Jasmine</caption>
- * // spec/some.spec.ts
- * import { serenity, WithStage } from '@serenity-js/core';
- *
- * describe('Using the Stage', () => {
- *   beforeEach(function (this: WithStage) {
- *     this.stage = serenity.callToStageFor(new SomeImplementationOfTheCastInterface());
- *   });
- *
- *   it('makes it easy to access the Actors', function(this: WithStage) {
- *     return this.stage.theActorCalled('Barry').attemptsTo(
- *       // tasks
- *     );
- *   })
- * });
- *
- * @deprecated Please use serenity.actor() and serenity.actorInTheSpotlight() instead
- */
-export interface WithStage {
-    stage: Stage;
-}

package/lib/stage/WithStage.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=WithStage.js.map

package/lib/stage/WithStage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"WithStage.js","sourceRoot":"","sources":["../../src/stage/WithStage.ts"],"names":[],"mappings":""}

package/src/io/collections/index.ts

@@ -1,2 +0,0 @@
-export * from './mappable';
-export * from './reducible';

package/src/io/collections/mappable.ts

@@ -1,60 +0,0 @@
-/**
- * @desc
- *  Describes a collection providing
- *  a [`map`-like interface](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map).
- *
- * @interface
- *
- * @see {@link Question#map}
- * @see {@link ElementArrayFinder}
- */
-export interface Mappable<Item> {
-
-    /**
-     * @desc
-     *  Applies a {@link MappingFunction} function to each element of a {@link Mappable} collection.
-     *
-     *  The callback receives an item from the collection as the first argument
-     *  and its index as the second argument.
-     *
-     * @abstract
-     *
-     * @type {function<U>(callback: (item?: Item, index?: number) => U): PromiseLike<U[]> | U[]}
-     */
-    map: <U>(callback: (item?: Item, index?: number) => U) => PromiseLike<U[]> | U[];
-}
-
-/**
- * @desc
- *  A mapping function converting one type into another.
- *
- * @public
- *
- * @typedef {function(item?: V, index?: number) => Promise<O> | O} Mapping<V,O>
- */
-export type MappingFunction<V, O> =
-    (item?: V, index?: number) => O;
-
-/**
- * @desc
- *  Checks if the value is a {@link Mappable} collection of items.
- *
- * @example <caption>An Array</caption>
- *  import { Mappable } from '@serenity-js/core/lib/io';
- *
- *  Mappable.isMappable([ 1, 2, 3 ]) === true
- *
- * @example <caption>Protractor's ElementArrayFinder</caption>
- *  import { Mappable } from '@serenity-js/core/lib/io';
- *  import { element } from 'protractor';
- *
- *  Mappable.isMappable(element.all(by.tagName('li')) === true
- *
- * @param {Mappable<Item> | any} maybeCollection
- * @returns {boolean}
- */
-export function isMappable<Item>(maybeCollection: Mappable<Item> | any): maybeCollection is Mappable<Item> {
-    return !! maybeCollection
-        && !! maybeCollection.map
-        && typeof maybeCollection.map === 'function';
-}

package/src/io/collections/reducible.ts

@@ -1,16 +0,0 @@
-/**
- * @desc
- *  Describes a collection providing
- *  a [`reduce`-like interface](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce).
- *
- * @interface
- *
- * @see {@link ElementArrayFinder}
- * @see {@link Loop}
- */
-export interface Reducible {
-    /**
-     * @type {function<T,A>(callback: (accumulator: A, currentValue: T, index: number) => A, initialValue: A): PromiseLike<A> | A}
-     */
-    reduce: <T, A>(fn: (accumulator: A, currentValue: T, index: number) => A, initialValue: A) => PromiseLike<A> | A;
-}

package/src/screenplay/interactions/See.ts

@@ -1,45 +0,0 @@
-import { AnswersQuestions, Interaction, Question } from '..';
-
-export type Assertion<A> = (actual: A) => void;
-
-/**
- * @deprecated
- *  Use the <a href="/modules/assertions"><code>@serenity-js/assertions</code> module</a> instead
- */
-export class See<S> extends Interaction {
-    static if<T>(question: Question<T>, assertion: Assertion<T>): Interaction {
-        return new See<T>(question, assertion);
-    }
-
-    constructor(
-        private question: Question<S>,
-        private assert: Assertion<S>,
-    ) {
-        super();
-    }
-
-    /**
-     * @desc
-     *  Makes the provided {@link Actor}
-     *  perform this {@link Interaction}.
-     *
-     * @param {AnswersQuestions} actor
-     * @returns {Promise<void>}
-     *
-     * @see {@link Actor}
-     * @see {@link AnswersQuestions}
-     */
-    performAs(actor: AnswersQuestions): PromiseLike<void> {
-        return actor.answer(this.question).then(this.assert);
-    }
-
-    /**
-     * @desc
-     *  Generates a description to be used when reporting this {@link Activity}.
-     *
-     * @returns {string}
-     */
-    toString(): string {
-        return `#actor checks ${this.question}`;
-    }
-}

package/src/screenplay/questions/Property.ts

@@ -1,98 +0,0 @@
-import { Answerable } from '../Answerable';
-import { createMetaQuestionProxy, createQuestionProxy, WithPropertiesAsMetaQuestions, WithPropertiesAsQuestions } from './proxies';
-
-/**
- * @desc
- *  Enables easy access to properties of the value of a given {@link Answerable}.
- *
- * @example <caption>Example API response</caption>
- *  interface EnvironmentDetails {
- *      name: string;
- *      url:  string;
- *  }
- *
- *  interface EnvironmentsResponse {
- *      environments: EnvironmentDetails[];
- *  }
- *
- *  const response: EnvironmentsResponse = {
- *     "environments": [
- *         {
- *             "name": "dev",
- *             "url":  "https://dev.example.com"
- *         },
- *         {
- *             "name": "sit",
- *             "url":  "https://sit.example.com"
- *         }
- *     ]
- *  }
- *
- * @example <caption>Combining Property.of and Property.at</caption>
- *  import { actorCalled, List, Property } from '@serenity-js/core';
- *  import { Ensure, equals } from '@serenity-js/assertions';
- *
- *  actorCalled('Lisa').attemptsTo(
- *      Ensure.that(
- *          Property.of(
- *              List.of(response.environments)
- *                  .where(Property.at<EnvironmentDetails>().name, equals('dev'))
- *                  .first(),
- *          ).url,
- *          equals('https://dev.example.com')
- *      )
- *  )
- *
- * @see {@link Question}
- * @see {@link List}
- */
-export class Property {
-
-    /**
-     * @desc
-     *  Generates a {@link Proxy} around a given {@link Answerable} `subject`
-     *  to turn the properties of the value it will resolve to into {@link Question}s.
-     *
-     * @example <caption>Reading a property</caption>
-     *  import { actorCalled, Property } from '@serenity-js/core';
-     *  import { Ensure, equals } from '@serenity-js/assertions';
-     *
-     *  actorCalled('Lisa').attemptsTo(
-     *      Ensure.that(
-     *          Property.of(response).environments[0].name,
-     *          equals('dev')
-     *      )
-     *  )
-     *
-     * @param {Answerable<Subject>} subject
-     * @returns {Proxy<Subject>}
-     */
-    static of<Subject extends object>(subject: Answerable<Subject>): WithPropertiesAsQuestions<Subject> {   // eslint-disable-line @typescript-eslint/ban-types
-        return createQuestionProxy<Subject>(subject);
-    }
-
-    /**
-     * @desc
-     *  Generates a {@link Proxy} around a given {@link Answerable} `subject`
-     *  to turn any of its properties into {@link MetaQuestion}s
-     *  to be used when filtering a {@link List},
-     *
-     * @example <caption>Reading a property</caption>
-     *  import { actorCalled, Property } from '@serenity-js/core';
-     *  import { Ensure, equals } from '@serenity-js/assertions';
-     *
-     *  actorCalled('Lisa').attemptsTo(
-     *      Ensure.that(
-     *          List.of(response.environments)
-     *              .where(Property.at<EnvironmentDetails>().name, equals('dev'))
-     *              .first(),
-     *          equals(response.environments[0])
-     *      )
-     *  )
-     *
-     * @returns {Proxy<Subject>}
-     */
-    static at<Subject extends object>(): WithPropertiesAsMetaQuestions<Subject> {   // eslint-disable-line @typescript-eslint/ban-types
-        return createMetaQuestionProxy<Subject>();
-    }
-}

package/src/screenplay/questions/Transform.ts

@@ -1,51 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unnecessary-type-constraint */
-import { AnswersQuestions, UsesAbilities } from '../actor';
-import { Answerable } from '../Answerable';
-import { Question } from '../Question';
-
-/**
- * @experimental
- */
-export class Transform<Answer_Type extends any, Output_Type> extends Question<Promise<Output_Type>> {
-    static the<AT extends any, OT>(questions: Answerable<AT> | Array<Answerable<AT>>, transformation: (...answers: AT[]) => OT): Transform<AT, OT> {
-        return new Transform<AT, OT>([].concat(questions), transformation);
-    }
-
-    constructor(
-        private readonly questions: Array<Answerable<Answer_Type>>,
-        private readonly transformation: (...answers: Answer_Type[]) => Output_Type,
-        private readonly description: string = `a transformed answer`,
-    ) {
-        super(description);
-    }
-
-    /**
-     * @deprecated
-     *  Please use {@link Transform#describedAs} instead
-     *
-     * @desc
-     *  Overrides the default {@link Transform#toString} representation of this object.
-     *
-     * @param {string} description
-     * @returns {Transform<Answer_Type, Output_Type>}
-     */
-    as(description: string): Transform<Answer_Type, Output_Type> {
-        return this.describedAs(description);
-    }
-
-    /**
-     * Changes the description of this question's subject.
-     *
-     * @param subject
-     */
-    describedAs(subject: string): this {
-        this.subject = subject;
-
-        return this;
-    }
-
-    answeredBy(actor: AnswersQuestions & UsesAbilities): Promise<Output_Type> {
-        return Promise.all(this.questions.map(question => actor.answer(question)))
-            .then(answers => this.transformation(...answers));
-    }
-}