#169 #170 #32

examples/tanstack-start/src/routeTree.gen.ts

@@ -88,7 +88,7 @@ export interface FileRoutesByFullPath {
   '/demo/start/ssr/data-only': typeof DemoStartSsrDataOnlyRoute
   '/demo/start/ssr/full-ssr': typeof DemoStartSsrFullSsrRoute
   '/demo/start/ssr/spa-mode': typeof DemoStartSsrSpaModeRoute
-  '/demo/start/ssr': typeof DemoStartSsrIndexRoute
+  '/demo/start/ssr/': typeof DemoStartSsrIndexRoute
 }
 export interface FileRoutesByTo {
   '/': typeof IndexRoute
@@ -130,7 +130,7 @@ export interface FileRouteTypes {
     | '/demo/start/ssr/data-only'
     | '/demo/start/ssr/full-ssr'
     | '/demo/start/ssr/spa-mode'
-    | '/demo/start/ssr'
+    | '/demo/start/ssr/'
   fileRoutesByTo: FileRoutesByTo
   to:
     | '/'
@@ -227,7 +227,7 @@ declare module '@tanstack/react-router' {
     '/demo/start/ssr/': {
       id: '/demo/start/ssr/'
       path: '/demo/start/ssr'
-      fullPath: '/demo/start/ssr'
+      fullPath: '/demo/start/ssr/'
       preLoaderRoute: typeof DemoStartSsrIndexRouteImport
       parentRoute: typeof rootRouteImport
     }

package.json

@@ -1,6 +1,6 @@
 {
     "name": "oidc-spa",
-    "version": "10.2.0",
+    "version": "10.3.0-rc.1",
     "description": "OpenID Connect / OAuth2 solution for client-first Web Applications",
     "repository": {
         "type": "git",

src/core/createOidc.ts

@@ -266,13 +266,44 @@ export type ParamsOfCreateOidc<
     disableDPoP?: true;
 };
 
-const globalContext = {
-    prOidcByConfigId: new Map<string, Promise<Oidc<any>>>(),
-    hasLogoutBeenCalled: id<boolean>(false),
-    dExports_earlyInit: new Deferred<Exports_earlyInit>(),
-    dExports_tokenSubstitution: new Deferred<Exports_tokenSubstitution>(),
-    dExports_DPoP: new Deferred<Exports_DPoP>()
+declare global {
+    interface Window {
+        "__oidc-spa:globalContext:createOidc": {
+            dEarlyInitResolved: Deferred<void>;
+            actual:
+                | {
+                      prOidcByConfigId: Map<string, Promise<Oidc<any>>>;
+                      hasLogoutBeenCalled: boolean;
+                      dExports_earlyInit: Deferred<Exports_earlyInit>;
+                      dExports_tokenSubstitution: Deferred<Exports_tokenSubstitution>;
+                      dExports_DPoP: Deferred<Exports_DPoP>;
+                  }
+                | undefined
+                | null;
+        };
+    }
+}
+
+window["__oidc-spa:globalContext:createOidc"] ??= {
+    dEarlyInitResolved: new Deferred(),
+    actual: undefined
 };
+const globalContext = window["__oidc-spa:globalContext:createOidc"];
+
+const globalContext_actual_moduleScoped: NonNullable<
+    Window["__oidc-spa:globalContext:createOidc"]["actual"]
+> = {
+    prOidcByConfigId: new Map(),
+    hasLogoutBeenCalled: false,
+    dExports_earlyInit: new Deferred(),
+    dExports_tokenSubstitution: new Deferred(),
+    dExports_DPoP: new Deferred()
+};
+
+function getGlobalContextActual(): NonNullable<Window["__oidc-spa:globalContext:createOidc"]["actual"]> {
+    assert(globalContext.actual !== undefined);
+    return globalContext.actual ?? globalContext_actual_moduleScoped;
+}
 
 export type Exports_earlyInit =
     | { shouldLoadApp: false }
@@ -287,8 +318,21 @@ export type Exports_earlyInit =
           sessionRestorationMethod: "iframe" | "full page redirect" | "auto" | undefined;
       };
 
-export function registerExports_earlyInit(exports: Exports_earlyInit): void {
-    globalContext.dExports_earlyInit.resolve(exports);
+export function registerExports_earlyInit(params: {
+    exports: Exports_earlyInit;
+    isMicroFrontendSetup: boolean;
+}): void {
+    const { exports, isMicroFrontendSetup } = params;
+
+    if (globalContext.actual !== undefined) {
+        throw new Error("oidc-spa: Wrong micro frontend setup");
+    }
+
+    globalContext.actual = isMicroFrontendSetup ? globalContext_actual_moduleScoped : null;
+
+    globalContext.dEarlyInitResolved.resolve();
+
+    globalContext_actual_moduleScoped.dExports_earlyInit.resolve(exports);
 }
 
 export type Exports_tokenSubstitution = {
@@ -307,7 +351,7 @@ export namespace Exports_tokenSubstitution {
 }
 
 export function registerExports_tokenSubstitution(exports: Exports_tokenSubstitution): void {
-    globalContext.dExports_tokenSubstitution.resolve(exports);
+    globalContext_actual_moduleScoped.dExports_tokenSubstitution.resolve(exports);
 }
 
 export type Exports_DPoP = {
@@ -339,7 +383,7 @@ export namespace Exports_DPoP {
 }
 
 export function registerExports_DPoP(exports: Exports_DPoP): void {
-    globalContext.dExports_DPoP.resolve(exports);
+    globalContext_actual_moduleScoped.dExports_DPoP.resolve(exports);
 }
 
 /** @see: https://docs.oidc-spa.dev/v/v10/usage */
@@ -360,6 +404,14 @@ export async function createOidc<
 
     const { issuerUri: issuerUri_params, clientId, debugLogs, ...rest } = params;
 
+    {
+        const { dEarlyInitResolved } = globalContext;
+
+        if (!dEarlyInitResolved.getState().hasResolved) {
+            await dEarlyInitResolved.pr;
+        }
+    }
+
     const issuerUri = toFullyQualifiedUrl({
         urlish: issuerUri_params,
         doAssertNoQueryParams: true,
@@ -384,7 +436,7 @@ export async function createOidc<
 
     const configId = getConfigId({ issuerUri, clientId });
 
-    const { prOidcByConfigId } = globalContext;
+    const { prOidcByConfigId } = getGlobalContextActual();
 
     use_previous_instance: {
         const prOidc = prOidcByConfigId.get(configId);
@@ -464,7 +516,7 @@ export async function createOidc_nonMemoized<
             );
         }, 3_000);
 
-        const exports_earlyInit = await globalContext.dExports_earlyInit.pr;
+        const exports_earlyInit = await getGlobalContextActual().dExports_earlyInit.pr;
 
         window.clearTimeout(timer);
 
@@ -484,9 +536,10 @@ export async function createOidc_nonMemoized<
     const sessionRestorationMethod =
         sessionRestorationMethod_params ?? sessionRestorationMethod_earlyInit ?? "auto";
 
-    const { value: exports_tokenSubstitution } = globalContext.dExports_tokenSubstitution.getState();
+    const { value: exports_tokenSubstitution } =
+        getGlobalContextActual().dExports_tokenSubstitution.getState();
 
-    const { value: exports_DPoP } = globalContext.dExports_DPoP.getState();
+    const { value: exports_DPoP } = getGlobalContextActual().dExports_DPoP.getState();
 
     const scopes = Array.from(new Set(["openid", ...(params.scopes ?? ["profile"])]));
 
@@ -1532,12 +1585,12 @@ export async function createOidc_nonMemoized<
         },
         getDecodedIdToken: () => currentTokens.decodedIdToken,
         logout: async params => {
-            if (globalContext.hasLogoutBeenCalled) {
+            if (getGlobalContextActual().hasLogoutBeenCalled) {
                 log?.("logout() has already been called, ignoring the call");
                 return new Promise<never>(() => {});
             }
 
-            globalContext.hasLogoutBeenCalled = true;
+            getGlobalContextActual().hasLogoutBeenCalled = true;
 
             const rootRelativePostLogoutRedirectUrl: string = (() => {
                 switch (params.redirectTo) {

src/core/earlyInit.ts

@@ -58,6 +58,9 @@ export type ParamsOfEarlyInit = {
         enableDPoP?: () => void;
         enableTokenSubstitution?: () => void;
     };
+
+    /** Default: false */
+    isMicroFrontendSetup?: boolean;
 };
 
 let shouldLoadApp: boolean | undefined = undefined;
@@ -73,7 +76,12 @@ export function oidcEarlyInit(params?: ParamsOfEarlyInit) {
 }
 
 function oidcEarlyInit_nonMemoized(params: ParamsOfEarlyInit | undefined) {
-    const { BASE_URL, sessionRestorationMethod, securityDefenses = {} } = params ?? {};
+    const {
+        BASE_URL,
+        sessionRestorationMethod,
+        securityDefenses = {},
+        isMicroFrontendSetup = false
+    } = params ?? {};
 
     if (!isBrowser) {
         return { shouldLoadApp: true };
@@ -185,7 +193,7 @@ function oidcEarlyInit_nonMemoized(params: ParamsOfEarlyInit | undefined) {
     }
 
     prModuleCreateOidc.then(({ registerExports_earlyInit }) => {
-        registerExports_earlyInit(exports_earlyInit);
+        registerExports_earlyInit({ exports: exports_earlyInit, isMicroFrontendSetup });
     });
 
     return { shouldLoadApp };

src/core/evtIsUserActive.ts

@@ -3,11 +3,22 @@ import { subscribeToUserInteraction } from "../tools/subscribeToUserInteraction"
 import { assert, is } from "../tools/tsafe/assert";
 import { id } from "../tools/tsafe/id";
 
-const globalContext = {
+declare global {
+    interface Window {
+        "__oidc-spa:globalContext:evtIsUserActive": {
+            appInstanceId: string;
+            evtIsUserActiveBySessionId: Map<string, NonPostableEvt<EventData>>;
+        };
+    }
+}
+
+window["__oidc-spa:globalContext:evtIsUserActive"] ??= {
     appInstanceId: Math.random().toString(36).slice(2),
     evtIsUserActiveBySessionId: new Map<string, NonPostableEvt<EventData>>()
 };
 
+const globalContext = window["__oidc-spa:globalContext:evtIsUserActive"];
+
 type EventData = { isUserActive: true } | { isUserActive: false; hasBeenInactiveForHowLongMs: number };
 
 export function createEvtIsUserActive(params: {

src/core/loginOrGoToAuthServer.ts

@@ -4,16 +4,26 @@ import { assert, type Equals } from "../tools/tsafe/assert";
 import { noUndefined } from "../tools/tsafe/noUndefined";
 import type { StateData } from "./StateData";
 import type { NonPostableEvt } from "../tools/Evt";
-import { createStatefulEvt } from "../tools/StatefulEvt";
+import { createStatefulEvt, StatefulEvt } from "../tools/StatefulEvt";
 import { Deferred } from "../tools/Deferred";
 import { addOrUpdateSearchParam, getAllSearchParams } from "../tools/urlSearchParams";
 import { getIsOnline } from "../tools/getIsOnline";
 import { setStateDataCookieIfEnabled } from "./StateDataCookie";
 
-const globalContext = {
+declare global {
+    interface Window {
+        "__oidc-spa:globalContext:loginOrGoToAuthServer": {
+            evtHasLoginBeenCalled: StatefulEvt<boolean>;
+        };
+    }
+}
+
+window["__oidc-spa:globalContext:loginOrGoToAuthServer"] ??= {
     evtHasLoginBeenCalled: createStatefulEvt(() => false)
 };
 
+const globalContext = window["__oidc-spa:globalContext:loginOrGoToAuthServer"];
+
 type Params = Params.Login | Params.GoToAuthServer;
 
 namespace Params {

src/core/loginPropagationToOtherTabs.ts

@@ -1,10 +1,20 @@
 import { assert, is } from "../tools/tsafe/assert";
 import { Deferred } from "../tools/Deferred";
 
-const globalContext = {
+declare global {
+    interface Window {
+        "__oidc-spa.createOidc.loginPropagationToOtherTabs": {
+            appInstanceId: string;
+        };
+    }
+}
+
+window["__oidc-spa.createOidc.loginPropagationToOtherTabs"] ??= {
     appInstanceId: Math.random().toString(36).slice(2)
 };
 
+const globalContext = window["__oidc-spa.createOidc.loginPropagationToOtherTabs"];
+
 type Message = {
     appInstanceId: string;
     configId: string;

src/core/logoutPropagationToOtherTabs.ts

@@ -1,10 +1,20 @@
 import { assert, is } from "../tools/tsafe/assert";
 import { Deferred } from "../tools/Deferred";
 
-const globalContext = {
+declare global {
+    interface Window {
+        "__oidc-spa:globalContext:logoutPropagationToOtherTabs": {
+            appInstanceId: string;
+        };
+    }
+}
+
+window["__oidc-spa:globalContext:logoutPropagationToOtherTabs"] ??= {
     appInstanceId: Math.random().toString(36).slice(2)
 };
 
+const globalContext = window["__oidc-spa:globalContext:logoutPropagationToOtherTabs"];
+
 type Message = {
     appInstanceId: string;
     configId: string;

src/core/ongoingLoginOrRefreshProcesses.ts

@@ -1,12 +1,22 @@
 import { Deferred } from "../tools/Deferred";
 import { assert } from "../tools/tsafe/assert";
-import { id } from "../tools/tsafe/id";
 
-const globalContext = {
-    prDone_arr: id<Promise<void>[]>([]),
-    prUnlock: id<Promise<void>>(Promise.resolve())
+declare global {
+    interface Window {
+        "__oidc-spa:globalContext:ongoingLoginOrRefreshProcesses": {
+            prDone_arr: Promise<void>[];
+            prUnlock: Promise<void>;
+        };
+    }
+}
+
+window["__oidc-spa:globalContext:ongoingLoginOrRefreshProcesses"] ??= {
+    prDone_arr: [],
+    prUnlock: Promise.resolve()
 };
 
+const globalContext = window["__oidc-spa:globalContext:ongoingLoginOrRefreshProcesses"];
+
 export async function startLoginOrRefreshProcess(): Promise<{
     completeLoginOrRefreshProcess: () => void;
 }> {