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

package/src/screenplay/questions/Unanswered.ts

@@ -0,0 +1,27 @@
+import { JSONValue, TinyType } from 'tiny-types';
+import * as util from 'util';   // eslint-disable-line unicorn/import-style
+
+/**
+ * A placeholder value signifying that a {@apilink Question}
+ * has not been answered by an {@apilink Actor} when producing an {@apilink ExpectationOutcome}.
+ * This happens when Serenity/JS decides that answering a given question
+ * won't affect the outcome.
+ *
+ * For example, making the actor answer questions about the expected value
+ * and the actual value of each list item is unnecessary if we already know that the list itself is empty.
+ *
+ * @group Questions
+ */
+export class Unanswered extends TinyType {
+    [util.inspect.custom](): string {
+        return `<<unanswered>>`;
+    }
+
+    toString(): string {
+        return 'unanswered';
+    }
+
+    toJSON(): JSONValue {
+        return undefined;   // eslint-disable-line unicorn/no-useless-undefined
+    }
+}

package/src/screenplay/questions/expectations/ExpectationDetails.ts

@@ -0,0 +1,64 @@
+import { ensure, isArray, isDefined, JSONObject, JSONValue, TinyType } from 'tiny-types';
+
+import { inspected, typeOf } from '../../../io';
+import { Name } from '../../../model';
+import { Unanswered } from '../Unanswered';
+
+/**
+ * Used with {@apilink ExpectationOutcome} to describe an {@apilink Expectation} and the arguments it's been executed with.
+ *
+ * @group Expectations
+ */
+export class ExpectationDetails extends TinyType {
+
+    static of(functionName: string, ...functionArguments: Array<JSONValue | ExpectationDetails | Unanswered>): ExpectationDetails {
+        return new ExpectationDetails(new Name(functionName), functionArguments);
+    }
+
+    static fromJSON(o: JSONObject): ExpectationDetails {
+        return new ExpectationDetails(
+            Name.fromJSON(o.name as string),
+            (o.args as Array<{ type: string, value: JSONValue }>).map(arg => {
+                if (arg.type === Unanswered.name) {
+                    return new Unanswered();
+                }
+                if (arg.type === ExpectationDetails.name) {
+                    return ExpectationDetails.fromJSON(arg.value as JSONObject)
+                }
+                // must be a JSONValue then
+                return arg.value;
+            }),
+        );
+    }
+
+    protected constructor(
+        public readonly name: Name,
+        public readonly args: Array<JSONValue | ExpectationDetails | Unanswered>,
+    ) {
+        super();
+        ensure('name', name, isDefined());
+        ensure('args', args, isArray());
+    }
+
+    toString(): string {
+        const argumentValues = this.args.map(arg =>
+            arg instanceof ExpectationDetails
+                ? arg.toString()
+                : inspected(arg, { compact: true })
+        ).join(', ');
+
+        return `${ this.name.value }(${ argumentValues })`;
+    }
+
+    toJSON(): { name: string, args: Array<{ type: string, value: JSONValue }> } {
+        return {
+            name: this.name.value,
+            args: this.args.map(arg => ({
+                type: typeOf(arg),
+                value: arg['toJSON']
+                    ? (arg as any).toJSON()
+                    : arg,
+            })),
+        }
+    }
+}

package/src/screenplay/questions/expectations/ExpectationMet.ts

@@ -1,3 +1,8 @@
 import { ExpectationOutcome } from './ExpectationOutcome';
 
-export class ExpectationMet<Expected, Actual> extends ExpectationOutcome<Expected, Actual> {}
+/**
+ * Indicates that an {@apilink Expectation} was met.
+ *
+ * @group Expectations
+ */
+export class ExpectationMet extends ExpectationOutcome {}

package/src/screenplay/questions/expectations/ExpectationNotMet.ts

@@ -1,3 +1,8 @@
 import { ExpectationOutcome } from './ExpectationOutcome';
 
-export class ExpectationNotMet<Expected, Actual> extends ExpectationOutcome<Expected, Actual> {}
+/**
+ * Indicates that an {@apilink Expectation} was not met.
+ *
+ * @group Expectations
+ */
+export class ExpectationNotMet extends ExpectationOutcome {}

package/src/screenplay/questions/expectations/ExpectationOutcome.ts

@@ -1,10 +1,19 @@
 import { TinyType } from 'tiny-types';
 
-export class ExpectationOutcome<Expected, Actual> extends TinyType {
+import { ExpectationDetails } from './ExpectationDetails';
+
+/**
+ * An outcome of an {@apilink Expectation},
+ * which could be either {@apilink ExpectationMet|met} or {@apilink ExpectationNotMet|not met}.
+ *
+ * @group Expectations
+ */
+export class ExpectationOutcome extends TinyType {
     constructor(
         public readonly message: string,
-        public readonly expected: Expected,
-        public readonly actual: Actual,
+        public readonly expectation: ExpectationDetails,
+        public readonly expected: unknown,
+        public readonly actual: unknown,
     ) {
         super();
     }

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

@@ -1,3 +1,4 @@
+export * from './ExpectationDetails';
 export * from './ExpectationMet';
 export * from './ExpectationNotMet';
 export * from './ExpectationOutcome';

package/src/screenplay/questions/index.ts

@@ -1,7 +1,8 @@
+export * from './AnswersQuestions';
 export * from './Check';
 export * from './Expectation';
 export * from './expectations';
 export * from './List';
 export * from './MetaQuestion';
-export * from './Note';
 export * from './q';
+export * from './Unanswered';

package/src/screenplay/questions/q.ts

@@ -1,39 +1,69 @@
 import { Answerable } from '../Answerable';
-import { Question } from '../Question';
+import { Question, QuestionAdapter } from '../Question';
 
 /**
- * @desc
- *  A Screenplay-flavour of a [tagged template literal](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#Tagged_templates),
- *  `q` is a tag function capable of resolving any `Answerable<string | number>` you parametrise it with (i.e. a {@link Question}).
+ * A Serenity/JS Screenplay Pattern-flavour
+ * of a [tagged template literal](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#Tagged_templates),
+ * `q` is a tag function capable of resolving any `Answerable<string>` or `Answerable<number>`
+ * you parametrise it with, and returning a `QuestionAdapter<string>`.
  *
- * @example <caption>Interpolating `Questions`</caption>
- *  import { q, actorCalled } from '@serenity-js/core';
- *  import { Send, DeleteRequest } from '@serenity-js/rest';
+ * Use `q` to concatenate `string` and `number` values returned from synchronous an asynchronous sources.
  *
- *  actorCalled('Alice').attemptsTo(
- *      Send.a(DeleteRequest.to(
- *          q `/articles/${ Text.of(Article.id()) }`
- *      ))
- *  )
+ * ## Interpolating questions
  *
- * @example <caption>Using a custom description</caption>
- *  import { q, actorCalled } from '@serenity-js/core';
- *  import { Send, DeleteRequest } from '@serenity-js/rest';
+ * ```ts
+ * import { q, actorCalled } from '@serenity-js/core'
+ * import { Send, DeleteRequest } from '@serenity-js/rest'
+ * import { Text } from '@serenity-js/web'
  *
- *  actorCalled('Alice').attemptsTo(
- *      Send.a(DeleteRequest.to(
- *          q `/articles/${ Text.of(Article.id()) }`.describedAs('/articles/:id')
- *      ))
- *  )
+ * await actorCalled('Alice').attemptsTo(
+ *   Send.a(DeleteRequest.to(
+ *     q `/articles/${ Text.of(Article.id()) }`
+ *   ))
+ * )
+ * ```
  *
- * @param {TemplateStringsArray} templates
- * @param {Array<Answerable<string | number>>} parameters
+ * ## Using a custom description
  *
- * @returns {Question<Promise<string>>}
+ * ```ts
+ * import { q, actorCalled } from '@serenity-js/core'
+ * import { Send, DeleteRequest } from '@serenity-js/rest'
  *
- * @see {@link Question}
+ * await actorCalled('Alice').attemptsTo(
+ *   Send.a(DeleteRequest.to(
+ *     q `/articles/${ Text.of(Article.id()) }`.describedAs('/articles/:id')
+ *   ))
+ * )
+ * ```
+ *
+ * ## Transforming the interpolated string
+ *
+ * The mechanism presented below relies on {@apilink QuestionAdapter}.
+ *
+ * ```ts
+ * import { q, actorCalled } from '@serenity-js/core'
+ * import { Send, DeleteRequest } from '@serenity-js/rest'
+ *
+ * await actorCalled('Alice').attemptsTo(
+ *   Send.a(DeleteRequest.to(
+ *     q `/articles/${ Text.of(Article.id()) }`.toLocaleLowerCase()
+ *   ))
+ * )
+ * ```
+ *
+ * ## Learn more
+ *
+ * - {@apilink Answerable}
+ * - {@apilink Question}
+ * - {@apilink Question.describedAs}
+ * - {@apilink QuestionAdapter}
+ *
+ * @group Questions
+ *
+ * @param templates
+ * @param parameters
  */
-export function q(templates: TemplateStringsArray, ...parameters: Array<Answerable<string | number>>): Question<Promise<string>> {
+export function q(templates: TemplateStringsArray, ...parameters: Array<Answerable<string | number>>): QuestionAdapter<string> {
     return Question.about(templates.join('{}'), actor =>
         Promise.all(parameters.map(parameter => actor.answer(parameter)))
             .then(answers =>

package/src/screenplay/time/abilities/ScheduleWork.ts

@@ -0,0 +1,52 @@
+import { Ability, Discardable, Initialisable } from '../../abilities';
+import { Clock, DelayedCallback, Duration, RepeatUntilLimits, Scheduler } from '../models';
+
+/**
+ * An {@apilink Ability} that enables an {@apilink Actor} to schedule a callback function
+ * to be executed with a delay, or until some condition is met.
+ *
+ * Used internally by the {@apilink Interaction|interaction} to {@apilink Wait}.
+ *
+ * @experimental
+ *
+ * @group Time
+ */
+export class ScheduleWork extends Ability implements Initialisable, Discardable {
+
+    private readonly scheduler: Scheduler;
+
+    constructor(clock: Clock, interactionTimeout: Duration) {
+        super();
+        this.scheduler = new Scheduler(clock, interactionTimeout);
+    }
+
+    initialise(): void {
+        this.scheduler.start();
+    }
+
+    isInitialised(): boolean {
+        return this.scheduler.isRunning();
+    }
+
+    /**
+     * @param callback
+     * @param limits
+     */
+    repeatUntil<Result>(
+        callback: DelayedCallback<Result>,
+        limits?: RepeatUntilLimits<Result>,
+    ): Promise<Result> {
+        return this.scheduler.repeatUntil(callback, limits);
+    }
+
+    waitFor(delay: Duration): Promise<void> {
+        this.scheduler.start();
+        return this.scheduler.after(delay, () => {
+            // do nothing
+        })
+    }
+
+    discard(): void {
+        this.scheduler.stop();
+    }
+}

package/src/screenplay/time/abilities/index.ts

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

package/src/screenplay/time/activities/Wait.ts

@@ -0,0 +1,294 @@
+import { ensure, isGreaterThanOrEqualTo, isInRange } from 'tiny-types';
+
+import { AssertionError, ListItemNotFoundError, RaiseErrors, TimeoutExpiredError } from '../../../errors';
+import { d } from '../../../io';
+import { UsesAbilities } from '../../abilities';
+import { Answerable } from '../../Answerable';
+import { Interaction } from '../../Interaction';
+import { AnswersQuestions, Expectation, ExpectationMet, ExpectationOutcome } from '../../questions';
+import { ScheduleWork } from '../abilities';
+import { Duration } from '../models';
+
+/**
+ * `Wait` is a synchronisation statement that instructs the {@apilink Actor|actor}
+ * to wait before proceeding with their next {@apilink Activity|activity},
+ * either for a set {@apilink Duration|duration}, or until a given {@apilink Expectation|expectation} is met.
+ *
+ * You can configure the timeout of the interaction to {@apilink Wait.until}:
+ * - globally, using {@apilink SerenityConfig.interactionTimeout}
+ * - locally, on a per-interaction basis using {@apilink Wait.upTo}
+ *
+ * :::tip Portable waiting
+ * Serenity/JS implements `Wait` from scratch, so that the behaviour is consistent no matter the integration tool you use (Playwright, WebdriverIO, Selenium, etc.)
+ * or the type of testing you do (Web, REST API, component testing, etc.)
+ * :::
+ *
+ * ## Wait with Web-based tests
+ *
+ * ### Example widget
+ *
+ * ```html
+ * <!--
+ *     After about 1 second, the text will change from 'Loading...' to 'Ready!'
+ * -->
+ * <h1 id="status">Loading...</h1>
+ * <script>
+ *     (function () {
+ *         setTimeout(function () {
+ *             document.getElementById('status').textContent = 'Ready!'
+ *         }, 1000);
+ *     })();
+ * </script>
+ * ```
+ *
+ * ### Lean Page Object describing the widget
+ *
+ * ```ts
+ * import { By, PageElement, Text } from '@serenity-js/web'
+ *
+ * class App {
+ *   static status = () =>
+ *      Text.of(PageElement.located(By.id('status'))
+ *          .describedAs('status widget'))
+ *  }
+ * ```
+ *
+ * ### Waiting for a set duration
+ *
+ * ```ts
+ * import { actorCalled, Duration, Wait } from '@serenity-js/core'
+ * import { BrowseTheWebWithPlaywright } from '@serenity-js/playwright'
+ * import { Ensure, equals } from '@serenity-js/assertions'
+ * import { Browser, chromium } from 'playwright'
+ *
+ * const browser = await chromium.launch({ headless: true })
+ *
+ * await actorCalled('Inês')
+ *   .whoCan(BrowseTheWebWithPlaywright.using(browser))
+ *   .attemptsTo(
+ *       Wait.for(Duration.ofMilliseconds(1_500)),
+ *       Ensure.that(App.status(), equals('Ready!')),
+ *   );
+ * ```
+ *
+ * **Please note** that while the above implementation works,
+ * this approach is inefficient because at best
+ * the actor might wait too long and at worst the test
+ * might become "flaky" if any external interference
+ * (like network glitches, animations taking a bit too long etc.)
+ * makes the actor wait not long enough.
+ *
+ * ### Waiting until a condition is met
+ *
+ * ```ts
+ * import { actorCalled, Wait } from '@serenity-js/core'
+ * import { BrowseTheWebWithPlaywright } from '@serenity-js/playwright'
+ * import { equals } from '@serenity-js/assertions'
+ * import { Browser, chromium } from 'playwright'
+ *
+ * const browser = await chromium.launch({ headless: true })
+ *
+ * await actorCalled('Wendy')
+ *     .whoCan(BrowseTheWebWithPlaywright.using(browser))
+ *     .attemptsTo(
+ *         Wait.until(App.status(), equals('Ready!')),
+ *         // app is ready, proceed with the scenario
+ *     );
+ * ```
+ *
+ * `Wait.until` makes the {@apilink Actor} keep asking the {@apilink Question},
+ * in this case `Text.of(App.status)`, until the answer meets
+ * the expectation, or a timeout expires (default: 5s).
+ *
+ * **Please note** that both Ensure and Wait can be used with
+ * the same expectations, like `equals` or `includes`.
+ *
+ * ### Changing the default timeout
+ *
+ * ```ts
+ *  import { actorCalled, Duration, Wait } from '@serenity-js/core';
+ *  import { BrowseTheWebWithPlaywright } from '@serenity-js/playwright';
+ *  import { equals } from '@serenity-js/assertions';
+ *  import { Browser, chromium } from 'playwright';
+ *
+ *  const browser: Browser = await chromium.launch({ headless: true });
+ *
+ *  await actorCalled('Polly')
+ *      .whoCan(BrowseTheWebWithPlaywright.using(browser))
+ *      .attemptsTo(
+ *          Wait.upTo(Duration.ofSeconds(3))
+ *              .until(App.status(), equals('Ready!')),
+ *          // app is ready, proceed with the scenario
+ *      );
+ * ```
+ *
+ * ## Learn more
+ * - {@apilink SerenityConfig.interactionTimeout}
+ * - {@apilink Duration}
+ * - {@apilink Expectation}
+ *
+ * @group Time
+ */
+export class Wait {
+
+    /**
+     * Minimum timeout that can be used with {@apilink Wait.until},
+     * defaults to 250 milliseconds,
+     */
+    static readonly minimumTimeout = Duration.ofMilliseconds(250);
+
+    /**
+     * The amount of time {@apilink Wait.until} should wait between condition checks,
+     * defaults to 500ms.
+     *
+     * Use {@apilink WaitUntil.pollingEvery} to override it for a given interaction.
+     *
+     * @type {Duration}
+     */
+    static readonly defaultPollingInterval = Duration.ofMilliseconds(500);
+
+    /**
+     * Minimum polling interval of 50ms between condition checks, used with {@apilink Wait.until}.
+     */
+    static readonly minimumPollingInterval = Duration.ofMilliseconds(50);
+
+    /**
+     * Instantiates a version of this {@apilink Interaction}
+     * configured to wait for a set duration.
+     *
+     * @param duration
+     *  A set duration the {@apilink Actor} should wait for before proceeding.
+     */
+    static for(duration: Answerable<Duration>): Interaction {
+        return new WaitFor(duration);
+    }
+
+    /**
+     * Instantiates a version of this {@apilink Interaction}
+     * configured to wait until the answer to the question `actual` meets the `expectation`,
+     * or the `timeout` expires.
+     *
+     * @param timeout
+     *  Custom timeout to override {@apilink SerenityConfig.interactionTimeout}
+     */
+    static upTo(timeout: Duration): { until: <Actual>(actual: Answerable<Actual>, expectation: Expectation<Actual>) => WaitUntil<Actual> } {
+        return {
+            until: <Actual>(actual: Answerable<Actual>, expectation: Expectation<Actual>): WaitUntil<Actual> =>
+                new WaitUntil(actual, expectation, Wait.defaultPollingInterval.isLessThan(timeout) ? Wait.defaultPollingInterval : timeout, timeout),
+        };
+    }
+
+    /**
+     * Instantiates a version of this {@apilink Interaction} configured to
+     * poll every {@apilink Wait.defaultPollingInterval} for the result of the provided
+     * question (`actual`) until it meets the `expectation`,
+     * or the timeout expires.
+     *
+     * @param actual
+     *  An {@apilink Answerable} that the {@apilink Actor} will keep answering
+     *  until the answer meets the {@apilink Expectation} provided, or the timeout expires.
+     *
+     * @param expectation
+     *  An {@apilink Expectation} to be met before proceeding
+     */
+    static until<Actual>(actual: Answerable<Actual>, expectation: Expectation<Actual>): WaitUntil<Actual> {
+        return new WaitUntil(actual, expectation, Wait.defaultPollingInterval);
+    }
+}
+
+/**
+ * @package
+ */
+class WaitFor extends Interaction {
+    constructor(private readonly duration: Answerable<Duration>) {
+        super(d`#actor waits for ${ duration }`);
+    }
+
+    async performAs(actor: UsesAbilities & AnswersQuestions): Promise<void> {
+        const duration = await actor.answer(this.duration);
+
+        return ScheduleWork.as(actor).waitFor(duration);
+    }
+}
+
+/**
+ * Synchronisation statement that instructs the {@apilink Actor} to wait before proceeding until a given {@apilink Expectation} is met.
+ *
+ * :::tip
+ * To instantiate {@apilink Interaction|interaction} to {@apilink WaitUntil}, use the factory method {@apilink Wait.until}.
+ * :::
+ *
+ * ## Learn more
+ * * {@apilink Wait.until}
+ *
+ * @group Time
+ */
+export class WaitUntil<Actual> extends Interaction {
+    constructor(
+        private readonly actual: Answerable<Actual>,
+        private readonly expectation: Expectation<Actual>,
+        private readonly pollingInterval: Duration,
+        private readonly timeout?: Duration,
+    ) {
+        super(d`#actor waits until ${ actual } does ${ expectation }`);
+
+        if (timeout) {
+            ensure('Timeout', timeout.inMilliseconds(), isGreaterThanOrEqualTo(Wait.minimumTimeout.inMilliseconds()));
+            ensure('Polling interval', pollingInterval.inMilliseconds(), isInRange(Wait.minimumPollingInterval.inMilliseconds(), timeout.inMilliseconds()));
+        }
+
+        ensure('Polling interval', pollingInterval.inMilliseconds(), isGreaterThanOrEqualTo(Wait.minimumPollingInterval.inMilliseconds()));
+    }
+
+    /**
+     * Configure how frequently the {@apilink Actor} should check if the answer meets the expectation.
+     *
+     * Note that the polling interval defines the delay between subsequent attempts
+     * to evaluate the expected value, and doesn't include the amount of time
+     * it take the actor to evaluate the value itself.
+     *
+     * @param interval
+     */
+    pollingEvery(interval: Duration): Interaction {
+        return new WaitUntil(this.actual, this.expectation, interval, this.timeout);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    async performAs(actor: UsesAbilities & AnswersQuestions): Promise<void> {
+
+        await ScheduleWork.as(actor).repeatUntil<ExpectationOutcome>(
+            () => actor.answer(this.expectation.isMetFor(this.actual)),
+            {
+                exitCondition: outcome =>
+                    outcome instanceof ExpectationMet,
+
+                delayBetweenInvocations: (invocation) => invocation === 0
+                    ? Duration.ofMilliseconds(0)
+                    : this.pollingInterval,
+
+                timeout: this.timeout,
+
+                errorHandler: (error, outcome) => {
+                    if (error instanceof ListItemNotFoundError) {
+                        return; // ignore, lists might get populated later
+                    }
+
+                    if (error instanceof TimeoutExpiredError) {
+
+                        throw RaiseErrors.as(actor).create(AssertionError, {
+                            message: error.message + d` while waiting for ${ this.actual } to ${ this.expectation }`,
+                            expectation: outcome?.expectation,
+                            diff: outcome && { expected: outcome?.expected, actual: outcome?.actual },
+                            location: this.instantiationLocation(),
+                            cause: error,
+                        });
+                    }
+
+                    throw error;
+                }
+            }
+        );
+    }
+}

package/src/screenplay/time/activities/index.ts

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

package/src/screenplay/time/index.ts

@@ -0,0 +1,3 @@
+export * from './abilities';
+export * from './activities';
+export * from './models';

package/src/screenplay/time/models/Clock.ts

@@ -0,0 +1,28 @@
+import { Timestamp } from './Timestamp';
+
+/**
+ * A {@apilink Clock} tells the time. This abstraction allows Serenity/JS to have a single place
+ * in the framework responsible for telling the time, and one that can be easily mocked for internal testing.
+ *
+ * ```ts
+ * const now: Timestamp = new Clock().now()
+ * ```
+ *
+ * ## Learn more
+ * - {@apilink Timestamp}
+ * - {@apilink Duration}
+ *
+ * @group Time
+ */
+export class Clock {
+
+    constructor(private readonly checkTime: () => Date = () => new Date()) {
+    }
+
+    /**
+     * Returns current time
+     */
+    now(): Timestamp {
+        return new Timestamp(this.checkTime());
+    }
+}

package/src/screenplay/time/models/DelayedCallback.ts

@@ -0,0 +1,8 @@
+import { Timestamp } from './Timestamp';
+
+/**
+ * @group Time
+ */
+export interface DelayedCallback<Result> {
+    (stats: { currentTime: Timestamp, i: number }): Promise<Result> | Result;
+}

package/src/{model → screenplay/time/models}/Duration.ts

@@ -1,5 +1,10 @@
-import { TinyType } from 'tiny-types';
+import { ensure, isGreaterThanOrEqualTo, isInteger, JSONObject, TinyType } from 'tiny-types';
 
+/**
+ * Represents a duration in milliseconds between two {@apilink Timestamp|timestamps}.
+ *
+ * @group Time
+ */
 export class Duration extends TinyType {
 
     private static msPerSecond = 1000;
@@ -15,8 +20,13 @@ export class Duration extends TinyType {
     static ofDays           = (days: number): Duration         => Duration.ofMilliseconds(days     * Duration.msPerDay);
     static ofYears          = (years: number): Duration        => Duration.ofMilliseconds(years    * Duration.msPerYear);
 
+    static fromJSON({ milliseconds }: { milliseconds: number }): Duration {
+        return Duration.ofMilliseconds(milliseconds);
+    }
+
     constructor(private readonly milliseconds: number) {
         super();
+        ensure('duration', milliseconds, isInteger(), isGreaterThanOrEqualTo(0));
     }
 
     isLessThan(another: Duration): boolean {
@@ -60,4 +70,10 @@ export class Duration extends TinyType {
             : acc,
         '').trim() || '0ms';
     }
+
+    toJSON(): JSONObject {
+        return {
+            milliseconds: this.milliseconds,
+        }
+    }
 }