oidc-spa 8.0.3 → 8.0.5

package/src/angular/angular.ts

@@ -0,0 +1,429 @@
+import { type Oidc, createOidc, type ParamsOfCreateOidc, OidcInitializationError } from "../core";
+import { assert, type Equals } from "../vendor/frontend/tsafe";
+import { id } from "../vendor/frontend/tsafe";
+import type { ValueOrAsyncGetter } from "../tools/ValueOrAsyncGetter";
+import { Deferred } from "../tools/Deferred";
+import { type Signal, type EnvironmentProviders, provideAppInitializer, inject } from "@angular/core";
+import { type CanActivateFn, Router } from "@angular/router";
+import { toSignal } from "@angular/core/rxjs-interop";
+import { BehaviorSubject } from "rxjs";
+import { createObjectThatThrowsIfAccessed } from "../tools/createObjectThatThrowsIfAccessed";
+
+export type OidcAngular = OidcAngular.NotLoggedIn | OidcAngular.LoggedIn;
+
+export namespace OidcAngular {
+    export type Common = Oidc.Common;
+
+    export type NotLoggedIn = Common & {
+        isUserLoggedIn: false;
+        login: (params?: {
+            extraQueryParams?: Record<string, string | undefined>;
+            transformUrlBeforeRedirect?: (url: string) => string;
+        }) => Promise<never>;
+    };
+
+    export type LoggedIn = Common & {
+        isUserLoggedIn: true;
+        logout: Oidc.LoggedIn["logout"];
+        renewTokens: Oidc.LoggedIn["renewTokens"];
+        goToAuthServer: Oidc.LoggedIn["goToAuthServer"];
+        backFromAuthServer:
+            | {
+                  extraQueryParams: Record<string, string>;
+                  result: Record<string, string>;
+              }
+            | undefined;
+        isNewBrowserSession: boolean;
+    };
+}
+
+type OidcAngularApi<DecodedIdToken extends Record<string, unknown>, AutoLogin extends boolean> = {
+    getOidc: AutoLogin extends true
+        ? {
+              (params?: { assert: "user logged in" }): OidcAngular.LoggedIn;
+          }
+        : {
+              (params?: { assert?: undefined }): OidcAngular;
+              (params: { assert: "user logged in" }): OidcAngular.LoggedIn;
+              (params: { assert: "user not logged in" }): OidcAngular.NotLoggedIn;
+          };
+
+    getOidcInitializationError: () => OidcInitializationError | undefined;
+
+    get$decodedIdToken: () => Signal<DecodedIdToken>;
+
+    get$secondsLeftBeforeAutoLogout: (params: {
+        warningDurationSeconds: number;
+    }) => Signal<number | undefined>;
+
+    getTokens: () => Promise<
+        | { isUserLoggedIn: false; prTokens?: never }
+        | { isUserLoggedIn: true; prTokens: Promise<Oidc.Tokens<DecodedIdToken>> }
+    >;
+
+    provideOidcInitAwaiter: EnvironmentProviders;
+} & (AutoLogin extends true
+    ? {}
+    : {
+          enforceLoginGuard: CanActivateFn;
+      });
+
+export function createAngularOidc_dependencyInjection<
+    DecodedIdToken extends Record<string, unknown>,
+    ParamsOfCreateOidc extends {
+        autoLogin?: boolean;
+    } & (
+        | {
+              decodedIdTokenSchema: { parse: (data: unknown) => DecodedIdToken } | undefined;
+          }
+        | {}
+    )
+>(
+    paramsOrGetParams: ValueOrAsyncGetter<ParamsOfCreateOidc>,
+    createOidc: (params: ParamsOfCreateOidc) => Promise<Oidc<DecodedIdToken>>
+): OidcAngularApi<
+    DecodedIdToken,
+    ParamsOfCreateOidc extends { autoLogin?: true | undefined } ? true : false
+> {
+    const dReadyToCreate = new Deferred<void>();
+
+    // NOTE: It can be InitializationError only if autoLogin is true
+    const prOidcOrAutoLoginInitializationError = (async () => {
+        const params = await (async () => {
+            await dReadyToCreate.pr;
+
+            if (typeof paramsOrGetParams === "function") {
+                const getParams = paramsOrGetParams;
+
+                const params = await getParams();
+
+                return params;
+            }
+
+            const params = paramsOrGetParams;
+
+            return params;
+        })();
+
+        let oidc: Oidc<DecodedIdToken>;
+
+        try {
+            oidc = await createOidc(params);
+        } catch (error) {
+            if (!(error instanceof OidcInitializationError)) {
+                throw error;
+            }
+
+            return error;
+        }
+
+        return oidc;
+    })();
+
+    let oidcOrAutoLoginInitializationError: Oidc<DecodedIdToken> | OidcInitializationError | undefined =
+        undefined;
+
+    prOidcOrAutoLoginInitializationError.then(value => {
+        oidcOrAutoLoginInitializationError = value;
+    });
+
+    function getOidc(params?: { assert?: "user logged in" | "user not logged in" }): OidcAngular {
+        const { assert: assert_params } = params ?? {};
+
+        if (oidcOrAutoLoginInitializationError === undefined) {
+            throw new Error("oidc-spa: calling getOidc() before provideOidcInitAwaiter has resolved");
+        }
+
+        if (oidcOrAutoLoginInitializationError instanceof OidcInitializationError) {
+            throw new Error(
+                "oidc-spa: calling getOidc() while getOidcInitializationError() is not `undefined` in autoLogin: true mode"
+            );
+        }
+
+        const oidc = oidcOrAutoLoginInitializationError;
+
+        check_assertion: {
+            if (assert_params === undefined) {
+                break check_assertion;
+            }
+
+            const getMessage = (v: string) =>
+                [
+                    "There is a logic error in the application.",
+                    `If this component is mounted the user is supposed ${v}.`,
+                    "An explicit assertion was made in this sense."
+                ].join(" ");
+
+            switch (assert_params) {
+                case "user logged in":
+                    if (!oidc.isUserLoggedIn) {
+                        throw new Error(getMessage("to be logged in but currently they arn't"));
+                    }
+                    break;
+                case "user not logged in":
+                    if (oidc.isUserLoggedIn) {
+                        throw new Error(getMessage("not to be logged in but currently they are"));
+                    }
+                    break;
+                default:
+                    assert<Equals<typeof assert_params, never>>(false);
+            }
+        }
+
+        const common: OidcAngular.Common = {
+            params: oidc.params
+        };
+
+        return oidc.isUserLoggedIn
+            ? id<OidcAngular.LoggedIn>({
+                  ...common,
+                  isUserLoggedIn: true,
+                  logout: oidc.logout,
+                  renewTokens: oidc.renewTokens,
+                  goToAuthServer: oidc.goToAuthServer,
+                  backFromAuthServer: oidc.backFromAuthServer,
+                  isNewBrowserSession: oidc.isNewBrowserSession
+              })
+            : id<OidcAngular.NotLoggedIn>({
+                  ...common,
+                  isUserLoggedIn: false,
+                  login: params =>
+                      oidc.login({
+                          ...params,
+                          doesCurrentHrefRequiresAuth: false
+                      })
+              });
+    }
+
+    function getOidcInitializationError(): OidcInitializationError | undefined {
+        if (oidcOrAutoLoginInitializationError === undefined) {
+            throw new Error(
+                "oidc-spa: calling getOidcInitializationError() before provideOidcInitAwaiter has resolved"
+            );
+        }
+
+        if (oidcOrAutoLoginInitializationError instanceof OidcInitializationError) {
+            return oidcOrAutoLoginInitializationError;
+        }
+
+        const oidc = oidcOrAutoLoginInitializationError;
+
+        if (!oidc.isUserLoggedIn && oidc.initializationError !== undefined) {
+            return oidc.initializationError;
+        }
+
+        return undefined;
+    }
+
+    const { get$decodedIdToken } = (() => {
+        function createDecodedIdToken$() {
+            if (oidcOrAutoLoginInitializationError === undefined) {
+                throw new Error(
+                    "oidc-spa: calling get$decodedIdToken() before provideOidcInitAwaiter has resolved"
+                );
+            }
+
+            if (oidcOrAutoLoginInitializationError instanceof OidcInitializationError) {
+                throw new Error(
+                    "oidc-spa: calling getOidc() while getOidcInitializationError() is not `undefined` in autoLogin: true mode"
+                );
+            }
+
+            const oidc = oidcOrAutoLoginInitializationError;
+
+            let initialValue: DecodedIdToken;
+
+            if (!oidc.isUserLoggedIn) {
+                initialValue = createObjectThatThrowsIfAccessed({
+                    debugMessage: [
+                        "You are trying to read the decodedIdToken but the user",
+                        "isn't logged in"
+                    ].join(" ")
+                });
+            } else {
+                initialValue = oidc.getDecodedIdToken();
+            }
+
+            const decodedIdToken$ = new BehaviorSubject<DecodedIdToken>(initialValue);
+
+            if (oidc.isUserLoggedIn) {
+                oidc.subscribeToTokensChange(() => {
+                    const decodedIdToken = oidc.getDecodedIdToken();
+
+                    if (decodedIdToken$.getValue() === decodedIdToken) {
+                        return;
+                    }
+
+                    decodedIdToken$.next(decodedIdToken);
+                });
+            }
+
+            return decodedIdToken$;
+        }
+
+        let decodedIdToken$: BehaviorSubject<DecodedIdToken> | undefined = undefined;
+
+        function get$decodedIdToken(): Signal<DecodedIdToken> {
+            return toSignal((decodedIdToken$ ??= createDecodedIdToken$()), {
+                requireSync: true
+            });
+        }
+
+        return { get$decodedIdToken };
+    })();
+
+    const { get$secondsLeftBeforeAutoLogout } = (() => {
+        function createSecondsLeftBeforeAutoLogout$() {
+            if (oidcOrAutoLoginInitializationError === undefined) {
+                throw new Error(
+                    "oidc-spa: calling get$decodedIdToken() before provideOidcInitAwaiter has resolved"
+                );
+            }
+
+            if (oidcOrAutoLoginInitializationError instanceof OidcInitializationError) {
+                throw new Error(
+                    "oidc-spa: calling getOidc() while getOidcInitializationError() is not `undefined` in autoLogin: true mode"
+                );
+            }
+
+            const oidc = oidcOrAutoLoginInitializationError;
+
+            const secondsLeftBeforeAutoLogout$ = new BehaviorSubject<number | undefined>(undefined);
+
+            if (oidc.isUserLoggedIn) {
+                oidc.subscribeToAutoLogoutCountdown(({ secondsLeft }) =>
+                    secondsLeftBeforeAutoLogout$.next(secondsLeft)
+                );
+            }
+
+            return secondsLeftBeforeAutoLogout$;
+        }
+
+        let secondsLeftBeforeAutoLogout$: BehaviorSubject<number | undefined> | undefined = undefined;
+
+        function get$secondsLeftBeforeAutoLogout(params: {
+            warningDurationSeconds: number;
+        }): Signal<number | undefined> {
+            const { warningDurationSeconds } = params;
+
+            secondsLeftBeforeAutoLogout$ ??= createSecondsLeftBeforeAutoLogout$();
+
+            const secondsLeftBeforeAutoLogout$_cropped = new BehaviorSubject<number | undefined>(
+                secondsLeftBeforeAutoLogout$.getValue()
+            );
+
+            secondsLeftBeforeAutoLogout$.subscribe(secondsLeftBeforeAutoLogout => {
+                if (
+                    secondsLeftBeforeAutoLogout === undefined ||
+                    secondsLeftBeforeAutoLogout > warningDurationSeconds
+                ) {
+                    if (secondsLeftBeforeAutoLogout$_cropped.getValue() !== undefined) {
+                        secondsLeftBeforeAutoLogout$_cropped.next(undefined);
+                    }
+                    return;
+                }
+
+                secondsLeftBeforeAutoLogout$_cropped.next(secondsLeftBeforeAutoLogout);
+            });
+
+            const signal = toSignal(secondsLeftBeforeAutoLogout$_cropped, {
+                requireSync: true
+            });
+
+            return signal;
+        }
+
+        return { get$secondsLeftBeforeAutoLogout };
+    })();
+
+    async function getTokens(): Promise<
+        | { isUserLoggedIn: false; prTokens?: never }
+        | { isUserLoggedIn: true; prTokens: Promise<Oidc.Tokens<DecodedIdToken>> }
+    > {
+        const oidcOrAutoLoginInitializationError = await prOidcOrAutoLoginInitializationError;
+
+        if (oidcOrAutoLoginInitializationError instanceof OidcInitializationError) {
+            return new Promise<never>(() => {});
+        }
+
+        const oidc = oidcOrAutoLoginInitializationError;
+
+        return oidc.isUserLoggedIn
+            ? { isUserLoggedIn: true, prTokens: oidc.getTokens() }
+            : {
+                  isUserLoggedIn: false
+              };
+    }
+
+    const provideOidcInitAwaiter: EnvironmentProviders = provideAppInitializer(async () => {
+        dReadyToCreate.resolve();
+        await prOidcOrAutoLoginInitializationError;
+    });
+
+    const enforceLoginGuard: CanActivateFn = async route => {
+        const router = inject(Router);
+
+        const oidcOrAutoLoginInitializationError = await prOidcOrAutoLoginInitializationError;
+
+        if (oidcOrAutoLoginInitializationError instanceof OidcInitializationError) {
+            // TODO: Not the correct behavior here.
+            return new Promise<never>(() => {});
+        }
+
+        const oidc = oidcOrAutoLoginInitializationError;
+
+        if (!oidc.isUserLoggedIn) {
+            const redirectUrl = (() => {
+                const tree = router.createUrlTree(
+                    route.url.map(u => u.path),
+                    {
+                        queryParams: route.queryParams
+                    }
+                );
+                return router.serializeUrl(tree);
+            })();
+
+            const doesCurrentHrefRequiresAuth =
+                location.href.replace(/\/$/, "") === redirectUrl.replace(/\/$/, "");
+
+            await oidc.login({
+                doesCurrentHrefRequiresAuth,
+                redirectUrl
+            });
+        }
+
+        return true;
+    };
+
+    const oidcAngularApi = id<OidcAngularApi<DecodedIdToken, false>>({
+        getOidc: getOidc as any,
+        getOidcInitializationError,
+        get$decodedIdToken,
+        get$secondsLeftBeforeAutoLogout,
+        getTokens,
+        provideOidcInitAwaiter,
+        enforceLoginGuard
+    });
+
+    // @ts-expect-error: We know what we are doing
+    return oidcAngularApi;
+}
+
+/** @see: https://docs.oidc-spa.dev/v/v8/usage#angular-api */
+export function createAngularOidc<
+    DecodedIdToken extends Record<string, unknown> = Oidc.Tokens.DecodedIdToken_base,
+    AutoLogin extends boolean = false
+>(params: ValueOrAsyncGetter<Omit<ParamsOfCreateOidc<DecodedIdToken, AutoLogin>, "homeUrl">>) {
+    return createAngularOidc_dependencyInjection(params, params =>
+        createOidc({
+            ...params,
+            homeUrl: (() => {
+                const baseEl = document.querySelector<HTMLBaseElement>("base[href]");
+                if (!baseEl) {
+                    throw new Error('No <base href="..."> element found in the DOM');
+                }
+                return baseEl.getAttribute("href") ?? "/";
+            })()
+        })
+    );
+}

package/src/angular/index.ts

@@ -0,0 +1 @@
+export { type OidcAngular, createAngularOidc } from "./angular";

package/src/core/createOidc.ts

@@ -47,6 +47,7 @@ import {
 import { createGetIsNewBrowserSession } from "./isNewBrowserSession";
 import { getIsOnline } from "../tools/getIsOnline";
 import { isKeycloak } from "../keycloak/isKeycloak";
+import { INFINITY_TIME } from "../tools/INFINITY_TIME";
 
 // NOTE: Replaced at build time
 const VERSION = "{{OIDC_SPA_VERSION}}";
@@ -1502,6 +1503,14 @@ export async function createOidc_nonMemoized<
             return;
         }
 
+        if (
+            currentTokens.refreshTokenExpirationTime !== undefined &&
+            currentTokens.refreshTokenExpirationTime >= INFINITY_TIME
+        ) {
+            log?.("The refresh_token never expires, disabling auto-renewal mechanism");
+            return;
+        }
+
         const msBeforeExpiration =
             (currentTokens.refreshTokenExpirationTime ?? currentTokens.accessTokenExpirationTime) -
             currentTokens.getServerDateNow();
@@ -1612,9 +1621,18 @@ export async function createOidc_nonMemoized<
                 return undefined;
             }
 
+            if (currentTokens.refreshTokenExpirationTime >= INFINITY_TIME) {
+                return 0;
+            }
+
             return (currentTokens.refreshTokenExpirationTime - currentTokens.issuedAtTime) / 1000;
         };
 
+        if (getCurrentRefreshTokenTtlInSeconds() === 0) {
+            log?.("The refresh_token never expires, disabling auto logout mechanism");
+            break auto_logout;
+        }
+
         if (getCurrentRefreshTokenTtlInSeconds() === undefined) {
             log?.(
                 `${

package/src/core/oidcClientTsUserToTokens.ts

@@ -3,6 +3,7 @@ import { assert, id } from "../vendor/frontend/tsafe";
 import { readExpirationTimeInJwt } from "../tools/readExpirationTimeInJwt";
 import { decodeJwt } from "../tools/decodeJwt";
 import type { Oidc } from "./Oidc";
+import { INFINITY_TIME } from "../tools/INFINITY_TIME";
 
 export function oidcClientTsUserToTokens<DecodedIdToken extends Record<string, unknown>>(params: {
     oidcClientTsUser: OidcClientTsUser;
@@ -187,6 +188,10 @@ export function oidcClientTsUserToTokens<DecodedIdToken extends Record<string, u
 
                           assert(typeof refresh_expires_at === "number", "2033392");
 
+                          if (refresh_expires_at === 0) {
+                              return INFINITY_TIME;
+                          }
+
                           return refresh_expires_at * 1000;
                       }
 
@@ -199,6 +204,10 @@ export function oidcClientTsUserToTokens<DecodedIdToken extends Record<string, u
 
                           assert(typeof refresh_expires_in === "number", "2033425330");
 
+                          if (refresh_expires_in === 0) {
+                              return INFINITY_TIME;
+                          }
+
                           return issuedAtTime + refresh_expires_in * 1000;
                       }
 

package/src/mock/angular.ts

@@ -0,0 +1,11 @@
+import { createAngularOidc_dependencyInjection } from "../angular/angular";
+import { createMockOidc, type ParamsOfCreateMockOidc } from "./oidc";
+import type { ValueOrAsyncGetter } from "../tools/ValueOrAsyncGetter";
+
+/** @see: https://docs.oidc-spa.dev/v/v8/mock */
+export function createMockAngularOidc<
+    DecodedIdToken extends Record<string, unknown> = Record<string, unknown>,
+    AutoLogin extends boolean = false
+>(params: ValueOrAsyncGetter<ParamsOfCreateMockOidc<DecodedIdToken, AutoLogin>>) {
+    return createAngularOidc_dependencyInjection(params, createMockOidc);
+}

package/src/mock/oidc.ts

@@ -4,6 +4,7 @@ import { id } from "../vendor/frontend/tsafe";
 import { toFullyQualifiedUrl } from "../tools/toFullyQualifiedUrl";
 import { getSearchParam, addOrUpdateSearchParam } from "../tools/urlSearchParams";
 import { getRootRelativeOriginalLocationHref } from "../core/earlyInit";
+import { INFINITY_TIME } from "../tools/INFINITY_TIME";
 
 export type ParamsOfCreateMockOidc<
     DecodedIdToken extends Record<string, unknown> = Record<string, unknown>,
@@ -144,7 +145,7 @@ export async function createMockOidc<
         ...(() => {
             const tokens_common: Oidc.Tokens.Common<DecodedIdToken> = {
                 accessToken: mockedTokens.accessToken ?? "mocked-access-token",
-                accessTokenExpirationTime: mockedTokens.accessTokenExpirationTime ?? Infinity,
+                accessTokenExpirationTime: mockedTokens.accessTokenExpirationTime ?? INFINITY_TIME,
                 idToken: mockedTokens.idToken ?? "mocked-id-token",
                 decodedIdToken:
                     mockedTokens.decodedIdToken ??

package/src/mock/react.tsx

@@ -1,4 +1,4 @@
-import { createOidcReactApi_dependencyInjection } from "../react/react";
+import { createReactOidc_dependencyInjection } from "../react/react";
 import { createMockOidc, type ParamsOfCreateMockOidc } from "./oidc";
 import type { ValueOrAsyncGetter } from "../tools/ValueOrAsyncGetter";
 
@@ -7,5 +7,5 @@ export function createMockReactOidc<
     DecodedIdToken extends Record<string, unknown> = Record<string, unknown>,
     AutoLogin extends boolean = false
 >(params: ValueOrAsyncGetter<ParamsOfCreateMockOidc<DecodedIdToken, AutoLogin>>) {
-    return createOidcReactApi_dependencyInjection(params, createMockOidc);
+    return createReactOidc_dependencyInjection(params, createMockOidc);
 }

package/src/react/react.tsx

@@ -114,7 +114,7 @@ type OidcReactApi<DecodedIdToken extends Record<string, unknown>, AutoLogin exte
           }) => Promise<void | never>;
       });
 
-export function createOidcReactApi_dependencyInjection<
+export function createReactOidc_dependencyInjection<
     DecodedIdToken extends Record<string, unknown>,
     ParamsOfCreateOidc extends {
         autoLogin?: boolean;
@@ -140,11 +140,11 @@ export function createOidcReactApi_dependencyInjection<
     // NOTE: It can be InitializationError only if autoLogin is true
     const prOidcOrInitializationError = (async () => {
         const params = await (async () => {
+            await dReadyToCreate.pr;
+
             if (typeof paramsOrGetParams === "function") {
                 const getParams = paramsOrGetParams;
 
-                await dReadyToCreate.pr;
-
                 const params = await getParams();
 
                 return params;
@@ -439,7 +439,7 @@ export function createOidcReactApi_dependencyInjection<
         return oidc;
     }
 
-    const oidcReact: OidcReactApi<DecodedIdToken, false> = {
+    const oidcReactApi: OidcReactApi<DecodedIdToken, false> = {
         OidcProvider,
         useOidc: useOidc as any,
         getOidc,
@@ -448,7 +448,7 @@ export function createOidcReactApi_dependencyInjection<
     };
 
     // @ts-expect-error: We know what we are doing
-    return oidcReact;
+    return oidcReactApi;
 }
 
 /** @see: https://docs.oidc-spa.dev/v/v8/usage#react-api */
@@ -456,5 +456,5 @@ export function createReactOidc<
     DecodedIdToken extends Record<string, unknown> = Oidc.Tokens.DecodedIdToken_base,
     AutoLogin extends boolean = false
 >(params: ValueOrAsyncGetter<ParamsOfCreateOidc<DecodedIdToken, AutoLogin>>) {
-    return createOidcReactApi_dependencyInjection(params, createOidc);
+    return createReactOidc_dependencyInjection(params, createOidc);
 }

package/src/tools/INFINITY_TIME.ts

@@ -0,0 +1,2 @@
+// We do not use Infinity because it's not serializable.
+export const INFINITY_TIME = new Date("9999-12-31T23:59:59.999Z").getTime();

package/src/tools/readExpirationTimeInJwt.ts

@@ -1,5 +1,6 @@
 import { decodeJwt } from "./decodeJwt";
 import { assert } from "../vendor/frontend/tsafe";
+import { INFINITY_TIME } from "./INFINITY_TIME";
 
 // Return undefined if token provided wasn't a JWT or if it hasn't an exp claim number
 export function readExpirationTimeInJwt(token: string): number | undefined {
@@ -12,5 +13,9 @@ export function readExpirationTimeInJwt(token: string): number | undefined {
         return undefined;
     }
 
+    if (exp === 0) {
+        return INFINITY_TIME;
+    }
+
     return exp * 1000;
 }

package/tools/INFINITY_TIME.d.ts

@@ -0,0 +1 @@
+export declare const INFINITY_TIME: number;

package/tools/INFINITY_TIME.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INFINITY_TIME = void 0;
+// We do not use Infinity because it's not serializable.
+exports.INFINITY_TIME = new Date("9999-12-31T23:59:59.999Z").getTime();
+//# sourceMappingURL=INFINITY_TIME.js.map

package/tools/INFINITY_TIME.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"INFINITY_TIME.js","sourceRoot":"","sources":["../src/tools/INFINITY_TIME.ts"],"names":[],"mappings":";;;AAAA,wDAAwD;AAC3C,QAAA,aAAa,GAAG,IAAI,IAAI,CAAC,0BAA0B,CAAC,CAAC,OAAO,EAAE,CAAC"}

package/tools/readExpirationTimeInJwt.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readExpirationTimeInJwt = readExpirationTimeInJwt;
 const decodeJwt_1 = require("./decodeJwt");
 const tsafe_1 = require("../vendor/frontend/tsafe");
+const INFINITY_TIME_1 = require("./INFINITY_TIME");
 // Return undefined if token provided wasn't a JWT or if it hasn't an exp claim number
 function readExpirationTimeInJwt(token) {
     let exp;
@@ -13,6 +14,9 @@ function readExpirationTimeInJwt(token) {
     catch {
         return undefined;
     }
+    if (exp === 0) {
+        return INFINITY_TIME_1.INFINITY_TIME;
+    }
     return exp * 1000;
 }
 //# sourceMappingURL=readExpirationTimeInJwt.js.map

package/tools/readExpirationTimeInJwt.js.map

@@ -1 +1 @@
-{"version":3,"file":"readExpirationTimeInJwt.js","sourceRoot":"","sources":["../src/tools/readExpirationTimeInJwt.ts"],"names":[],"mappings":";;AAIA,0DAWC;AAfD,2CAAwC;AACxC,oDAAkD;AAElD,sFAAsF;AACtF,SAAgB,uBAAuB,CAAC,KAAa;IACjD,IAAI,GAAW,CAAC;IAEhB,IAAI,CAAC;QACD,GAAG,GAAG,IAAA,qBAAS,EAAkB,KAAK,CAAC,CAAC,GAAG,CAAC;QAC5C,IAAA,cAAM,EAAC,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC;IACpC,CAAC;IAAC,MAAM,CAAC;QACL,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,OAAO,GAAG,GAAG,IAAI,CAAC;AACtB,CAAC"}
+{"version":3,"file":"readExpirationTimeInJwt.js","sourceRoot":"","sources":["../src/tools/readExpirationTimeInJwt.ts"],"names":[],"mappings":";;AAKA,0DAeC;AApBD,2CAAwC;AACxC,oDAAkD;AAClD,mDAAgD;AAEhD,sFAAsF;AACtF,SAAgB,uBAAuB,CAAC,KAAa;IACjD,IAAI,GAAW,CAAC;IAEhB,IAAI,CAAC;QACD,GAAG,GAAG,IAAA,qBAAS,EAAkB,KAAK,CAAC,CAAC,GAAG,CAAC;QAC5C,IAAA,cAAM,EAAC,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC;IACpC,CAAC;IAAC,MAAM,CAAC;QACL,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,IAAI,GAAG,KAAK,CAAC,EAAE,CAAC;QACZ,OAAO,6BAAa,CAAC;IACzB,CAAC;IAED,OAAO,GAAG,GAAG,IAAI,CAAC;AACtB,CAAC"}