oidc-spa 4.2.1 → 4.3.0

package/src/oidc.ts

@@ -7,6 +7,9 @@ import { fnv1aHashToHex } from "./tools/fnv1aHashToHex";
 import { Deferred } from "./tools/Deferred";
 import { decodeJwt } from "./tools/decodeJwt";
 import { getDownlinkAndRtt } from "./tools/getDownlinkAndRtt";
+import { createIsUserActive } from "./tools/createIsUserActive";
+import { createStartCountdown } from "./tools/startCountdown";
+import type { StatefulObservable } from "./tools/StatefulObservable";
 
 export declare type Oidc<DecodedIdToken extends Record<string, unknown> = Record<string, unknown>> =
     | Oidc.LoggedIn<DecodedIdToken>
@@ -40,6 +43,9 @@ export declare namespace Oidc {
                     | { redirectTo: "home" | "current page" }
                     | { redirectTo: "specific url"; url: string }
             ) => Promise<never>;
+            subscribeToAutoLogoutCountdown: (
+                tickCallback: (params: { secondsLeft: number | undefined }) => void
+            ) => { unsubscribeFromAutoLogoutCountdown: () => void };
         };
 
     export type Tokens<DecodedIdToken extends Record<string, unknown> = Record<string, unknown>> =
@@ -120,8 +126,20 @@ export type ParamsOfCreateOidc<
      */
     publicUrl?: string;
     decodedIdTokenSchema?: { parse: (data: unknown) => DecodedIdToken };
+    /**
+     * This parameter defines after how many seconds of inactivity the user should be
+     * logged out automatically.
+     *
+     * WARNING: It should be configured on the identity server side
+     * as it's the authoritative source for security policies and not the client.
+     * If you don't provide this parameter it will be inferred from the refresh token expiration time.
+     * */
+    __unsafe_ssoSessionIdleSeconds?: number;
 };
 
+let $isUserActive: StatefulObservable<boolean> | undefined = undefined;
+const hotReloadCleanups = new Map<string, Set<() => void>>();
+
 /** @see: https://github.com/garronej/oidc-spa#option-1-usage-without-involving-the-ui-framework */
 export async function createOidc<
     DecodedIdToken extends Record<string, unknown> = Record<string, unknown>
@@ -133,7 +151,8 @@ export async function createOidc<
         transformUrlBeforeRedirect = url => url,
         extraQueryParams: extraQueryParamsOrGetter,
         publicUrl: publicUrl_params,
-        decodedIdTokenSchema
+        decodedIdTokenSchema,
+        __unsafe_ssoSessionIdleSeconds
     } = params;
 
     const getExtraQueryParams = (() => {
@@ -161,6 +180,12 @@ export async function createOidc<
     })();
 
     const configHash = fnv1aHashToHex(`${issuerUri} ${clientId}`);
+
+    {
+        hotReloadCleanups.get(configHash)?.forEach(cleanup => cleanup());
+        hotReloadCleanups.set(configHash, new Set());
+    }
+
     const configHashKey = "configHash";
 
     const oidcClientTsUserManager = new OidcClientTsUserManager({
@@ -174,15 +199,17 @@ export async function createOidc<
         "silent_redirect_uri": `${publicUrl}/silent-sso.html?${configHashKey}=${configHash}`
     });
 
+    // NOTE: Only useful for Firefox, see note bellow.
     let lastPublicRoute: string | undefined = undefined;
 
-    {
+    // NOTE: To call only if not logged in.
+    const startTrackingLastPublicRoute = () => {
         const realPushState = history.pushState.bind(history);
         history.pushState = function pushState(...args) {
             lastPublicRoute = window.location.href;
             return realPushState(...args);
         };
-    }
+    };
 
     let hasLoginBeenCalled = false;
 
@@ -243,6 +270,9 @@ export async function createOidc<
         });
 
         if (doesCurrentHrefRequiresAuth) {
+            // NOTE: In Firefox, when the user navigate back from the login page
+            // the state of the app is restored. We don't want that to happen,
+            // we want to redirect the user to the last public page.
             const callback = () => {
                 if (document.visibilityState === "visible") {
                     document.removeEventListener("visibilitychange", callback);
@@ -259,6 +289,9 @@ export async function createOidc<
 
         await oidcClientTsUserManager.signinRedirect({
             redirect_uri,
+            // NOTE: This is for the behavior when the use presses the back button on the login pages.
+            // This is what happens when the user gave up the login process.
+            // We want to that to redirect to the last public page.
             "redirectMethod": doesCurrentHrefRequiresAuth ? "replace" : "assign"
         });
         return new Promise<never>(() => {});
@@ -507,7 +540,9 @@ export async function createOidc<
                       "cause": error
                   });
 
-        console.error(`OIDC initilization error: ${initializationError.message}`);
+        console.error(`OIDC initialization error: ${initializationError.message}`);
+
+        startTrackingLastPublicRoute();
 
         return id<Oidc.NotLoggedIn>({
             ...common,
@@ -521,6 +556,8 @@ export async function createOidc<
     }
 
     if (initialTokens === undefined) {
+        startTrackingLastPublicRoute();
+
         return id<Oidc.NotLoggedIn>({
             ...common,
             "isUserLoggedIn": false,
@@ -531,6 +568,10 @@ export async function createOidc<
 
     let currentTokens = initialTokens;
 
+    const autoLogoutCountdownTickCallback = new Set<
+        (params: { secondsLeft: number | undefined }) => void
+    >();
+
     const onTokenChanges = new Set<() => void>();
 
     const oidc = id<Oidc.LoggedIn<DecodedIdToken>>({
@@ -583,24 +624,105 @@ export async function createOidc<
                     onTokenChanges.delete(onTokenChange);
                 }
             };
+        },
+        "subscribeToAutoLogoutCountdown": tickCallback => {
+            autoLogoutCountdownTickCallback.add(tickCallback);
+
+            const unsubscribeFromAutoLogoutCountdown = () => {
+                autoLogoutCountdownTickCallback.delete(tickCallback);
+            };
+
+            return { unsubscribeFromAutoLogoutCountdown };
         }
     });
 
-    (function scheduleAutomaticRenew() {
-        const msBeforeExpiration =
-            Math.min(currentTokens.accessTokenExpirationTime, currentTokens.refreshTokenExpirationTime) -
-            Date.now();
+    {
+        const getMsBeforeExpiration = () => {
+            // NOTE: In general the access token is supposed to have a shorter
+            // lifespan than the refresh token but we don't want to make any
+            // assumption here.
+            const tokenExpirationTime = Math.min(
+                currentTokens.accessTokenExpirationTime,
+                currentTokens.refreshTokenExpirationTime
+            );
 
-        setTimeout(async () => {
-            try {
-                await oidc.renewTokens();
-            } catch {
-                await login({ "doesCurrentHrefRequiresAuth": true });
+            return tokenExpirationTime - Date.now();
+        };
+
+        // NOTE: We refresh the token 25 seconds before it expires.
+        // If the token expiration time is less than 25 seconds we refresh the token when
+        // only 1/10 of the token time is left.
+        const renewMsBeforeExpires = Math.min(25_000, getMsBeforeExpiration() * 0.1);
+
+        (function scheduleRenew() {
+            const timer = setTimeout(async () => {
+                tokenChangeUnsubscribe();
+
+                try {
+                    await oidc.renewTokens();
+                } catch {
+                    // NOTE: Here semantically it's wrong. The user may very well be
+                    // on a page that require auth.
+                    // However there's no way to enforce the browser to redirect back to
+                    // the last public route if the user press back on the login page.
+                    // This is due to the fact that pushing to history only works if it's
+                    // triggered by a user interaction.
+                    await login({ "doesCurrentHrefRequiresAuth": false });
+                }
+
+                scheduleRenew();
+            }, getMsBeforeExpiration() - renewMsBeforeExpires);
+
+            const { unsubscribe: tokenChangeUnsubscribe } = oidc.subscribeToTokensChange(() => {
+                clearTimeout(timer);
+                tokenChangeUnsubscribe();
+                scheduleRenew();
+            });
+        })();
+    }
+
+    {
+        const { startCountdown } = createStartCountdown({
+            "getCountdownEndTime": () =>
+                __unsafe_ssoSessionIdleSeconds ?? currentTokens.refreshTokenExpirationTime,
+            "tickCallback": ({ secondsLeft }) => {
+                autoLogoutCountdownTickCallback.forEach(tickCallback => tickCallback({ secondsLeft }));
+
+                if (secondsLeft === 0) {
+                    oidc.logout({ "redirectTo": "current page" });
+                }
             }
+        });
 
-            scheduleAutomaticRenew();
-        }, msBeforeExpiration - /* min validity in seconds */ 25 * 1000);
-    })();
+        let stopCountdown: (() => void) | undefined = undefined;
+
+        if ($isUserActive === undefined) {
+            $isUserActive = createIsUserActive({
+                "theUserIsConsideredInactiveAfterMsOfInactivity": 5_000
+            }).$isUserActive;
+        }
+
+        const { unsubscribe: unsubscribeFrom$isUserActive } = $isUserActive.subscribe(isUserActive => {
+            if (isUserActive) {
+                if (stopCountdown !== undefined) {
+                    stopCountdown();
+                    stopCountdown = undefined;
+                }
+            } else {
+                assert(stopCountdown === undefined);
+                stopCountdown = startCountdown().stopCountdown;
+            }
+        });
+
+        {
+            const hotReloadCleanupsForThisConfig = hotReloadCleanups.get(configHash);
+            assert(hotReloadCleanupsForThisConfig !== undefined);
+            hotReloadCleanupsForThisConfig.add(() => {
+                unsubscribeFrom$isUserActive();
+                stopCountdown?.();
+            });
+        }
+    }
 
     return oidc;
 }

package/src/react.tsx

@@ -14,9 +14,11 @@ export namespace OidcReact {
     export type NotLoggedIn = Common & {
         isUserLoggedIn: false;
         login: Oidc.NotLoggedIn["login"];
+        initializationError: OidcInitializationError | undefined;
+
         oidcTokens?: never;
         logout?: never;
-        initializationError: OidcInitializationError | undefined;
+        subscribeToAutoLogoutCountdown?: never;
     };
 
     export type LoggedIn<DecodedIdToken extends Record<string, unknown>> = Common & {
@@ -24,6 +26,10 @@ export namespace OidcReact {
         oidcTokens: Oidc.Tokens<DecodedIdToken>;
         logout: Oidc.LoggedIn["logout"];
         renewTokens: Oidc.LoggedIn["renewTokens"];
+        subscribeToAutoLogoutCountdown: (
+            tickCallback: (params: { secondsLeft: number | undefined }) => void
+        ) => { unsubscribeFromAutoLogoutCountdown: () => void };
+
         login?: never;
         initializationError?: never;
     };
@@ -160,7 +166,8 @@ export function createReactOidc<
                       "isUserLoggedIn": true,
                       oidcTokens,
                       "logout": oidc.logout,
-                      "renewTokens": oidc.renewTokens
+                      "renewTokens": oidc.renewTokens,
+                      "subscribeToAutoLogoutCountdown": oidc.subscribeToAutoLogoutCountdown
                   })
               )
             : id<OidcReact.NotLoggedIn>({

package/src/tools/StatefulObservable.ts

@@ -0,0 +1,52 @@
+export type StatefulObservable<T> = {
+    current: T;
+    subscribe: (next: (data: T) => void) => Subscription;
+};
+
+export type StatefulReadonlyObservable<T> = {
+    readonly current: T;
+    subscribe: (next: (data: T) => void) => Subscription;
+};
+
+export type Subscription = {
+    unsubscribe(): void;
+};
+
+export function createStatefulObservable<T>(getInitialValue: () => T): StatefulObservable<T> {
+    let nextFunctions: ((data: T) => void)[] = [];
+
+    const { get, set } = (() => {
+        let wrappedState: [T] | undefined = undefined;
+
+        return {
+            "get": () => {
+                if (wrappedState === undefined) {
+                    wrappedState = [getInitialValue()];
+                }
+                return wrappedState[0];
+            },
+            "set": (data: T) => {
+                wrappedState = [data];
+
+                nextFunctions.forEach(next => next(data));
+            }
+        };
+    })();
+
+    return Object.defineProperty(
+        {
+            "current": null as any as T,
+            "subscribe": (next: (data: T) => void) => {
+                nextFunctions.push(next);
+
+                return { "unsubscribe": () => nextFunctions.splice(nextFunctions.indexOf(next), 1) };
+            }
+        },
+        "current",
+        {
+            "enumerable": true,
+            get,
+            set
+        }
+    );
+}

package/src/tools/createIsUserActive.ts

@@ -0,0 +1,41 @@
+import { createStatefulObservable } from "./StatefulObservable";
+import { subscribeToUserInteraction } from "./subscribeToUserInteraction";
+import { assert } from "tsafe/assert";
+
+export function createIsUserActive(params: { theUserIsConsideredInactiveAfterMsOfInactivity: number }) {
+    const { theUserIsConsideredInactiveAfterMsOfInactivity } = params;
+
+    // this should set itself to false whenever the user had performed no user interaction for a certain amount of time
+    const $isUserActive = createStatefulObservable(() => true);
+
+    const scheduleSetInactive = () => {
+        const timer = setTimeout(() => {
+            assert($isUserActive.current);
+            $isUserActive.current = false;
+        }, theUserIsConsideredInactiveAfterMsOfInactivity);
+        return () => {
+            clearTimeout(timer);
+        };
+    };
+
+    let clearScheduledSetInactive = scheduleSetInactive();
+
+    const { unsubscribeFromUserInteraction } = subscribeToUserInteraction({
+        "throttleMs": 1_000,
+        "callback": () => {
+            clearScheduledSetInactive();
+            clearScheduledSetInactive = scheduleSetInactive();
+
+            if (!$isUserActive.current) {
+                $isUserActive.current = true;
+            }
+        }
+    });
+
+    const disable$isUserActive = () => {
+        unsubscribeFromUserInteraction();
+        clearScheduledSetInactive();
+    };
+
+    return { $isUserActive, disable$isUserActive };
+}

package/src/tools/getPrUserInteraction.ts

@@ -0,0 +1,23 @@
+import { Deferred } from "./Deferred";
+
+export function getPrUserInteraction() {
+    const d = new Deferred<void>();
+
+    const callback = () => {
+        d.resolve();
+        cleanup();
+    };
+
+    const cleanup = () => {
+        window.document.removeEventListener("mousemove", callback, false);
+        window.document.removeEventListener("keydown", callback, false);
+    };
+
+    window.document.addEventListener("mousemove", callback, false);
+    window.document.addEventListener("keydown", callback, false);
+
+    return {
+        "prUserInteraction": d.pr,
+        "cancelPrUserInteraction": cleanup
+    };
+}

package/src/tools/startCountdown.ts

@@ -0,0 +1,35 @@
+export function createStartCountdown(params: {
+    tickCallback: (params: { secondsLeft: number | undefined }) => void;
+    getCountdownEndTime: () => number;
+}) {
+    const { getCountdownEndTime, tickCallback } = params;
+
+    const getCountdownEndInMs = () => getCountdownEndTime() - Date.now();
+
+    function startCountdown() {
+        let timer: ReturnType<typeof setTimeout>;
+
+        (async () => {
+            let secondsLeft = Math.floor(getCountdownEndInMs() / 1000);
+
+            while (secondsLeft >= 0) {
+                tickCallback({ secondsLeft });
+
+                await new Promise<void>(resolve => {
+                    timer = setTimeout(resolve, 1_000);
+                });
+
+                secondsLeft--;
+            }
+        })();
+
+        const stopCountdown = () => {
+            clearTimeout(timer);
+            tickCallback({ "secondsLeft": undefined });
+        };
+
+        return { stopCountdown };
+    }
+
+    return { startCountdown };
+}

package/src/tools/subscribeToUserInteraction.ts

@@ -0,0 +1,33 @@
+import { getPrUserInteraction } from "./getPrUserInteraction";
+
+export function subscribeToUserInteraction(params: { throttleMs: number; callback: () => void }) {
+    const { throttleMs } = params;
+
+    const cleanups = new Set<() => void>();
+
+    (async function callee() {
+        const { cancelPrUserInteraction, prUserInteraction } = getPrUserInteraction();
+
+        cleanups.add(cancelPrUserInteraction);
+
+        await prUserInteraction;
+
+        params.callback();
+
+        await new Promise<void>(resolve => {
+            const timer = setTimeout(resolve, throttleMs);
+            cleanups.add(() => {
+                clearTimeout(timer);
+            });
+        });
+
+        cleanups.clear();
+        callee();
+    })();
+
+    const unsubscribeFromUserInteraction = () => {
+        cleanups.forEach(cleanup => cleanup());
+    };
+
+    return { unsubscribeFromUserInteraction };
+}

package/tools/StatefulObservable.d.ts

@@ -0,0 +1,12 @@
+export type StatefulObservable<T> = {
+    current: T;
+    subscribe: (next: (data: T) => void) => Subscription;
+};
+export type StatefulReadonlyObservable<T> = {
+    readonly current: T;
+    subscribe: (next: (data: T) => void) => Subscription;
+};
+export type Subscription = {
+    unsubscribe(): void;
+};
+export declare function createStatefulObservable<T>(getInitialValue: () => T): StatefulObservable<T>;

package/tools/StatefulObservable.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStatefulObservable = void 0;
+function createStatefulObservable(getInitialValue) {
+    var nextFunctions = [];
+    var _a = (function () {
+        var wrappedState = undefined;
+        return {
+            "get": function () {
+                if (wrappedState === undefined) {
+                    wrappedState = [getInitialValue()];
+                }
+                return wrappedState[0];
+            },
+            "set": function (data) {
+                wrappedState = [data];
+                nextFunctions.forEach(function (next) { return next(data); });
+            }
+        };
+    })(), get = _a.get, set = _a.set;
+    return Object.defineProperty({
+        "current": null,
+        "subscribe": function (next) {
+            nextFunctions.push(next);
+            return { "unsubscribe": function () { return nextFunctions.splice(nextFunctions.indexOf(next), 1); } };
+        }
+    }, "current", {
+        "enumerable": true,
+        get: get,
+        set: set
+    });
+}
+exports.createStatefulObservable = createStatefulObservable;
+//# sourceMappingURL=StatefulObservable.js.map

package/tools/StatefulObservable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StatefulObservable.js","sourceRoot":"","sources":["../src/tools/StatefulObservable.ts"],"names":[],"mappings":";;;AAcA,SAAgB,wBAAwB,CAAI,eAAwB;IAChE,IAAI,aAAa,GAA0B,EAAE,CAAC;IAExC,IAAA,KAAe,CAAC;QAClB,IAAI,YAAY,GAAoB,SAAS,CAAC;QAE9C,OAAO;YACH,KAAK,EAAE;gBACH,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;oBAC7B,YAAY,GAAG,CAAC,eAAe,EAAE,CAAC,CAAC;gBACvC,CAAC;gBACD,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC;YAC3B,CAAC;YACD,KAAK,EAAE,UAAC,IAAO;gBACX,YAAY,GAAG,CAAC,IAAI,CAAC,CAAC;gBAEtB,aAAa,CAAC,OAAO,CAAC,UAAA,IAAI,IAAI,OAAA,IAAI,CAAC,IAAI,CAAC,EAAV,CAAU,CAAC,CAAC;YAC9C,CAAC;SACJ,CAAC;IACN,CAAC,CAAC,EAAE,EAhBI,GAAG,SAAA,EAAE,GAAG,SAgBZ,CAAC;IAEL,OAAO,MAAM,CAAC,cAAc,CACxB;QACI,SAAS,EAAE,IAAgB;QAC3B,WAAW,EAAE,UAAC,IAAuB;YACjC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAEzB,OAAO,EAAE,aAAa,EAAE,cAAM,OAAA,aAAa,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,EAApD,CAAoD,EAAE,CAAC;QACzF,CAAC;KACJ,EACD,SAAS,EACT;QACI,YAAY,EAAE,IAAI;QAClB,GAAG,KAAA;QACH,GAAG,KAAA;KACN,CACJ,CAAC;AACN,CAAC;AArCD,4DAqCC"}

package/tools/createIsUserActive.d.ts

@@ -0,0 +1,6 @@
+export declare function createIsUserActive(params: {
+    theUserIsConsideredInactiveAfterMsOfInactivity: number;
+}): {
+    $isUserActive: import("./StatefulObservable").StatefulObservable<boolean>;
+    disable$isUserActive: () => void;
+};

package/tools/createIsUserActive.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIsUserActive = void 0;
+var StatefulObservable_1 = require("./StatefulObservable");
+var subscribeToUserInteraction_1 = require("./subscribeToUserInteraction");
+var assert_1 = require("tsafe/assert");
+function createIsUserActive(params) {
+    var theUserIsConsideredInactiveAfterMsOfInactivity = params.theUserIsConsideredInactiveAfterMsOfInactivity;
+    // this should set itself to false whenever the user had performed no user interaction for a certain amount of time
+    var $isUserActive = (0, StatefulObservable_1.createStatefulObservable)(function () { return true; });
+    var scheduleSetInactive = function () {
+        var timer = setTimeout(function () {
+            (0, assert_1.assert)($isUserActive.current);
+            $isUserActive.current = false;
+        }, theUserIsConsideredInactiveAfterMsOfInactivity);
+        return function () {
+            clearTimeout(timer);
+        };
+    };
+    var clearScheduledSetInactive = scheduleSetInactive();
+    var unsubscribeFromUserInteraction = (0, subscribeToUserInteraction_1.subscribeToUserInteraction)({
+        "throttleMs": 1000,
+        "callback": function () {
+            clearScheduledSetInactive();
+            clearScheduledSetInactive = scheduleSetInactive();
+            if (!$isUserActive.current) {
+                $isUserActive.current = true;
+            }
+        }
+    }).unsubscribeFromUserInteraction;
+    var disable$isUserActive = function () {
+        unsubscribeFromUserInteraction();
+        clearScheduledSetInactive();
+    };
+    return { $isUserActive: $isUserActive, disable$isUserActive: disable$isUserActive };
+}
+exports.createIsUserActive = createIsUserActive;
+//# sourceMappingURL=createIsUserActive.js.map

package/tools/createIsUserActive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createIsUserActive.js","sourceRoot":"","sources":["../src/tools/createIsUserActive.ts"],"names":[],"mappings":";;;AAAA,2DAAgE;AAChE,2EAA0E;AAC1E,uCAAsC;AAEtC,SAAgB,kBAAkB,CAAC,MAAkE;IACzF,IAAA,8CAA8C,GAAK,MAAM,+CAAX,CAAY;IAElE,mHAAmH;IACnH,IAAM,aAAa,GAAG,IAAA,6CAAwB,EAAC,cAAM,OAAA,IAAI,EAAJ,CAAI,CAAC,CAAC;IAE3D,IAAM,mBAAmB,GAAG;QACxB,IAAM,KAAK,GAAG,UAAU,CAAC;YACrB,IAAA,eAAM,EAAC,aAAa,CAAC,OAAO,CAAC,CAAC;YAC9B,aAAa,CAAC,OAAO,GAAG,KAAK,CAAC;QAClC,CAAC,EAAE,8CAA8C,CAAC,CAAC;QACnD,OAAO;YACH,YAAY,CAAC,KAAK,CAAC,CAAC;QACxB,CAAC,CAAC;IACN,CAAC,CAAC;IAEF,IAAI,yBAAyB,GAAG,mBAAmB,EAAE,CAAC;IAE9C,IAAA,8BAA8B,GAAK,IAAA,uDAA0B,EAAC;QAClE,YAAY,EAAE,IAAK;QACnB,UAAU,EAAE;YACR,yBAAyB,EAAE,CAAC;YAC5B,yBAAyB,GAAG,mBAAmB,EAAE,CAAC;YAElD,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;gBACzB,aAAa,CAAC,OAAO,GAAG,IAAI,CAAC;YACjC,CAAC;QACL,CAAC;KACJ,CAAC,+BAVoC,CAUnC;IAEH,IAAM,oBAAoB,GAAG;QACzB,8BAA8B,EAAE,CAAC;QACjC,yBAAyB,EAAE,CAAC;IAChC,CAAC,CAAC;IAEF,OAAO,EAAE,aAAa,eAAA,EAAE,oBAAoB,sBAAA,EAAE,CAAC;AACnD,CAAC;AApCD,gDAoCC"}

package/tools/getPrUserInteraction.d.ts

@@ -0,0 +1,4 @@
+export declare function getPrUserInteraction(): {
+    prUserInteraction: Promise<void>;
+    cancelPrUserInteraction: () => void;
+};

package/tools/getPrUserInteraction.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrUserInteraction = void 0;
+var Deferred_1 = require("./Deferred");
+function getPrUserInteraction() {
+    var d = new Deferred_1.Deferred();
+    var callback = function () {
+        d.resolve();
+        cleanup();
+    };
+    var cleanup = function () {
+        window.document.removeEventListener("mousemove", callback, false);
+        window.document.removeEventListener("keydown", callback, false);
+    };
+    window.document.addEventListener("mousemove", callback, false);
+    window.document.addEventListener("keydown", callback, false);
+    return {
+        "prUserInteraction": d.pr,
+        "cancelPrUserInteraction": cleanup
+    };
+}
+exports.getPrUserInteraction = getPrUserInteraction;
+//# sourceMappingURL=getPrUserInteraction.js.map

package/tools/getPrUserInteraction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPrUserInteraction.js","sourceRoot":"","sources":["../src/tools/getPrUserInteraction.ts"],"names":[],"mappings":";;;AAAA,uCAAsC;AAEtC,SAAgB,oBAAoB;IAChC,IAAM,CAAC,GAAG,IAAI,mBAAQ,EAAQ,CAAC;IAE/B,IAAM,QAAQ,GAAG;QACb,CAAC,CAAC,OAAO,EAAE,CAAC;QACZ,OAAO,EAAE,CAAC;IACd,CAAC,CAAC;IAEF,IAAM,OAAO,GAAG;QACZ,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAC,WAAW,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;QAClE,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAC,SAAS,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;IACpE,CAAC,CAAC;IAEF,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,WAAW,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;IAC/D,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,SAAS,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;IAE7D,OAAO;QACH,mBAAmB,EAAE,CAAC,CAAC,EAAE;QACzB,yBAAyB,EAAE,OAAO;KACrC,CAAC;AACN,CAAC;AApBD,oDAoBC"}

package/tools/startCountdown.d.ts

@@ -0,0 +1,10 @@
+export declare function createStartCountdown(params: {
+    tickCallback: (params: {
+        secondsLeft: number | undefined;
+    }) => void;
+    getCountdownEndTime: () => number;
+}): {
+    startCountdown: () => {
+        stopCountdown: () => void;
+    };
+};