@serenity-js/core 2.32.2 → 3.0.0-rc.0

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

@@ -1,198 +0,0 @@
-import { Reducible } from '../../io';
-import { Activity } from '../Activity';
-import { AnswersQuestions, PerformsActivities, UsesAbilities } from '../actor';
-import { Answerable } from '../Answerable';
-import { Question } from '../Question';
-import { Task } from '../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}
- */
-export declare class Loop<Item> extends Task {
-    private readonly items;
-    private readonly activities;
-    private static currentItem;
-    private static currentIndex;
-    /**
-     * @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<T>(items: Answerable<Reducible>): {
-        to: (...activities: Activity[]) => Loop<T>;
-    };
-    /**
-     * @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<ExpectedType = any>(): Question<ExpectedType>;
-    /**
-     * @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(): Question<number>;
-    /**
-     * @param {Answerable<Reducible>} items
-     * @param {Activity[]} activities
-     */
-    constructor(items: Answerable<Reducible>, activities: Activity[]);
-    /**
-     * @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: PerformsActivities & UsesAbilities & AnswersQuestions): PromiseLike<void> | PromiseLike<any>;
-    /**
-     * @desc
-     *  Generates a description to be used when reporting this {@link Activity}.
-     *
-     * @returns {string}
-     */
-    toString(): string;
-}
-/**
- * @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}
- */

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.map

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

package/src/decorators/pending.ts

@@ -1 +0,0 @@
-// class-level

package/src/decorators/step.ts

@@ -1 +0,0 @@
-// performAs level; sets a toString; deprecated

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/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,50 +0,0 @@
-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));
-    }
-}

package/src/screenplay/questions/mappings/AnswerMappingFunction.ts

@@ -1,13 +0,0 @@
-import { MappingFunction } from '../../../io/collections';
-import { AnswersQuestions } from '../../actor';
-
-/**
- * @desc
- *  A mapping function converting one type into another.
- *
- * @public
- *
- * @typedef {function(actor: AnswersQuestions) => MappingFunction<V,O>} AnswerMappingFunction<V, O>
- */
-export type AnswerMappingFunction<V, O> =
-    (actor: AnswersQuestions) => MappingFunction<V, Promise<O> | O>

package/src/screenplay/questions/mappings/index.ts

@@ -1,2 +0,0 @@
-export * from './AnswerMappingFunction';
-export * from './string';