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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ChainableSetter.d.ts","sourceRoot":"","sources":["../../../src/screenplay/notes/ChainableSetter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC;IACvD,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC;CAC7F"}

package/lib/screenplay/notes/ChainableSetter.js

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

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

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

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

@@ -0,0 +1,164 @@
+import { TinyType } from 'tiny-types';
+import { NotepadAdapter } from './NotepadAdapter';
+/**
+ * Stores notes recorded by an {@apilink Actor}.
+ *
+ * See {@apilink TakeNotes} and [notes](/api/core/function/notes) for more usage examples.
+ *
+ * ## Sharing a notepad between actors
+ *
+ * ```ts
+ * import { Actor, Cast, Notepad, TakeNotes } from '@serenity-js/core'
+ *
+ * interface MyNotes {
+ *   auth: {
+ *     username: string;
+ *     password: string;
+ *   }
+ * }
+ *
+ * export class Actors implements Cast {
+ *
+ *   // initialise a shared notepad when the Actors class is initialised
+ *   private readonly sharedNotepad = Notepad.with<MyNotes>({
+ *     auth: {
+ *       username: 'test-user',
+ *       password: 'SuperSecretP@ssword!',
+ *     }
+ *   });
+ *
+ *   prepare(actor: Actor): Actor {
+ *     switch (actor.name) {
+ *       case 'Alice':
+ *       case 'Bob':
+ *         // Alice and Bob will share their notepad
+ *         return actor.whoCan(TakeNotes.using(this.sharedNotepad));
+ *       default:
+ *         // other actors will get their own notepads
+ *         return actor.whoCan(TakeNotes.using(Notepad.empty<AuthCredentials>()));
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ## Learn more
+ *
+ * - {@apilink TakeNotes}
+ * - [notes](/api/core/function/notes)
+ * - {@apilink Cast}
+ *
+ * @group Notes
+ */
+export declare class Notepad<Notes extends Record<any, any>> extends TinyType {
+    private readonly recordedNotes;
+    /**
+     * Instantiates a new empty Notepad.
+     */
+    static empty<N extends Record<any, any>>(): Notepad<N>;
+    /**
+     * Instantiates a new Notepad with an initial state.
+     *
+     * ```ts
+     * import { actorCalled, Notepad, notes, TakeNotes } from '@serenity-js/core'
+     * import { Ensure, equals } from '@serenity-js/assertions'
+     *
+     * interface MyNotes {
+     *   personalDetails: {
+     *     firstName: string;
+     *     lastName: string;
+     *   }
+     * }
+     *
+     * actorCalled('Leonard')
+     *   .whoCan(
+     *     TakeNotes.using(
+     *       Notepad.with<MyNotes>({
+     *         personalDetails: {
+     *           firstName: 'Leonard',
+     *           lastName: 'McLaud',
+     *         }
+     *       })
+     *     )
+     *   )
+     *   .attemptsTo(
+     *     Ensure.that(
+     *       notes<MyNotes>().get('personalDetails').firstName,
+     *       equals('Leonard')
+     *     ),
+     *   )
+     * ```
+     *
+     * @param notes
+     */
+    static with<N extends Record<any, any>>(notes: N): Notepad<N>;
+    /**
+     * Creates a {@apilink QuestionAdapter} that simplifies access to the notes
+     * stored in this notepad. Allows the {@apilink Actor} to record, read, and remove notes.
+     *
+     * #### Learn more
+     * - [notes](/api/core/function/notes)
+     * - {@apilink TakeNotes}
+     * - {@apilink Notepad}
+     */
+    static notes<N extends Record<any, any>>(): NotepadAdapter<N>;
+    /**
+     * Instantiates a {@apilink Notepad} with an initial state.
+     *
+     * @param recordedNotes
+     *  Initial state of the notepad
+     */
+    protected constructor(recordedNotes: Notes);
+    /**
+     * Checks if a note identified by `subject` exists in the notepad.
+     *
+     * @param subject
+     *   A subject (name) that uniquely identifies a given note
+     *
+     * @returns
+     *  `true` if the note exists, `false` otherwise
+     */
+    has<Subject extends keyof Notes>(subject: Subject): boolean;
+    /**
+     * Retrieves a note, identified by `subject`, from the notepad.
+     *
+     * @param subject
+     *   A subject (name) that uniquely identifies a given note
+     *
+     * @returns
+     *  The value of the previously recorded note.
+     *
+     * @throws {@apilink LogicError}
+     *  Throws a {@apilink LogicError} if the note with a given `subject`
+     *  has never been recorded.
+     */
+    get<Subject extends keyof Notes>(subject: Subject): Notes[Subject];
+    /**
+     * Stores a given `value` uniquely identified by `subject` in the notepad.
+     *
+     * @param subject
+     *  A subject (name) that uniquely identifies a given note
+     *
+     * @param value
+     *  The value to record.
+     */
+    set<Subject extends keyof Notes>(subject: Subject, value: Notes[Subject]): Notepad<Notes>;
+    /**
+     * Removes the note identified by `subject` from the notepad.
+     *
+     * @param subject
+     *
+     * @returns
+     *  `true` if the item in the Notepad object existed and has been removed,
+     *  `false` otherwise.
+     */
+    delete<Subject extends keyof Notes>(subject: Subject): boolean;
+    /**
+     * Deletes all the notes stored in this notepad.
+     */
+    clear(): void;
+    /**
+     * Returns the number of notes stored in the notepad.
+     */
+    size(): number;
+}
+//# sourceMappingURL=Notepad.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Notepad.d.ts","sourceRoot":"","sources":["../../../src/screenplay/notes/Notepad.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAItC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,qBAAa,OAAO,CAAC,KAAK,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAAE,SAAQ,QAAQ;IAmE3C,OAAO,CAAC,QAAQ,CAAC,aAAa;IAjEpD;;OAEG;IACH,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC;IAItD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAI7D;;;;;;;;OAQG;IACH,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,cAAc,CAAC,CAAC,CAAC;IAI7D;;;;;OAKG;IACH,SAAS,aAA8B,aAAa,EAAE,KAAK;IAI3D;;;;;;;;OAQG;IACH,GAAG,CAAC,OAAO,SAAS,MAAM,KAAK,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO;IAI3D;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,OAAO,SAAS,MAAM,KAAK,EAAE,OAAO,EAAE,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;IAQlE;;;;;;;;OAQG;IACH,GAAG,CAAC,OAAO,SAAS,MAAM,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC;IAKzF;;;;;;;;OAQG;IACH,MAAM,CAAC,OAAO,SAAS,MAAM,KAAK,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO;IAO9D;;OAEG;IACH,KAAK,IAAI,IAAI;IAQb;;OAEG;IACH,IAAI,IAAI,MAAM;CAGjB"}

package/lib/screenplay/notes/Notepad.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Notepad = void 0;
+const tiny_types_1 = require("tiny-types");
+const errors_1 = require("../../errors");
+const io_1 = require("../../io");
+const NotepadAdapter_1 = require("./NotepadAdapter");
+/**
+ * Stores notes recorded by an {@apilink Actor}.
+ *
+ * See {@apilink TakeNotes} and [notes](/api/core/function/notes) for more usage examples.
+ *
+ * ## Sharing a notepad between actors
+ *
+ * ```ts
+ * import { Actor, Cast, Notepad, TakeNotes } from '@serenity-js/core'
+ *
+ * interface MyNotes {
+ *   auth: {
+ *     username: string;
+ *     password: string;
+ *   }
+ * }
+ *
+ * export class Actors implements Cast {
+ *
+ *   // initialise a shared notepad when the Actors class is initialised
+ *   private readonly sharedNotepad = Notepad.with<MyNotes>({
+ *     auth: {
+ *       username: 'test-user',
+ *       password: 'SuperSecretP@ssword!',
+ *     }
+ *   });
+ *
+ *   prepare(actor: Actor): Actor {
+ *     switch (actor.name) {
+ *       case 'Alice':
+ *       case 'Bob':
+ *         // Alice and Bob will share their notepad
+ *         return actor.whoCan(TakeNotes.using(this.sharedNotepad));
+ *       default:
+ *         // other actors will get their own notepads
+ *         return actor.whoCan(TakeNotes.using(Notepad.empty<AuthCredentials>()));
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ## Learn more
+ *
+ * - {@apilink TakeNotes}
+ * - [notes](/api/core/function/notes)
+ * - {@apilink Cast}
+ *
+ * @group Notes
+ */
+class Notepad extends tiny_types_1.TinyType {
+    /**
+     * Instantiates a new empty Notepad.
+     */
+    static empty() {
+        return new Notepad({});
+    }
+    /**
+     * Instantiates a new Notepad with an initial state.
+     *
+     * ```ts
+     * import { actorCalled, Notepad, notes, TakeNotes } from '@serenity-js/core'
+     * import { Ensure, equals } from '@serenity-js/assertions'
+     *
+     * interface MyNotes {
+     *   personalDetails: {
+     *     firstName: string;
+     *     lastName: string;
+     *   }
+     * }
+     *
+     * actorCalled('Leonard')
+     *   .whoCan(
+     *     TakeNotes.using(
+     *       Notepad.with<MyNotes>({
+     *         personalDetails: {
+     *           firstName: 'Leonard',
+     *           lastName: 'McLaud',
+     *         }
+     *       })
+     *     )
+     *   )
+     *   .attemptsTo(
+     *     Ensure.that(
+     *       notes<MyNotes>().get('personalDetails').firstName,
+     *       equals('Leonard')
+     *     ),
+     *   )
+     * ```
+     *
+     * @param notes
+     */
+    static with(notes) {
+        return new Notepad(notes);
+    }
+    /**
+     * Creates a {@apilink QuestionAdapter} that simplifies access to the notes
+     * stored in this notepad. Allows the {@apilink Actor} to record, read, and remove notes.
+     *
+     * #### Learn more
+     * - [notes](/api/core/function/notes)
+     * - {@apilink TakeNotes}
+     * - {@apilink Notepad}
+     */
+    static notes() {
+        return new NotepadAdapter_1.NotepadAdapter();
+    }
+    /**
+     * Instantiates a {@apilink Notepad} with an initial state.
+     *
+     * @param recordedNotes
+     *  Initial state of the notepad
+     */
+    constructor(recordedNotes) {
+        super();
+        this.recordedNotes = recordedNotes;
+    }
+    /**
+     * Checks if a note identified by `subject` exists in the notepad.
+     *
+     * @param subject
+     *   A subject (name) that uniquely identifies a given note
+     *
+     * @returns
+     *  `true` if the note exists, `false` otherwise
+     */
+    has(subject) {
+        return Object.prototype.hasOwnProperty.call(this.recordedNotes, subject);
+    }
+    /**
+     * Retrieves a note, identified by `subject`, from the notepad.
+     *
+     * @param subject
+     *   A subject (name) that uniquely identifies a given note
+     *
+     * @returns
+     *  The value of the previously recorded note.
+     *
+     * @throws {@apilink LogicError}
+     *  Throws a {@apilink LogicError} if the note with a given `subject`
+     *  has never been recorded.
+     */
+    get(subject) {
+        if (!this.has(subject)) {
+            throw new errors_1.LogicError((0, io_1.d) `Note of ${subject} cannot be retrieved because it's never been recorded`);
+        }
+        return this.recordedNotes[subject];
+    }
+    /**
+     * Stores a given `value` uniquely identified by `subject` in the notepad.
+     *
+     * @param subject
+     *  A subject (name) that uniquely identifies a given note
+     *
+     * @param value
+     *  The value to record.
+     */
+    set(subject, value) {
+        this.recordedNotes[subject] = value;
+        return this;
+    }
+    /**
+     * Removes the note identified by `subject` from the notepad.
+     *
+     * @param subject
+     *
+     * @returns
+     *  `true` if the item in the Notepad object existed and has been removed,
+     *  `false` otherwise.
+     */
+    delete(subject) {
+        if (this.has(subject)) {
+            return delete this.recordedNotes[subject];
+        }
+        return false;
+    }
+    /**
+     * Deletes all the notes stored in this notepad.
+     */
+    clear() {
+        const keys = Object.keys(this.recordedNotes);
+        for (const key of keys) {
+            this.delete(key);
+        }
+    }
+    /**
+     * Returns the number of notes stored in the notepad.
+     */
+    size() {
+        return Object.keys(this.recordedNotes).length;
+    }
+}
+exports.Notepad = Notepad;
+//# sourceMappingURL=Notepad.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Notepad.js","sourceRoot":"","sources":["../../../src/screenplay/notes/Notepad.ts"],"names":[],"mappings":";;;AAAA,2CAAsC;AAEtC,yCAA0C;AAC1C,iCAA6B;AAC7B,qDAAkD;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAa,OAAwC,SAAQ,qBAAQ;IAEjE;;OAEG;IACH,MAAM,CAAC,KAAK;QACR,OAAO,IAAI,OAAO,CAAI,EAAO,CAAC,CAAC;IACnC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,MAAM,CAAC,IAAI,CAA6B,KAAQ;QAC5C,OAAO,IAAI,OAAO,CAAI,KAAK,CAAC,CAAC;IACjC,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,KAAK;QACR,OAAO,IAAI,+BAAc,EAAK,CAAC;IACnC,CAAC;IAED;;;;;OAKG;IACH,YAAuC,aAAoB;QACvD,KAAK,EAAE,CAAC;QAD2B,kBAAa,GAAb,aAAa,CAAO;IAE3D,CAAC;IAED;;;;;;;;OAQG;IACH,GAAG,CAA8B,OAAgB;QAC7C,OAAO,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAC7E,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,GAAG,CAA8B,OAAgB;QAC7C,IAAI,CAAE,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE;YACrB,MAAM,IAAI,mBAAU,CAAC,IAAA,MAAC,EAAA,WAAY,OAAQ,uDAAuD,CAAC,CAAC;SACtG;QAED,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IACvC,CAAC;IAED;;;;;;;;OAQG;IACH,GAAG,CAA8B,OAAgB,EAAE,KAAqB;QACpE,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,KAAK,CAAC;QACpC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAA8B,OAAgB;QAChD,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE;YACnB,OAAO,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;SAC7C;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;IAED;;OAEG;IACH,KAAK;QACD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAE7C,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;YACpB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;SACpB;IACL,CAAC;IAED;;OAEG;IACH,IAAI;QACA,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC;IAClD,CAAC;CACJ;AAxJD,0BAwJC"}

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

@@ -0,0 +1,245 @@
+import { JSONObject } from 'tiny-types';
+import { Answerable } from '../Answerable';
+import { Interaction } from '../Interaction';
+import { QuestionAdapter } from '../Question';
+import { ChainableSetter } from './ChainableSetter';
+/**
+ * Serenity/JS Screenplay Pattern-style adapter for the {@apilink Notepad},
+ * that makes it easier for the {@apilink Actor|actors} to access its APIs.
+ *
+ * See {@apilink TakeNotes}, {@apilink Notepad} and {@apilink notes} for more examples.
+ *
+ * @group Notes
+ */
+export declare class NotepadAdapter<Notes extends Record<any, any>> implements ChainableSetter<Notes> {
+    /**
+     * Checks if a note identified by `subject` exists in the notepad.
+     *
+     * #### Learn more
+     * - {@apilink Notepad.has}
+     *
+     * @param subject
+     *   A subject (name) that uniquely identifies a given note
+     *
+     * @returns
+     *  Question that resolves to `true` if the note exists, `false` otherwise
+     */
+    has<Subject extends keyof Notes>(subject: Subject): QuestionAdapter<boolean>;
+    /**
+     * Retrieves a note, identified by `subject`, from the notepad.
+     *
+     * #### Learn more
+     * - {@apilink Notepad.get}
+     *
+     * @param subject
+     *   A subject (name) that uniquely identifies a given note
+     *
+     * @returns
+     *  The value of the previously recorded note.
+     *
+     * @throws {LogicError}
+     *  Throws a {@apilink LogicError} if the note with a given `subject`
+     *  has never been recorded.
+     */
+    get<Subject extends keyof Notes>(subject: Subject): QuestionAdapter<Notes[Subject]>;
+    /**
+     * Resolves a given `Answerable<value>` and stores it in the notepad,
+     * uniquely identified by its `subject`.
+     *
+     * **Pro tip:** calls to `set` can be chained and result in an accumulation
+     * of values to be recorded in the {@apilink Notepad}.
+     * Those values are resolved and recorded when the {@apilink Interaction}
+     * returned by this method is performed by an {@apilink Actor}.
+     *
+     * If a note identified by a given `subject` is set multiple times,
+     * the last call wins.
+     *
+     * ```ts
+     *  import { actorCalled, notes, TakeNotes } from '@serenity-js/core'
+     *  import { Ensure, equals } from '@serenity-js/assertions'
+     *
+     *  interface MyNotes {
+     *      stringNote: string;
+     *      numberNote: number;
+     *  }
+     *
+     * await actorCalled('Alice')
+     *   .whoCan(TakeNotes.usingAnEmptyNotepad<MyNotes>());
+     *   .attemptsTo(
+     *
+     *     notes<MyNotes>()
+     *       .set('stringNote', 'example')
+     *       .set('numberNote', Promise.resolve(42))
+     *       .set('stringNote', 'another example'),
+     *
+     *     Ensure.equal(notes().toJSON(), {
+     *       firstNote: 'another example',
+     *       secondNote: 42,
+     *     })
+     * )
+     * ```
+     *
+     * #### Learn more
+     * - {@apilink Notepad.set}
+     *
+     * @param subject
+     *   A subject (name) that uniquely identifies a given note
+     *
+     * @param value
+     *  The value to record
+     */
+    set<Subject extends keyof Notes>(subject: Subject, value: Answerable<Notes[Subject]>): ChainableSetter<Notes> & Interaction;
+    /**
+     * Removes the note identified by `subject` from the notepad.
+     *
+     * #### Using as an `Interaction`
+     *
+     * ```ts
+     * import { actorCalled, Check, Log, notes } from '@serenity-js/core'
+     * import { isPresent } from '@serenity-js/assertions'
+     *
+     * interface MyNotes {
+     *   myNote: string;
+     * }
+     *
+     * await actorCalled('Alice')
+     *   .whoCan(TakeNotes.using(Notepad.empty<MyNotes>()))
+     *   .attemptsTo(
+     *     notes<MyNotes>().set('myNote', 'example value'),
+     *
+     *     notes<MyNotes>().delete('myNote'),
+     *
+     *     Check.whether(notes<MyNotes>().get('myNote'), isPresent())
+     *       .andIfSo(
+     *         Log.the('myNote is present'),
+     *       )
+     *       .otherwise(
+     *         Log.the('myNote was deleted'),
+     *       )
+     *   )
+     *   // logs: myNote was deleted
+     * ```
+     *
+     * #### Using as a `Question`
+     *
+     * ```ts
+     * import { actorCalled, Check, Log, notes } from '@serenity-js/core'
+     * import { isTrue } from '@serenity-js/assertions'
+     *
+     * interface MyNotes {
+     *   myNote: string;
+     * }
+     *
+     * await actorCalled('Alice')
+     *   .whoCan(TakeNotes.using(Notepad.empty<MyNotes>()))
+     *   .attemptsTo(
+     *     notes<MyNotes>().set('myNote', 'example value'),
+     *
+     *     Check.whether(notes<MyNotes>().delete('myNote'), isTrue())
+     *       .andIfSo(
+     *         Log.the('myNote was deleted'),
+     *       )
+     *       .otherwise(
+     *         Log.the('myNote could not be deleted because it was not set'),
+     *       )
+     *   )
+     *   // logs: myNote was deleted
+     * ```
+     *
+     * #### Learn more
+     * - {@apilink Notepad.delete}
+     *
+     * @param subject
+     *
+     * @returns
+     *  When used as a `Question`, resolves to `true` if the item in the Notepad object existed and has been removed,
+     *  `false` otherwise.
+     */
+    delete<Subject extends keyof Notes>(subject: Subject): QuestionAdapter<boolean>;
+    /**
+     * Deletes all the notes stored in this notepad.
+     *
+     * ```ts
+     * import { actorCalled, notes } from '@serenity-js/core'
+     * import { isTrue } from '@serenity-js/assertions'
+     *
+     * interface MyNotes {
+     *   myNote: string;
+     * }
+     *
+     * await actorCalled('Alice')
+     *   .whoCan(TakeNotes.using(Notepad.empty<MyNotes>()))
+     *   .attemptsTo(
+     *     notes<MyNotes>().set('myNote', 'example value'),
+     *     Log.the(notes<MyNotes>().size()),   // emits 1
+     *     notes<MyNotes>().clear(),
+     *     Log.the(notes<MyNotes>().size()),   // emits 0
+     *   )
+     * ```
+     *
+     * #### Learn more
+     * - {@apilink Notepad.clear}
+     */
+    clear(): Interaction;
+    /**
+     * Returns the number of notes stored in the notepad.
+     *
+     * ```ts
+     * import { actorCalled, notes } from '@serenity-js/core'
+     * import { isTrue } from '@serenity-js/assertions'
+     *
+     * interface MyNotes {
+     *   myNote: string;
+     * }
+     *
+     * await actorCalled('Alice')
+     *   .whoCan(TakeNotes.using(Notepad.empty<MyNotes>()))
+     *   .attemptsTo(
+     *     Log.the(notes<MyNotes>().size()),   // emits 0
+     *     notes<MyNotes>().set('myNote', 'example value'),
+     *     Log.the(notes<MyNotes>().size()),   // emits 1
+     *   )
+     * ```
+     *
+     * #### Learn more
+     * - {@apilink Notepad.size}
+     */
+    size(): QuestionAdapter<number>;
+    /**
+     * Produces a {@apilink QuestionAdapter} that resolves to a `JSONObject`
+     * representing the resolved notes stored in the notepad.
+     *
+     * Note that serialisation to JSON will simplify some data types that might not be serialisable by default,
+     * but are commonly used in data structures representing actor's notes.
+     * For example a {@apilink Map} will be serialised as a regular JSON object, a {@apilink Set} will be serialised as {@apilink Array}.
+     *
+     * Additionally, notepad assumes that the data structure you use it with does not contain cyclic references.
+     *
+     * To learn more about the serialisation mechanism used by the notepad, please refer to [TinyTypes documentation](https://jan-molak.github.io/tiny-types/).
+     *
+     * ```ts
+     * import { actorCalled, notes } from '@serenity-js/core'
+     *
+     * await actorCalled('Alice')
+     *   .whoCan(TakeNotes.using(Notepad.with({
+     *     aSet: new Set(['apples', 'bananas', 'cucumbers']),
+     *     aPromisedValue: Promise.resolve(42),
+     *     aString: 'example'
+     *   })))
+     *   .attemptsTo(
+     *     Log.the(notes().toJSON()),
+     *   )
+     *   // emits: {
+     *   //    aSet: ['apples', 'bananas', 'cucumbers']
+     *   //    aPromisedValue: 42,
+     *   //    aString: 'example',
+     *   // }
+     * ```
+     */
+    toJSON(): QuestionAdapter<JSONObject>;
+    /**
+     * @inheritDoc
+     */
+    toString(): string;
+}
+//# sourceMappingURL=NotepadAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NotepadAdapter.d.ts","sourceRoot":"","sources":["../../../src/screenplay/notes/NotepadAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAIxC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAY,eAAe,EAAE,MAAM,aAAa,CAAC;AAExD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGpD;;;;;;;GAOG;AACH,qBAAa,cAAc,CAAC,KAAK,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAAE,YAAW,eAAe,CAAC,KAAK,CAAC;IAEzF;;;;;;;;;;;OAWG;IACH,GAAG,CAAC,OAAO,SAAS,MAAM,KAAK,EAAE,OAAO,EAAE,OAAO,GAAG,eAAe,CAAC,OAAO,CAAC;IAM5E;;;;;;;;;;;;;;;OAeG;IACH,GAAG,CAAC,OAAO,SAAS,MAAM,KAAK,EAAE,OAAO,EAAE,OAAO,GAAG,eAAe,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAMnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,GAAG,CAAC,OAAO,SAAS,MAAM,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,eAAe,CAAC,KAAK,CAAC,GAAG,WAAW;IAI3H;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiEG;IACH,MAAM,CAAC,OAAO,SAAS,MAAM,KAAK,EAAE,OAAO,EAAE,OAAO,GAAG,eAAe,CAAC,OAAO,CAAC;IAM/E;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,KAAK,IAAI,WAAW;IAMpB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,IAAI,IAAI,eAAe,CAAC,MAAM,CAAC;IAM/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,MAAM,IAAI,eAAe,CAAC,UAAU,CAAC;IAMrC;;OAEG;IACH,QAAQ,IAAI,MAAM;CAGrB"}