oidc-spa 3.0.2 → 4.0.0

package/src/react.tsx

@@ -1,23 +1,48 @@
-import {
-    useEffect,
-    useState,
-    createContext,
-    useContext,
-    useReducer,
-    useMemo,
-    type ReactNode
-} from "react";
-import { createOidc, type Oidc } from "./oidc";
+import { useEffect, useState, createContext, useContext, useReducer, type ReactNode } from "react";
+import { createOidc, type ParamsOfCreateOidc, type Oidc } from "./oidc";
 import { assert } from "tsafe/assert";
-import { decodeJwt } from "./tools/decodeJwt";
 import { id } from "tsafe/id";
+import { useGuaranteedMemo } from "./tools/powerhooks/useGuaranteedMemo";
 
-const oidcContext = createContext<Oidc | undefined>(undefined);
+export type OidcReact<DecodedIdToken extends Record<string, unknown>> =
+    | OidcReact.NotLoggedIn
+    | OidcReact.LoggedIn<DecodedIdToken>;
+
+export namespace OidcReact {
+    export type Common = Oidc.Common;
+
+    export type NotLoggedIn = Common & {
+        isUserLoggedIn: false;
+        login: Oidc.NotLoggedIn["login"];
+        oidcTokens?: never;
+        logout?: never;
+    };
+
+    export type LoggedIn<DecodedIdToken extends Record<string, unknown>> = Common & {
+        isUserLoggedIn: true;
+        oidcTokens: Oidc.Tokens<DecodedIdToken>;
+        logout: Oidc.LoggedIn["logout"];
+        renewTokens: Oidc.LoggedIn["renewTokens"];
+        login?: never;
+    };
+}
+
+const oidcContext = createContext<
+    | {
+          oidc: Oidc;
+          decodedIdTokenSchema: ParamsOfCreateOidc["decodedIdTokenSchema"];
+      }
+    | undefined
+>(undefined);
 
 /** @see: https://github.com/garronej/oidc-spa#option-2-usage-directly-within-react */
-export function createOidcProvider(params: Parameters<typeof createOidc>[0]) {
+export function createReactOidc<
+    DecodedIdToken extends Record<string, unknown> = Record<string, unknown>
+>(params: ParamsOfCreateOidc<DecodedIdToken>) {
     const prOidc = createOidc(params);
 
+    const { decodedIdTokenSchema } = params;
+
     function OidcProvider(props: { fallback?: ReactNode; children: ReactNode }) {
         const { children, fallback } = props;
 
@@ -31,50 +56,25 @@ export function createOidcProvider(params: Parameters<typeof createOidc>[0]) {
             return <>{fallback === undefined ? null : fallback}</>;
         }
 
-        return <oidcContext.Provider value={oidc}>{children}</oidcContext.Provider>;
+        return (
+            <oidcContext.Provider value={{ oidc, decodedIdTokenSchema }}>
+                {children}
+            </oidcContext.Provider>
+        );
     }
 
-    return { OidcProvider, prOidc };
-}
-
-export type ReactiveOidc<DecodedIdToken extends Record<string, unknown>> =
-    | ReactiveOidc.NotLoggedIn
-    | ReactiveOidc.LoggedIn<DecodedIdToken>;
-
-export namespace ReactiveOidc {
-    export type Common = Oidc.Common;
-
-    export type NotLoggedIn = Common & {
-        isUserLoggedIn: false;
-        login: Oidc.NotLoggedIn["login"];
-        oidcTokens: undefined;
-        logout: undefined;
-    };
-
-    export type LoggedIn<DecodedIdToken extends Record<string, unknown>> = Common & {
-        isUserLoggedIn: true;
-        oidcTokens: ReturnType<Oidc.LoggedIn["getTokens"]> & {
-            decodedIdToken: DecodedIdToken;
-        };
-        logout: Oidc.LoggedIn["logout"];
-        renewTokens: Oidc.LoggedIn["renewTokens"];
-        login: undefined;
-    };
-}
-
-export function createUseOidc<
-    DecodedOidcIdToken extends Record<string, unknown> = Record<string, unknown>
->(params?: { decodedIdTokenSchema?: { parse: (data: unknown) => DecodedOidcIdToken } }) {
-    const { decodedIdTokenSchema } = params ?? {};
-
-    function useOidc(params?: { assertUserLoggedIn: false }): ReactiveOidc<DecodedOidcIdToken>;
-    function useOidc(params: { assertUserLoggedIn: true }): ReactiveOidc.LoggedIn<DecodedOidcIdToken>;
-    function useOidc(params?: { assertUserLoggedIn: boolean }): ReactiveOidc<DecodedOidcIdToken> {
+    function useOidc(params?: { assertUserLoggedIn: false }): OidcReact<DecodedIdToken>;
+    function useOidc(params: { assertUserLoggedIn: true }): OidcReact.LoggedIn<DecodedIdToken>;
+    function useOidc(params?: { assertUserLoggedIn: boolean }): OidcReact<DecodedIdToken> {
         const { assertUserLoggedIn = false } = params ?? {};
 
-        const oidc = useContext(oidcContext);
+        const { oidc, decodedIdTokenSchema: decodedIdTokenSchema_context } = (function useClosure() {
+            const context = useContext(oidcContext);
+
+            assert(context !== undefined, "You must use useOidc inside a OidcProvider");
 
-        assert(oidc !== undefined, "You must use useOidc inside a OidcProvider");
+            return context;
+        })();
 
         const [, forceUpdate] = useReducer(() => [], []);
 
@@ -94,46 +94,79 @@ export function createUseOidc<
             );
         }
 
-        const tokens = oidc.isUserLoggedIn ? oidc.getTokens() : undefined;
-
-        const decodedIdToken = useMemo(() => {
-            if (tokens?.idToken === undefined) {
-                return undefined;
-            }
-
-            const decodedIdToken = decodeJwt(tokens.idToken) as DecodedOidcIdToken;
-
-            if (decodedIdTokenSchema !== undefined) {
-                decodedIdTokenSchema.parse(decodeJwt(tokens.idToken));
-            }
-
-            return decodedIdToken;
-        }, [tokens?.idToken]);
-
-        const common: ReactiveOidc.Common = {
+        const { oidcTokens } = (function useClosure() {
+            const tokens = oidc.isUserLoggedIn ? oidc.getTokens() : undefined;
+
+            const oidcTokens = useGuaranteedMemo(() => {
+                if (tokens === undefined) {
+                    return undefined;
+                }
+
+                const oidcTokens: Oidc.Tokens<DecodedIdToken> = {
+                    "accessToken": tokens.accessToken,
+                    "accessTokenExpirationTime": tokens.accessTokenExpirationTime,
+                    "idToken": tokens.idToken,
+                    "refreshToken": tokens.refreshToken,
+                    "refreshTokenExpirationTime": tokens.refreshTokenExpirationTime,
+                    "decodedIdToken": null as any
+                };
+
+                let cache: { decodedIdToken: Record<string, unknown> } | undefined = undefined;
+
+                Object.defineProperty(oidcTokens, "decodedIdToken", {
+                    "get": () => {
+                        if (cache !== undefined) {
+                            return cache.decodedIdToken;
+                        }
+
+                        let { decodedIdToken } = tokens;
+
+                        if (
+                            decodedIdTokenSchema !== undefined &&
+                            decodedIdTokenSchema !== decodedIdTokenSchema_context
+                        ) {
+                            decodedIdToken = decodedIdTokenSchema.parse(decodedIdToken);
+                        }
+
+                        cache = { decodedIdToken };
+
+                        return decodedIdToken;
+                    }
+                });
+
+                return oidcTokens;
+            }, [
+                tokens?.accessToken,
+                tokens?.accessTokenExpirationTime,
+                tokens?.idToken,
+                tokens?.refreshToken,
+                tokens?.refreshTokenExpirationTime
+            ]);
+
+            return { oidcTokens };
+        })();
+
+        const common: OidcReact.Common = {
             "params": oidc.params
         };
 
         return oidc.isUserLoggedIn
-            ? id<ReactiveOidc.LoggedIn<DecodedOidcIdToken>>({
-                  ...common,
-                  "isUserLoggedIn": true,
-                  "oidcTokens": {
-                      ...tokens!,
-                      "decodedIdToken": decodedIdToken!
-                  },
-                  "logout": oidc.logout,
-                  "renewTokens": oidc.renewTokens,
-                  "login": undefined
-              })
-            : id<ReactiveOidc.NotLoggedIn>({
+            ? id<OidcReact.LoggedIn<DecodedIdToken>>(
+                  (assert(oidcTokens !== undefined),
+                  {
+                      ...common,
+                      "isUserLoggedIn": true,
+                      oidcTokens,
+                      "logout": oidc.logout,
+                      "renewTokens": oidc.renewTokens
+                  })
+              )
+            : id<OidcReact.NotLoggedIn>({
                   ...common,
                   "isUserLoggedIn": false,
-                  "login": oidc.login,
-                  "oidcTokens": undefined,
-                  "logout": undefined
+                  "login": oidc.login
               });
     }
 
-    return { useOidc };
+    return { OidcProvider, useOidc, prOidc };
 }

package/src/tools/powerhooks/useGuaranteedMemo.ts

@@ -0,0 +1,18 @@
+import { useRef } from "react";
+
+export function useGuaranteedMemo<T>(fn: () => T, deps: readonly any[]): T {
+    const ref = useRef<{ v: T; prevDeps: any[] }>();
+
+    if (
+        !ref.current ||
+        deps.length !== ref.current.prevDeps.length ||
+        ref.current.prevDeps.map((v, i) => v === deps[i]).indexOf(false) >= 0
+    ) {
+        ref.current = {
+            "v": fn(),
+            "prevDeps": [...deps]
+        };
+    }
+
+    return ref.current.v;
+}

package/tools/powerhooks/useGuaranteedMemo.d.ts

@@ -0,0 +1 @@
+export declare function useGuaranteedMemo<T>(fn: () => T, deps: readonly any[]): T;

package/tools/powerhooks/useGuaranteedMemo.js

@@ -0,0 +1,43 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGuaranteedMemo = void 0;
+var react_1 = require("react");
+function useGuaranteedMemo(fn, deps) {
+    var ref = (0, react_1.useRef)();
+    if (!ref.current ||
+        deps.length !== ref.current.prevDeps.length ||
+        ref.current.prevDeps.map(function (v, i) { return v === deps[i]; }).indexOf(false) >= 0) {
+        ref.current = {
+            "v": fn(),
+            "prevDeps": __spreadArray([], __read(deps), false)
+        };
+    }
+    return ref.current.v;
+}
+exports.useGuaranteedMemo = useGuaranteedMemo;
+//# sourceMappingURL=useGuaranteedMemo.js.map

package/tools/powerhooks/useGuaranteedMemo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGuaranteedMemo.js","sourceRoot":"","sources":["../../src/tools/powerhooks/useGuaranteedMemo.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAA+B;AAE/B,SAAgB,iBAAiB,CAAI,EAAW,EAAE,IAAoB;IAClE,IAAM,GAAG,GAAG,IAAA,cAAM,GAA6B,CAAC;IAEhD,IACI,CAAC,GAAG,CAAC,OAAO;QACZ,IAAI,CAAC,MAAM,KAAK,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM;QAC3C,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAC,CAAC,EAAE,CAAC,IAAK,OAAA,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,EAAb,CAAa,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,EACvE,CAAC;QACC,GAAG,CAAC,OAAO,GAAG;YACV,GAAG,EAAE,EAAE,EAAE;YACT,UAAU,2BAAM,IAAI,SAAC;SACxB,CAAC;IACN,CAAC;IAED,OAAO,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AACzB,CAAC;AAfD,8CAeC"}