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

package/src/screenplay/notes/NotepadAdapter.ts

@@ -0,0 +1,317 @@
+import { JSONObject } from 'tiny-types';
+
+import { commaSeparated } from '../../io';
+import { UsesAbilities } from '../abilities';
+import { Answerable } from '../Answerable';
+import { Interaction } from '../Interaction';
+import { Question, QuestionAdapter } from '../Question';
+import { AnswersQuestions } from '../questions';
+import { ChainableSetter } from './ChainableSetter';
+import { TakeNotes } from './TakeNotes';
+
+/**
+ * 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 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> {
+        return Question.about(`a note of ${ String(subject) } exists`, actor => {
+            return TakeNotes.as(actor).notepad.has(subject);
+        });
+    }
+
+    /**
+     * 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]> {
+        return Question.about(`a note of ${ String(subject) }`, actor => {
+            return TakeNotes.as(actor).notepad.get(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 {
+        return new ChainableNoteSetter<Notes>({ [subject]: value } as NotesToSet<Notes>);
+    }
+
+    /**
+     * 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> {
+        return Question.about(`#actor deletes a note of ${ String(subject) }`, actor => {
+            return TakeNotes.as(actor).notepad.delete(subject);
+        });
+    }
+
+    /**
+     * 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 {
+        return Interaction.where('#actor clears their notepad', actor => {
+            return TakeNotes.as(actor).notepad.clear();
+        });
+    }
+
+    /**
+     * 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> {
+        return Question.about('number of notes', async actor => {
+            return TakeNotes.as(actor).notepad.size();
+        });
+    }
+
+    /**
+     * 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> {
+        return Question.about('notepad serialised to JSON', async actor => {
+            return TakeNotes.as(actor).notepad.toJSON() as JSONObject;
+        });
+    }
+
+    /**
+     * @inheritDoc
+     */
+    toString(): string {
+        return 'notes';
+    }
+}
+
+type NotesToSet<Notes extends Record<any, any>> = {
+    [Subject in keyof Notes]?: Answerable<Notes[Subject]>
+}
+
+/**
+ * @package
+ */
+class ChainableNoteSetter<Notes extends Record<any, any>> extends Interaction implements ChainableSetter<Notes> {
+
+    constructor(private readonly notes: NotesToSet<Notes>) {
+        super(`#actor takes note of ${ commaSeparated(Object.keys(notes)) }`);
+    }
+
+    set<K extends keyof Notes>(subject: K, value: Answerable<Notes[K]>): ChainableSetter<Notes> & Interaction {
+        return new ChainableNoteSetter({
+            ...this.notes,
+            [subject]: value,
+        } as NotesToSet<Notes>)
+    }
+
+    async performAs(actor: AnswersQuestions & UsesAbilities): Promise<void> {
+
+        const notepad = TakeNotes.as(actor).notepad;
+
+        for (const [ subject, value ] of Object.entries(this.notes)) {
+            const answer = await actor.answer(value);
+            notepad.set(subject, answer);
+        }
+    }
+}

package/src/screenplay/notes/TakeNotes.ts

@@ -0,0 +1,257 @@
+import { Ability } from '../abilities';
+import { Notepad } from './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
+ */
+export class TakeNotes<Notes_Type extends Record<any, any>> extends Ability {
+
+    /**
+     * Initialises an {@apilink Ability} to {@apilink TakeNotes} with {@apilink Notepad.empty}.
+     */
+    static usingAnEmptyNotepad<N extends Record<any, any>>(): TakeNotes<N> {
+        return TakeNotes.using<N>(Notepad.empty<N>());
+    }
+
+    /**
+     * Initialises an {@apilink Ability} to {@apilink TakeNotes} using
+     * a {@apilink Notepad.with} some initial state.
+     *
+     * @param notepad
+     */
+    static using<N extends Record<any, any>>(notepad: Notepad<N>): TakeNotes<N> {
+        return new TakeNotes<N>(notepad);
+    }
+
+    /**
+     * @param notepad
+     */
+    constructor(public readonly notepad: Notepad<Notes_Type>) {
+        super();
+    }
+}

package/src/screenplay/notes/index.ts

@@ -0,0 +1,5 @@
+export * from './ChainableSetter';
+export * from './Notepad';
+export * from './NotepadAdapter';
+export * from './notes';
+export * from './TakeNotes';

package/src/screenplay/notes/notes.ts

@@ -0,0 +1,120 @@
+import { Notepad } from './Notepad';
+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 function notes<N extends Record<any, any>>(): NotepadAdapter<N> {
+    return Notepad.notes<N>();
+}