@serenity-js/core 3.0.0-rc.9 → 3.0.0

package/lib/screenplay/notes/TakeNotes.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TakeNotes = void 0;
+const abilities_1 = require("../abilities");
+const Notepad_1 = require("./Notepad");
+/**
+ * An {@apilink Ability} that enables an {@apilink Actor} to remember information
+ * to be recalled during a test scenario.
+ *
+ * Under the hood, {@apilink TakeNotes} uses a {@apilink Notepad}, which state
+ * can be populated both during initialisation or while the test scenario is executed.
+ * Populating the notepad when it's initialised can be useful to associate authentication credentials
+ * or personal details with a given actor, while dynamic recording of notes during a test scenario
+ * can be useful when the data to be recorded is not known upfront - for example when we want
+ * the actor to remember a JWT stored in the browser and then use it when sending API requests.
+ *
+ * **Pro tip:** {@apilink TakeNotes}, {@apilink Notepad} and {@apilink notes} can be typed
+ * using [TypeScript generics](https://www.typescriptlang.org/docs/handbook/2/generics.html)
+ * to help you avoid typos when specifying note names.
+ *
+ * See [notes](/api/core/function/notes) and {@apilink Notepad} for more usage examples.
+ *
+ * ## Remembering and retrieving a value
+ *
+ * ```ts
+ * import { actorCalled, Log, notes, TakeNotes } from '@serenity-js/core'
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.usingAnEmptyNotepad())
+ *   .attemptsTo(
+ *     notes().set('my_note', 'some value'),
+ *     Log.the(notes().get('my_note')),
+ *     // emits 'some value'
+ *   )
+ * ```
+ *
+ * ## Using generics
+ *
+ * ```ts
+ *  import { actorCalled, Log, notes, TakeNotes } from '@serenity-js/core'
+ *
+ *  interface MyNotes {
+ *    personalDetails: {
+ *      firstName: string;
+ *      lastName: string;
+ *    }
+ *  }
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.usingAnEmptyNotepad<MyNotes>())
+ *   .attemptsTo(
+ *     Log.the(notes<MyNotes>().has('personalDetails')),
+ *     // emits false
+ *
+ *     Log.the(notes<MyNotes>().get('personalDetails').isPresent()),
+ *     // emits false
+ *
+ *     notes<MyNotes>().set('personalDetails', { firstName: 'Leonard', lastName: 'McLaud' }),
+ *
+ *     Log.the(notes<MyNotes>().has('personalDetails')),
+ *     // emits true
+ *
+ *     Log.the(notes<MyNotes>().get('personalDetails').isPresent()),
+ *     // emits true
+ *
+ *     Log.the(notes().get('personalDetails').firstName),
+ *     // emits 'Leonard'
+ *
+ *     Log.the(notes().get('personalDetails').firstName.toLocaleUpperCase()),
+ *     // emits 'LEONARD'
+ *   )
+ * ```
+ *
+ * ## Populating the notepad with initial state
+ *
+ * ```ts
+ * import { actorCalled, Log, Note, Notepad, TakeNotes } from '@serenity-js/core'
+ *
+ * interface MyNotes {
+ *   firstName: string;
+ *   lastName: string;
+ * }
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(
+ *     TakeNotes.using(Notepad.with<MyNotes>({
+ *       firstName: 'Leonard',
+ *       lastName: 'McLaud',
+ *     }))
+ *   )
+ *   .attemptsTo(
+ *     notes<MyNotes>().set('lastName', 'Shelby'),
+ *     Log.the(notes().get('firstName')),
+ *     // emits 'Leonard'
+ *
+ *     Log.the(notes().get('lastName')),
+ *     // emits 'Shelby'
+ *   )
+ * ```
+ *
+ * ## Recording a dynamic note
+ *
+ * ```ts
+ * import { actorCalled, Log, Notepad, notes, TakeNotes } from '@serenity-js/core'
+ * import { By, Text, PageElement } from '@serenity-js/web'
+ * import { BrowseTheWebWithWebdriverIO } from '@serenity-js/webdriverio'
+ *
+ * interface OnlineShoppingNotes {
+ *   promoCode: string;
+ * }
+ *
+ * const promoCodeBanner = () =>
+ *   PageElement.located(By.css('[data-testid="promo-code"]'))
+ *     .describedAs('promo code');
+ *
+ * const promoCodeInput = () =>
+ *   PageElement.located(By.css('[data-testid="promo-code-input"]'))
+ *     .describedAs('promo code field');
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(
+ *     BrowseTheWebWithWebdriverIO.using(browser),
+ *     TakeNotes.using(Notepad.empty<OnlineShoppingNotes>())
+ *   )
+ *   .attemptsTo(
+ *     notes<OnlineShoppingNotes>().set('promoCode', Text.of(promoCode()),
+ *     // ...
+ *     Enter.theValue(notes<OnlineShoppingNotes>().get('promoCode'))
+ *       .into(promoCodeInput())
+ *   )
+ * ```
+ *
+ * ## Clearing a notepad before each test scenario (Mocha)
+ *
+ * ```ts
+ * import 'mocha';
+ *
+ * beforeEach(() =>
+ *   actorCalled('Leonard')
+ *     .attemptsTo(
+ *       notes().clear(),
+ *     ))
+ * ```
+ *
+ * ## Clearing a notepad before each test scenario (Cucumber)
+ *
+ * ```ts
+ * import { Before } from '@cucumber/cucumber'
+ *
+ * Before(() =>
+ *   actorCalled('Leonard')
+ *     .attemptsTo(
+ *       notes().clear(),
+ *     ));
+ * ```
+ *
+ * ## Importing notes from an API response
+ *
+ * ```ts
+ *  // given an example API:
+ *  //   GET /generate-test-user
+ *  // which returns:
+ *  //   { "first_name": "Leonard", "last_name": "Shelby" }
+ *
+ * import { actorCalled, Log, Notepad, notes, TakeNotes } from '@serenity-js/core'
+ * import { CallAnApi, GetRequest, Send } from '@serenity-js/rest'
+ *
+ * interface PersonalDetails {
+ *   first_name: string;
+ *   last_name: string;
+ * }
+ *
+ * interface MyNotes {
+ *   personalDetails?: PersonalDetails;
+ * }
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(
+ *     CallAnApi.at('https://api.example.org/'),
+ *     TakeNotes.using(Notepad.empty<MyNotes>())
+ *   )
+ *   .attemptsTo(
+ *      Send.a(GetRequest.to('/generate-test-user')),
+ *      notes<MyNotes>().set('personalDetails', LastResponse.body<PersonalDetails>()),
+ *
+ *      Log.the(notes<MyNotes>().get('personalDetails').first_name),    // emits 'Leonard'
+ *      Log.the(notes<MyNotes>().get('personalDetails').last_name),     // emits 'Shelby'
+ *   )
+ * ```
+ *
+ * ## Using the QuestionAdapter
+ *
+ * ```ts
+ * import { actorCalled, Log, Notepad, notes, TakeNotes } from '@serenity-js/core'
+ *
+ * interface AuthCredentials {
+ *   username?: string;
+ *   password?: string;
+ * }
+ *
+ * interface MyNotes {
+ *   auth: AuthCredentials;
+ * }
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(
+ *     TakeNotes.using(
+ *       Notepad.with<MyNotes>({     // typed initial state
+ *         auth: {
+ *           username: 'leonard@example.org',
+ *           password: 'SuperSecretP@ssword!',
+ *         }
+ *       })
+ *     )
+ *   )
+ *   .attemptsTo(
+ *     Log.the(
+ *       notes<MyNotes>()          // typed notes
+ *         .get('auth')            // returns QuestionAdapter<AuthCredentials>
+ *         .password               // returns QuestionAdapter<string>
+ *         .charAt(0)
+ *         .toLocaleLowerCase(),   // emits "s"
+ *     ),
+ *   )
+ * ```
+ *
+ * ## Learn more
+ *
+ * - [notes](/api/core/function/notes)
+ * - {@apilink Notepad}
+ *
+ * @group Notes
+ */
+class TakeNotes extends abilities_1.Ability {
+    /**
+     * Initialises an {@apilink Ability} to {@apilink TakeNotes} with {@apilink Notepad.empty}.
+     */
+    static usingAnEmptyNotepad() {
+        return TakeNotes.using(Notepad_1.Notepad.empty());
+    }
+    /**
+     * Initialises an {@apilink Ability} to {@apilink TakeNotes} using
+     * a {@apilink Notepad.with} some initial state.
+     *
+     * @param notepad
+     */
+    static using(notepad) {
+        return new TakeNotes(notepad);
+    }
+    /**
+     * @param notepad
+     */
+    constructor(notepad) {
+        super();
+        this.notepad = notepad;
+    }
+}
+exports.TakeNotes = TakeNotes;
+//# sourceMappingURL=TakeNotes.js.map

package/lib/screenplay/notes/TakeNotes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TakeNotes.js","sourceRoot":"","sources":["../../../src/screenplay/notes/TakeNotes.ts"],"names":[],"mappings":";;;AAAA,4CAAuC;AACvC,uCAAoC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmOG;AACH,MAAa,SAA+C,SAAQ,mBAAO;IAEvE;;OAEG;IACH,MAAM,CAAC,mBAAmB;QACtB,OAAO,SAAS,CAAC,KAAK,CAAI,iBAAO,CAAC,KAAK,EAAK,CAAC,CAAC;IAClD,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAA6B,OAAmB;QACxD,OAAO,IAAI,SAAS,CAAI,OAAO,CAAC,CAAC;IACrC,CAAC;IAED;;OAEG;IACH,YAA4B,OAA4B;QACpD,KAAK,EAAE,CAAC;QADgB,YAAO,GAAP,OAAO,CAAqB;IAExD,CAAC;CACJ;AAzBD,8BAyBC"}

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

@@ -0,0 +1,6 @@
+export * from './ChainableSetter';
+export * from './Notepad';
+export * from './NotepadAdapter';
+export * from './notes';
+export * from './TakeNotes';
+//# sourceMappingURL=index.d.ts.map

package/lib/screenplay/notes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/screenplay/notes/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC"}

package/lib/screenplay/notes/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = 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];
+}));
+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("./ChainableSetter"), exports);
+__exportStar(require("./Notepad"), exports);
+__exportStar(require("./NotepadAdapter"), exports);
+__exportStar(require("./notes"), exports);
+__exportStar(require("./TakeNotes"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/screenplay/notes/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oDAAkC;AAClC,4CAA0B;AAC1B,mDAAiC;AACjC,0CAAwB;AACxB,8CAA4B"}

package/lib/screenplay/notes/notes.d.ts

@@ -0,0 +1,117 @@
+import { NotepadAdapter } from './NotepadAdapter';
+/**
+ * Alias for {@apilink Notepad.notes}.
+ *
+ * **Pro tip:** `notes<T>().get(subject)` returns a {@apilink NotepadAdapter} to make accessing the APIs
+ * of the underlying type easier. Check {@apilink NotepadAdapter} for more examples.
+ *
+ * ## Working with untyped notes
+ *
+ * You can use `notes<T>()` without parameterising it with an [interface](https://www.typescriptlang.org/docs/handbook/interfaces.html)
+ * describing the structure of your notes.
+ *
+ * **Note:** this approach _is not type-safe_ and the type-safe alternative presented below should be used in most cases.
+ *
+ * ```ts
+ * import { actorCalled, Log, notes, TakeNotes } from '@serenity-js/core';
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.usingAnEmptyNotepad())
+ *   .attemptsTo(
+ *     notes().set('my_note', 'some value'),
+ *
+ *     Log.the(notes().get('my_note')),
+ *     // emits "some value"
+ *
+ *     Log.the(notes().get('my_note').toLocaleUpperCase()),
+ *     // emits "SOME VALUE"
+ *   );
+ * ```
+ *
+ * ## Working with typed notes
+ *
+ * The **recommended** way to use `notes<T>()` is to parameterise it
+ * with an [interface](https://www.typescriptlang.org/docs/handbook/interfaces.html)
+ * describing the structure of your notes.
+ *
+ * **Note:** this approach _is type-safe_.
+ *
+ * ```ts
+ * import { actorCalled, Log, notes, TakeNotes } from '@serenity-js/core';
+ *
+ * interface MyNotes {
+ *   username: string;
+ *   token?: string;     // optional value
+ * }
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.using(Notepad.with<MyNotes>({
+ *     username: 'Leonard.McLaud@example.org',
+ *   }))
+ *   .attemptsTo(
+ *     notes<MyNotes>().set('token', 'my-auth-token')
+ *
+ *     Log.the(notes<MyNotes>().get('token').length),
+ *     // emits 13
+ *
+ *     Log.the(notes<MyNotes>().get('username').toLocaleLowerCase()),
+ *     // emits 'leonard.mclaud@example.org'
+ *   )
+ * ```
+ *
+ * ## Checking if a note is present
+ *
+ * ```ts
+ * import { actorCalled, Check, notes, TakeNotes } from '@serenity-js/core'
+ * import { isPresent } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.using(Notepad.empty()))
+ *   .attemptsTo(
+ *     Check.whether(notes().get('token'), isPresent())
+ *      .andIfSo(
+ *        Authenticate.using(notes().get('token')),
+ *      )
+ *      .otherwise(
+ *        SignIn.using('username', 'password'),
+ *      )
+ *    )
+ * ```
+ *
+ * ## Working with complex data structures
+ *
+ * ```ts
+ * import { actorCalled, Log, notes, TakeNotes } from '@serenity-js/core'
+ *
+ * interface MyNotes {
+ *   recordedItems: string[];
+ * }
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.using(Notepad.with<MyNotes>({
+ *     recordedItems: [],
+ *   }))
+ *   .attemptsTo(
+ *      // push 3 items
+ *      notes().get('recordedItems').push('apples'),
+ *      notes().get('recordedItems').push('cucumbers'),
+ *      notes().get('recordedItems').push('bananas'),
+ *
+ *      // use QuestionAdapter to access Array.sort()
+ *      notes().get('recordedItems').sort(),
+ *
+ *      Log.the(notes().get('recordedItems')),
+ *      // emits 'apples', 'bananas', 'cucumbers'
+ *   )
+ * ```
+ *
+ * ## Learn more
+ *
+ * - {@apilink NotepadAdapter}
+ * - {@apilink Notepad.notes}
+ * - {@apilink QuestionAdapter}
+ *
+ * @group Notes
+ */
+export declare function notes<N extends Record<any, any>>(): NotepadAdapter<N>;
+//# sourceMappingURL=notes.d.ts.map

package/lib/screenplay/notes/notes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notes.d.ts","sourceRoot":"","sources":["../../../src/screenplay/notes/notes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiHG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,cAAc,CAAC,CAAC,CAAC,CAErE"}

package/lib/screenplay/notes/notes.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notes = void 0;
+const Notepad_1 = require("./Notepad");
+/**
+ * Alias for {@apilink Notepad.notes}.
+ *
+ * **Pro tip:** `notes<T>().get(subject)` returns a {@apilink NotepadAdapter} to make accessing the APIs
+ * of the underlying type easier. Check {@apilink NotepadAdapter} for more examples.
+ *
+ * ## Working with untyped notes
+ *
+ * You can use `notes<T>()` without parameterising it with an [interface](https://www.typescriptlang.org/docs/handbook/interfaces.html)
+ * describing the structure of your notes.
+ *
+ * **Note:** this approach _is not type-safe_ and the type-safe alternative presented below should be used in most cases.
+ *
+ * ```ts
+ * import { actorCalled, Log, notes, TakeNotes } from '@serenity-js/core';
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.usingAnEmptyNotepad())
+ *   .attemptsTo(
+ *     notes().set('my_note', 'some value'),
+ *
+ *     Log.the(notes().get('my_note')),
+ *     // emits "some value"
+ *
+ *     Log.the(notes().get('my_note').toLocaleUpperCase()),
+ *     // emits "SOME VALUE"
+ *   );
+ * ```
+ *
+ * ## Working with typed notes
+ *
+ * The **recommended** way to use `notes<T>()` is to parameterise it
+ * with an [interface](https://www.typescriptlang.org/docs/handbook/interfaces.html)
+ * describing the structure of your notes.
+ *
+ * **Note:** this approach _is type-safe_.
+ *
+ * ```ts
+ * import { actorCalled, Log, notes, TakeNotes } from '@serenity-js/core';
+ *
+ * interface MyNotes {
+ *   username: string;
+ *   token?: string;     // optional value
+ * }
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.using(Notepad.with<MyNotes>({
+ *     username: 'Leonard.McLaud@example.org',
+ *   }))
+ *   .attemptsTo(
+ *     notes<MyNotes>().set('token', 'my-auth-token')
+ *
+ *     Log.the(notes<MyNotes>().get('token').length),
+ *     // emits 13
+ *
+ *     Log.the(notes<MyNotes>().get('username').toLocaleLowerCase()),
+ *     // emits 'leonard.mclaud@example.org'
+ *   )
+ * ```
+ *
+ * ## Checking if a note is present
+ *
+ * ```ts
+ * import { actorCalled, Check, notes, TakeNotes } from '@serenity-js/core'
+ * import { isPresent } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.using(Notepad.empty()))
+ *   .attemptsTo(
+ *     Check.whether(notes().get('token'), isPresent())
+ *      .andIfSo(
+ *        Authenticate.using(notes().get('token')),
+ *      )
+ *      .otherwise(
+ *        SignIn.using('username', 'password'),
+ *      )
+ *    )
+ * ```
+ *
+ * ## Working with complex data structures
+ *
+ * ```ts
+ * import { actorCalled, Log, notes, TakeNotes } from '@serenity-js/core'
+ *
+ * interface MyNotes {
+ *   recordedItems: string[];
+ * }
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.using(Notepad.with<MyNotes>({
+ *     recordedItems: [],
+ *   }))
+ *   .attemptsTo(
+ *      // push 3 items
+ *      notes().get('recordedItems').push('apples'),
+ *      notes().get('recordedItems').push('cucumbers'),
+ *      notes().get('recordedItems').push('bananas'),
+ *
+ *      // use QuestionAdapter to access Array.sort()
+ *      notes().get('recordedItems').sort(),
+ *
+ *      Log.the(notes().get('recordedItems')),
+ *      // emits 'apples', 'bananas', 'cucumbers'
+ *   )
+ * ```
+ *
+ * ## Learn more
+ *
+ * - {@apilink NotepadAdapter}
+ * - {@apilink Notepad.notes}
+ * - {@apilink QuestionAdapter}
+ *
+ * @group Notes
+ */
+function notes() {
+    return Notepad_1.Notepad.notes();
+}
+exports.notes = notes;
+//# sourceMappingURL=notes.js.map

package/lib/screenplay/notes/notes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notes.js","sourceRoot":"","sources":["../../../src/screenplay/notes/notes.ts"],"names":[],"mappings":";;;AAAA,uCAAoC;AAGpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiHG;AACH,SAAgB,KAAK;IACjB,OAAO,iBAAO,CAAC,KAAK,EAAK,CAAC;AAC9B,CAAC;AAFD,sBAEC"}

package/lib/screenplay/questions/AnswersQuestions.d.ts

@@ -0,0 +1,19 @@
+import { Answerable } from '../Answerable';
+/**
+ * Describes an {@apilink Actor} who can answer a {@apilink Question} about the system under test.
+ *
+ * ## Learn more
+ *
+ * - {@apilink Question}
+ * - {@apilink Actor}
+ *
+ * @group Actors
+ */
+export interface AnswersQuestions {
+    /**
+     * Makes the {@apilink Actor} evaluate an {@apilink Answerable}
+     * and return the value it holds.
+     */
+    answer<T>(answerable: Answerable<T>): Promise<T>;
+}
+//# sourceMappingURL=AnswersQuestions.d.ts.map

package/lib/screenplay/questions/AnswersQuestions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnswersQuestions.d.ts","sourceRoot":"","sources":["../../../src/screenplay/questions/AnswersQuestions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB;IAE7B;;;OAGG;IACH,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACpD"}

package/lib/screenplay/questions/AnswersQuestions.js.map

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