oidc-spa 8.1.14 → 8.2.0

package/src/react-spa/types.tsx

@@ -0,0 +1,308 @@
+import type { ReactNode, ComponentType } from "react";
+import type { Oidc as Oidc_core, OidcInitializationError } from "../core";
+import type { OidcMetadata } from "../core/OidcMetadata";
+
+export type UseOidc<DecodedIdToken> = {
+    (params?: { assert?: undefined }): UseOidc.Oidc<DecodedIdToken>;
+    (params: { assert: "user logged in" }): UseOidc.Oidc.LoggedIn<DecodedIdToken>;
+    (params: { assert: "user not logged in" }): UseOidc.Oidc.NotLoggedIn;
+};
+
+export namespace UseOidc {
+    export type WithAutoLogin<DecodedIdToken> = (params?: {
+        assert: "user logged in";
+    }) => Oidc.LoggedIn<DecodedIdToken>;
+
+    export type Oidc<DecodedIdToken> =
+        | (Oidc.NotLoggedIn & {
+              decodedIdToken?: never;
+              logout?: never;
+              renewTokens?: never;
+              goToAuthServer?: never;
+              backFromAuthServer?: never;
+              isNewBrowserSession?: never;
+          })
+        | (Oidc.LoggedIn<DecodedIdToken> & {
+              login?: never;
+              initializationError?: never;
+          });
+
+    export namespace Oidc {
+        type Common = {
+            issuerUri: string;
+            clientId: string;
+        };
+
+        export type NotLoggedIn = Common & {
+            login: (params?: {
+                extraQueryParams?: Record<string, string | undefined>;
+                redirectUrl?: string;
+                transformUrlBeforeRedirect?: (url: string) => string;
+            }) => Promise<never>;
+            autoLogoutState: {
+                shouldDisplayWarning: false;
+            };
+            isUserLoggedIn: false;
+            initializationError: OidcInitializationError | undefined;
+        };
+
+        export type LoggedIn<DecodedIdToken> = Common & {
+            isUserLoggedIn: true;
+            decodedIdToken: DecodedIdToken;
+            logout: Oidc_core.LoggedIn["logout"];
+            renewTokens: Oidc_core.LoggedIn["renewTokens"];
+            goToAuthServer: Oidc_core.LoggedIn["goToAuthServer"];
+            backFromAuthServer: Oidc_core.LoggedIn["backFromAuthServer"];
+            isNewBrowserSession: boolean;
+            autoLogoutState:
+                | {
+                      shouldDisplayWarning: true;
+                      secondsLeftBeforeAutoLogout: number;
+                  }
+                | {
+                      shouldDisplayWarning: false;
+                  };
+        };
+    }
+}
+
+export type GetOidc<DecodedIdToken> = {
+    (params?: { assert?: undefined }): Promise<GetOidc.Oidc<DecodedIdToken>>;
+    (params: { assert: "user logged in" }): Promise<GetOidc.Oidc.LoggedIn<DecodedIdToken>>;
+    (params: { assert: "user not logged in" }): Promise<GetOidc.Oidc.NotLoggedIn>;
+};
+
+export namespace GetOidc {
+    export type WithAutoLogin<DecodedIdToken> = (params?: {
+        assert: "user logged in";
+    }) => Promise<Oidc.LoggedIn<DecodedIdToken>>;
+
+    export type Oidc<DecodedIdToken> =
+        | (Oidc.NotLoggedIn & {
+              getAccessToken?: never;
+              getDecodedIdToken?: never;
+              logout?: never;
+              renewTokens?: never;
+              goToAuthServer?: never;
+              backFromAuthServer?: never;
+              isNewBrowserSession?: never;
+              subscribeToAutoLogoutState?: never;
+          })
+        | (Oidc.LoggedIn<DecodedIdToken> & {
+              initializationError?: never;
+              login?: never;
+          });
+
+    export namespace Oidc {
+        type Common = {
+            issuerUri: string;
+            clientId: string;
+        };
+
+        export type NotLoggedIn = Common & {
+            isUserLoggedIn: false;
+            initializationError: OidcInitializationError | undefined;
+            login: Oidc_core.NotLoggedIn["login"];
+        };
+
+        export type LoggedIn<DecodedIdToken> = Common & {
+            isUserLoggedIn: true;
+            getAccessToken: () => Promise<string>;
+            getDecodedIdToken: () => DecodedIdToken;
+            logout: Oidc_core.LoggedIn["logout"];
+            renewTokens: Oidc_core.LoggedIn["renewTokens"];
+            goToAuthServer: Oidc_core.LoggedIn["goToAuthServer"];
+            backFromAuthServer: Oidc_core.LoggedIn["backFromAuthServer"];
+            isNewBrowserSession: boolean;
+            subscribeToAutoLogoutState: (
+                next: (
+                    autoLogoutState:
+                        | {
+                              shouldDisplayWarning: true;
+                              secondsLeftBeforeAutoLogout: number;
+                          }
+                        | {
+                              shouldDisplayWarning: false;
+                          }
+                ) => void
+            ) => { unsubscribeFromAutoLogoutState: () => void };
+        };
+    }
+}
+
+export type ParamsOfBootstrap<AutoLogin, DecodedIdToken> =
+    | ParamsOfBootstrap.Real<AutoLogin>
+    | ParamsOfBootstrap.Mock<AutoLogin, DecodedIdToken>;
+
+export namespace ParamsOfBootstrap {
+    export type Real<AutoLogin> = {
+        implementation: "real";
+
+        /**
+         * See: https://docs.oidc-spa.dev/v/v8/providers-configuration/provider-configuration
+         */
+        issuerUri: string;
+        /**
+         * See: https://docs.oidc-spa.dev/v/v8/providers-configuration/provider-configuration
+         */
+        clientId: string;
+
+        /**
+         * Default: 45 second.
+         * It defines how long before the auto logout we should start
+         * displaying an overlay message to the user alerting them
+         * like: "Are you still there? You'll be disconnected in 45...44..."
+         * NOTE: This parameter is only UI related! It does not defines
+         * after how much time of inactivity the user should be auto logged out.
+         * This is a server policy (that can be overwrote by idleSessionLifetimeInSeconds)
+         * See: https://docs.oidc-spa.dev/v/v8/auto-logout
+         */
+        startCountdownSecondsBeforeAutoLogout?: number;
+        /**
+         * 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.
+         * Some provider however don't issue a refresh token or do not correctly set the
+         * expiration time. This parameter enable you to hard code the value to compensate
+         * the shortcoming of your auth server.
+         * */
+        idleSessionLifetimeInSeconds?: number;
+
+        /**
+         * The scopes being requested from the OIDC/OAuth2 provider (default: `["profile"]`
+         * (the scope "openid" is added automatically as it's mandatory)
+         **/
+        scopes?: string[];
+
+        /**
+         * Transform the url (authorization endpoint) before redirecting to the login pages.
+         *
+         * The isSilent parameter is true when the redirect is initiated in the background iframe for silent signin.
+         * This can be used to omit ui related query parameters (like `ui_locales`).
+         */
+        transformUrlBeforeRedirect?: (params: { authorizationUrl: string; isSilent: boolean }) => string;
+
+        /**
+         * Extra query params to be added to the authorization endpoint url before redirecting or silent signing in.
+         * You can provide a function that returns those extra query params, it will be called
+         * when login() is called.
+         *
+         * Example: extraQueryParams: ()=> ({ ui_locales: "fr" })
+         *
+         * This parameter can also be passed to login() directly.
+         */
+        extraQueryParams?:
+            | Record<string, string | undefined>
+            | ((params: { isSilent: boolean; url: string }) => Record<string, string | undefined>);
+        /**
+         * Extra body params to be added to the /token POST request.
+         *
+         * It will be used when for the initial request, whenever the token is getting refreshed and if you call `renewTokens()`.
+         * You can also provide this parameter directly to the `renewTokens()` method.
+         *
+         * It can be either a string to string record or a function that returns a string to string record.
+         *
+         * Example: extraTokenParams: ()=> ({ selectedCustomer: "xxx" })
+         *          extraTokenParams: { selectedCustomer: "xxx" }
+         */
+        extraTokenParams?:
+            | Record<string, string | undefined>
+            | (() => Record<string, string | undefined>);
+
+        /**
+         * Default: false
+         *
+         * See: https://docs.oidc-spa.dev/v/v8/resources/iframe-related-issues
+         */
+        noIframe?: boolean;
+
+        debugLogs?: boolean;
+
+        /**
+         * WARNING: This option exists solely as a workaround
+         * for limitations in the Google OAuth API.
+         * See: https://docs.oidc-spa.dev/providers-configuration/google-oauth
+         *
+         * Do not use this for other providers.
+         * If you think you need a client secret in a SPA, you are likely
+         * trying to use a confidential (private) client in the browser,
+         * which is insecure and not supported.
+         */
+        __unsafe_clientSecret?: string;
+
+        /**
+         * This option should only be used as a last resort.
+         *
+         * If your OIDC provider is correctly configured, this should not be necessary.
+         *
+         * The metadata is normally retrieved automatically from:
+         * `${issuerUri}/.well-known/openid-configuration`
+         *
+         * Use this only if that endpoint is not accessible (e.g. due to missing CORS headers
+         * or non-standard deployments), and you cannot fix the server-side configuration.
+         */
+        __metadata?: Partial<OidcMetadata>;
+
+        /**
+         *  WARNING: Setting this to true is a workaround for provider
+         *  like Google OAuth that don't support JWT access token.
+         *  Use at your own risk, this is a hack.
+         */
+        __unsafe_useIdTokenAsAccessToken?: boolean;
+
+        /**
+         * Let's you override the params passed to
+         * (if you weren't able to provide it)
+         */
+        BASE_URL?: string;
+    } & (AutoLogin extends true ? {} : {});
+
+    export type Mock<AutoLogin, DecodedIdToken> = {
+        implementation: "mock";
+        issuerUri_mock?: string;
+        clientId_mock?: string;
+        decodedIdToken_mock?: DecodedIdToken;
+
+        /**
+         * Let's you override the params passed to
+         * (if you weren't able to provide it)
+         */
+        BASE_URL?: string;
+    } & (AutoLogin extends true
+        ? {
+              isUserInitiallyLoggedIn?: true;
+          }
+        : {
+              isUserInitiallyLoggedIn: boolean;
+          });
+}
+
+export type OidcSpaApi<AutoLogin, DecodedIdToken> = {
+    bootstrapOidc: (params: ParamsOfBootstrap<AutoLogin, DecodedIdToken>) => void;
+    useOidc: AutoLogin extends true ? UseOidc.WithAutoLogin<DecodedIdToken> : UseOidc<DecodedIdToken>;
+    getOidc: AutoLogin extends true ? GetOidc.WithAutoLogin<DecodedIdToken> : GetOidc<DecodedIdToken>;
+} & (AutoLogin extends true
+    ? {
+          OidcInitializationErrorGate: (props: {
+              errorComponent: ComponentType<{
+                  oidcInitializationError: OidcInitializationError;
+              }>;
+              children: ReactNode;
+          }) => ReactNode;
+      }
+    : {
+          enforceLogin: (loaderContext: {
+              request?: { url?: string };
+              cause?: "preload" | string;
+              location?: {
+                  href?: string;
+              };
+          }) => Promise<void | never>;
+
+          withLoginEnforced: <Props extends Record<string, unknown>>(
+              component: ComponentType<Props>
+          ) => (props: Props) => ReactNode;
+      });

package/src/tanstack-start/react/apiBuilder.ts

@@ -61,7 +61,6 @@ export type OidcSpaApiBuilder<
                 ExcludedMethod | "withAccessTokenValidation"
             >;
         };
-
         finalize: () => OidcSpaApi<AutoLogin, DecodedIdToken, AccessTokenClaims>;
     },
     ExcludedMethod

package/src/tanstack-start/react/createOidcSpaApi.tsx

@@ -1,4 +1,11 @@
-import { useState, useEffect, type ReactNode, createContext, useContext } from "react";
+import {
+    useState,
+    useEffect,
+    type ReactNode,
+    createContext,
+    useContext,
+    type ComponentType
+} from "react";
 import type {
     CreateValidateAndGetAccessTokenClaims,
     OidcSpaApi,
@@ -13,7 +20,6 @@ import { OidcInitializationError } from "../../core/OidcInitializationError";
 import { Deferred } from "../../tools/Deferred";
 import { isBrowser } from "../../tools/isBrowser";
 import { assert, type Equals, is } from "../../tools/tsafe/assert";
-import { infer_import_meta_env_BASE_URL } from "../../tools/infer_import_meta_env_BASE_URL";
 import { createObjectThatThrowsIfAccessed } from "../../tools/createObjectThatThrowsIfAccessed";
 import { createStatefulEvt } from "../../tools/StatefulEvt";
 import { id } from "../../tools/tsafe/id";
@@ -610,7 +616,6 @@ export function createOidcSpaApi<
                         const { createMockOidc } = await import("../../mock/oidc");
 
                         const oidcCore = await createMockOidc({
-                            homeUrl: infer_import_meta_env_BASE_URL(),
                             // NOTE: The `as false` is lying here, it's just to preserve some level of type-safety.
                             autoLogin: autoLogin as false,
                             // NOTE: Same here, the nullish coalescing is lying.
@@ -641,15 +646,12 @@ export function createOidcSpaApi<
                     {
                         const { createOidc } = await prModuleCore;
 
-                        const homeUrl = infer_import_meta_env_BASE_URL();
-
                         let oidcCoreOrInitializationError:
                             | Oidc_core<DecodedIdToken>
                             | OidcInitializationError;
 
                         try {
                             oidcCoreOrInitializationError = await createOidc({
-                                homeUrl,
                                 autoLogin,
                                 decodedIdTokenSchema,
                                 issuerUri: paramsOfBootstrap.issuerUri,
@@ -735,12 +737,11 @@ export function createOidcSpaApi<
     enforceLogin.__isOidcSpaEnforceLogin = true;
 
     function OidcInitializationGate(props: {
-        renderFallback: (props: {
-            initializationError: OidcInitializationError | undefined;
-        }) => ReactNode;
+        errorComponent?: ComponentType<{ oidcInitializationError: OidcInitializationError }>;
+        pendingComponent?: ComponentType<{}>;
         children: ReactNode;
     }): ReactNode {
-        const { renderFallback, children } = props;
+        const { errorComponent: ErrorComponent, pendingComponent: PendingComponent, children } = props;
 
         const [oidcCoreOrInitializationError, setOidcCoreOrInitializationError] = useState<
             Oidc_core<DecodedIdToken> | OidcInitializationError | undefined
@@ -761,18 +762,21 @@ export function createOidcSpaApi<
             };
         }, []);
 
-        if (
-            oidcCoreOrInitializationError === undefined ||
-            oidcCoreOrInitializationError instanceof OidcInitializationError
-        ) {
-            return renderFallback({ initializationError: oidcCoreOrInitializationError });
+        if (oidcCoreOrInitializationError === undefined) {
+            if (PendingComponent === undefined) {
+                return null;
+            }
+            return <PendingComponent />;
         }
 
-        return (
-            <context_isFreeOfSsrHydrationConcern.Provider value={true}>
-                {children}
-            </context_isFreeOfSsrHydrationConcern.Provider>
-        );
+        if (oidcCoreOrInitializationError instanceof OidcInitializationError) {
+            if (ErrorComponent === undefined) {
+                throw oidcCoreOrInitializationError;
+            }
+            return <ErrorComponent oidcInitializationError={oidcCoreOrInitializationError} />;
+        }
+
+        return children;
     }
 
     const prValidateAndGetAccessTokenClaims =

package/src/tanstack-start/react/types.tsx

@@ -1,4 +1,4 @@
-import type { ReactNode } from "react";
+import type { ReactNode, ComponentType } from "react";
 import type { Oidc as Oidc_core, OidcInitializationError } from "../../core";
 import type { FunctionMiddlewareAfterServer, RequestMiddlewareAfterServer } from "@tanstack/react-start";
 import type { GetterOrDirectValue } from "../../tools/GetterOrDirectValue";
@@ -390,9 +390,8 @@ export type OidcSpaApi<AutoLogin, DecodedIdToken, AccessTokenClaims> = {
     (AutoLogin extends true
         ? {
               OidcInitializationGate: (props: {
-                  renderFallback: (props: {
-                      initializationError: OidcInitializationError | undefined;
-                  }) => ReactNode;
+                  errorComponent?: ComponentType<{ oidcInitializationError: OidcInitializationError }>;
+                  pendingComponent?: ComponentType<{}>;
                   children: ReactNode;
               }) => ReactNode;
           }

package/src/vite-plugin/handleClientEntrypoint.ts

@@ -1,7 +1,6 @@
 import type { OidcSpaVitePluginParams } from "./vite-plugin";
 import type { ResolvedConfig } from "vite";
 import type { PluginContext } from "rollup";
-import { detectProjectType, ProjectType } from "./detectProjectType";
 import { existsSync } from "node:fs";
 import { promises as fs } from "node:fs";
 import * as path from "node:path";
@@ -9,6 +8,7 @@ import { fileURLToPath } from "node:url";
 import { normalizePath } from "vite";
 import { assert } from "../tools/tsafe/assert";
 import type { Equals } from "../tools/tsafe/Equals";
+import type { ProjectType } from "./projectType";
 
 type EntryResolution = {
     absolutePath: string;
@@ -32,10 +32,9 @@ const TANSTACK_ENTRY_CANDIDATES = ["client.tsx", "client.ts", "client.jsx", "cli
 export function createLoadHandleEntrypoint(params: {
     oidcSpaVitePluginParams: OidcSpaVitePluginParams;
     resolvedConfig: ResolvedConfig;
+    projectType: ProjectType;
 }) {
-    const { oidcSpaVitePluginParams, resolvedConfig } = params;
-
-    const projectType = detectProjectType({ resolvedConfig });
+    const { oidcSpaVitePluginParams, resolvedConfig, projectType } = params;
 
     const entryResolution = resolveEntryForProject({
         config: resolvedConfig,
@@ -82,7 +81,8 @@ export function createLoadHandleEntrypoint(params: {
             `    freezeFetch: ${freezeFetch},`,
             `    freezeXMLHttpRequest: ${freezeXMLHttpRequest},`,
             `    freezeWebSocket: ${freezeWebSocket},`,
-            `    isPostLoginRedirectManual: ${projectType === "tanstack-start"}`,
+            `    isPostLoginRedirectManual: ${projectType === "tanstack-start"},`,
+            `    BASE_URL: "${resolvedConfig.base}"`,
             `});`,
             ``,
             `if(shouldLoadApp){`,

package/src/vite-plugin/manageOptimizedDeps.ts

@@ -0,0 +1,64 @@
+import type { UserConfig } from "vite";
+import { getThisCodebaseRootDirPath } from "../tools/getThisCodebaseRootDirPath_cjs";
+import * as fs from "node:fs";
+import { join as pathJoin } from "path";
+import type { ProjectType } from "./projectType";
+import { assert } from "../tools/tsafe/assert";
+
+export function manageOptimizedDeps(params: {
+    userConfig: UserConfig;
+    projectType: ProjectType;
+}): UserConfig {
+    const { userConfig, projectType } = params;
+
+    if (projectType === "other") {
+        return userConfig;
+    }
+
+    const packageJsonParsed = JSON.parse(
+        fs.readFileSync(pathJoin(getThisCodebaseRootDirPath(), "package.json")).toString("utf8")
+    ) as { name: string; exports: Record<string, { module?: string }> };
+
+    const moduleNames = Object.entries(packageJsonParsed.exports)
+        .filter(([, value]) => value.module !== undefined)
+        .map(([key]) => key.replace(/^\./, packageJsonParsed.name));
+
+    switch (projectType) {
+        case "tanstack-start":
+            {
+                ((userConfig.optimizeDeps ??= {}).exclude ??= []).push(...moduleNames);
+            }
+            break;
+        case "react-router-framework":
+            {
+                const moduleNames_include = [
+                    "oidc-spa/react-spa",
+                    "oidc-spa/entrypoint",
+                    "oidc-spa/keycloak"
+                ];
+
+                for (const moduleName of moduleNames_include) {
+                    assert(moduleNames.includes(moduleName));
+                }
+
+                const isZodInstalled = (() => {
+                    try {
+                        require.resolve(`zod/package.json`);
+                    } catch {
+                        return false;
+                    }
+
+                    return true;
+                })();
+
+                if (isZodInstalled) {
+                    moduleNames_include.push("zod");
+                }
+
+                ((userConfig.optimizeDeps ??= {}).include ??= []).push(...moduleNames_include);
+            }
+            break;
+    }
+
+    return userConfig;
+}

package/src/vite-plugin/projectType.ts

@@ -0,0 +1,18 @@
+export type ProjectType = "tanstack-start" | "react-router-framework" | "other";
+
+export function getProjectType(params: { pluginNames: string[] }) {
+    const pluginNames = new Set(params.pluginNames);
+
+    if (pluginNames.has("tanstack-react-start:config")) {
+        return "tanstack-start";
+    }
+
+    if (
+        pluginNames.has("react-router") ||
+        Array.from(pluginNames).some(pluginName => pluginName.startsWith("react-router:"))
+    ) {
+        return "react-router-framework";
+    }
+
+    return "other";
+}

package/src/vite-plugin/vite-plugin.ts

@@ -1,34 +1,70 @@
-import type { Plugin } from "vite";
+import type { Plugin, TransformResult } from "vite";
 import { assert } from "../tools/tsafe/assert";
 import type { Param0 } from "../tools/tsafe/Param0";
 import type { oidcEarlyInit } from "../entrypoint";
 import { createLoadHandleEntrypoint } from "./handleClientEntrypoint";
-import { excludeModuleExportFromOptimizedDeps } from "./excludeModuleExportFromOptimizedDeps";
-import { transformCreateFileRoute } from "./transformCreateFileRoute";
+import { manageOptimizedDeps } from "./manageOptimizedDeps";
+import { transformCreateFileRoute } from "./transformTanstackRouterCreateFileRoute";
+import { getProjectType, type ProjectType } from "./projectType";
 
-export type OidcSpaVitePluginParams = Omit<Param0<typeof oidcEarlyInit>, "isPostLoginRedirectManual">;
+export type OidcSpaVitePluginParams = Omit<
+    Param0<typeof oidcEarlyInit>,
+    "isPostLoginRedirectManual" | "BASE_URL"
+>;
 
-export function oidcSpa(params: OidcSpaVitePluginParams) {
+export function oidcSpa(
+    params: OidcSpaVitePluginParams = {
+        freezeFetch: true,
+        freezeXMLHttpRequest: true,
+        freezeWebSocket: true
+    }
+) {
     let loadHandleEntrypoint: ReturnType<typeof createLoadHandleEntrypoint> | undefined = undefined;
 
+    let projectType: ProjectType | undefined = undefined;
+
     const plugin: Plugin = {
         name: "oidc-spa",
         enforce: "pre",
         config(userConfig) {
-            userConfig = excludeModuleExportFromOptimizedDeps({ userConfig });
+            const projectType = getProjectType({
+                pluginNames:
+                    userConfig.plugins
+                        ?.flat()
+                        .filter(plugin => plugin instanceof Object)
+                        .filter(plugin => "name" in plugin)
+                        .map(plugin => plugin.name) ?? []
+            });
+
+            userConfig = manageOptimizedDeps({ userConfig, projectType });
             return userConfig;
         },
         configResolved(resolvedConfig) {
+            projectType = getProjectType({
+                pluginNames: resolvedConfig.plugins.map(({ name }) => name)
+            });
+
             loadHandleEntrypoint = createLoadHandleEntrypoint({
                 oidcSpaVitePluginParams: params,
-                resolvedConfig
+                resolvedConfig,
+                projectType
             });
         },
         transform(code, id) {
-            const transformed = transformCreateFileRoute({
-                code,
-                id
-            });
+            let transformed: TransformResult | null = null;
+
+            assert(projectType !== undefined);
+
+            tanstack_start_specific_transformations: {
+                if (projectType !== "tanstack-start") {
+                    break tanstack_start_specific_transformations;
+                }
+
+                transformed = transformCreateFileRoute({
+                    code,
+                    id
+                });
+            }
 
             return transformed;
         },

package/vite-plugin/handleClientEntrypoint.d.ts

@@ -1,9 +1,11 @@
 import type { OidcSpaVitePluginParams } from "./vite-plugin";
 import type { ResolvedConfig } from "vite";
 import type { PluginContext } from "rollup";
+import type { ProjectType } from "./projectType";
 export declare function createLoadHandleEntrypoint(params: {
     oidcSpaVitePluginParams: OidcSpaVitePluginParams;
     resolvedConfig: ResolvedConfig;
+    projectType: ProjectType;
 }): (params: {
     id: string;
     pluginContext: PluginContext;

package/vite-plugin/handleClientEntrypoint.js

@@ -34,7 +34,6 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLoadHandleEntrypoint = createLoadHandleEntrypoint;
-const detectProjectType_1 = require("./detectProjectType");
 const node_fs_1 = require("node:fs");
 const node_fs_2 = require("node:fs");
 const path = __importStar(require("node:path"));
@@ -51,8 +50,7 @@ const REACT_ROUTER_ENTRY_CANDIDATES = [
 ];
 const TANSTACK_ENTRY_CANDIDATES = ["client.tsx", "client.ts", "client.jsx", "client.js"];
 function createLoadHandleEntrypoint(params) {
-    const { oidcSpaVitePluginParams, resolvedConfig } = params;
-    const projectType = (0, detectProjectType_1.detectProjectType)({ resolvedConfig });
+    const { oidcSpaVitePluginParams, resolvedConfig, projectType } = params;
     const entryResolution = resolveEntryForProject({
         config: resolvedConfig,
         projectType
@@ -82,7 +80,8 @@ function createLoadHandleEntrypoint(params) {
             `    freezeFetch: ${freezeFetch},`,
             `    freezeXMLHttpRequest: ${freezeXMLHttpRequest},`,
             `    freezeWebSocket: ${freezeWebSocket},`,
-            `    isPostLoginRedirectManual: ${projectType === "tanstack-start"}`,
+            `    isPostLoginRedirectManual: ${projectType === "tanstack-start"},`,
+            `    BASE_URL: "${resolvedConfig.base}"`,
             `});`,
             ``,
             `if(shouldLoadApp){`,