@asgardeo/react 0.6.6 → 0.6.7

package/dist/cjs/index.js

@@ -856,12 +856,21 @@ var AsgardeoReactClient = class extends import_browser6.AsgardeoBrowserClient {
       const arg1 = args[0];
       const arg2 = args[1];
       const config = await this.asgardeo.getConfigData();
-      if (config.platform === import_browser6.Platform.AsgardeoV2 && typeof arg1 === "object" && !(0, import_browser6.isEmpty)(arg1) && ("flowId" in arg1 || "applicationId" in arg1)) {
-        const sessionDataKey = new URL(window.location.href).searchParams.get("sessionDataKey");
+      const platformFromStorage = sessionStorage.getItem("asgardeo_platform");
+      const isV2Platform = config && config.platform === import_browser6.Platform.AsgardeoV2 || platformFromStorage === "AsgardeoV2";
+      if (isV2Platform && typeof arg1 === "object" && arg1 !== null && arg1.callOnlyOnRedirect === true) {
+        return void 0;
+      }
+      if (isV2Platform && typeof arg1 === "object" && arg1 !== null && !(0, import_browser6.isEmpty)(arg1) && ("flowId" in arg1 || "applicationId" in arg1)) {
+        const sessionDataKeyFromUrl = new URL(window.location.href).searchParams.get("sessionDataKey");
+        const sessionDataKeyFromStorage = sessionStorage.getItem("asgardeo_session_data_key");
+        const sessionDataKey = sessionDataKeyFromUrl || sessionDataKeyFromStorage;
+        const baseUrlFromStorage = sessionStorage.getItem("asgardeo_base_url");
+        const baseUrl = config?.baseUrl || baseUrlFromStorage;
         return (0, import_browser6.executeEmbeddedSignInFlowV2)({
           payload: arg1,
           url: arg2?.url,
-          baseUrl: config?.baseUrl,
+          baseUrl,
           sessionDataKey
         });
       }
@@ -1609,7 +1618,14 @@ var AsgardeoProvider = ({
   (0, import_react15.useEffect)(() => {
     (async () => {
       await asgardeo.initialize(config);
-      setConfig(await asgardeo.getConfiguration());
+      const initializedConfig = await asgardeo.getConfiguration();
+      setConfig(initializedConfig);
+      if (initializedConfig?.platform) {
+        sessionStorage.setItem("asgardeo_platform", initializedConfig.platform);
+      }
+      if (initializedConfig?.baseUrl) {
+        sessionStorage.setItem("asgardeo_base_url", initializedConfig.baseUrl);
+      }
     })();
   }, []);
   (0, import_react15.useEffect)(() => {
@@ -1625,7 +1641,8 @@ var AsgardeoProvider = ({
       }
       const currentUrl = new URL(window.location.href);
       const hasAuthParamsResult = hasAuthParams(currentUrl, afterSignInUrl);
-      if (hasAuthParamsResult) {
+      const isV2Platform = config.platform === import_browser12.Platform.AsgardeoV2;
+      if (hasAuthParamsResult && !isV2Platform) {
         try {
           await signIn(
             { callOnlyOnRedirect: true }
@@ -1780,19 +1797,28 @@ var AsgardeoProvider = ({
     fetchBranding
   ]);
   const signIn = async (...args) => {
+    const arg1 = args[0];
+    const isV2FlowRequest = config.platform === import_browser12.Platform.AsgardeoV2 && typeof arg1 === "object" && arg1 !== null && ("flowId" in arg1 || "applicationId" in arg1);
     try {
-      setIsUpdatingSession(true);
-      setIsLoadingSync(true);
+      if (!isV2FlowRequest) {
+        setIsUpdatingSession(true);
+        setIsLoadingSync(true);
+      }
       const response = await asgardeo.signIn(...args);
+      if (isV2FlowRequest || response && typeof response === "object" && "flowStatus" in response) {
+        return response;
+      }
       if (await asgardeo.isSignedIn()) {
         await updateSession();
       }
       return response;
     } catch (error) {
-      throw new Error(`Error while signing in: ${error}`);
+      throw new Error(`Error while signing in: ${error instanceof Error ? error.message : String(error)}`);
     } finally {
-      setIsUpdatingSession(false);
-      setIsLoadingSync(asgardeo.isLoading());
+      if (!isV2FlowRequest) {
+        setIsUpdatingSession(false);
+        setIsLoadingSync(asgardeo.isLoading());
+      }
     }
   };
   const signInSilently = async (options) => {
@@ -7616,16 +7642,62 @@ var SignIn = ({ className, size = "medium", onSuccess, onError, variant, childre
   const [flowError, setFlowError] = (0, import_react59.useState)(null);
   const [isSubmitting, setIsSubmitting] = (0, import_react59.useState)(false);
   const initializationAttemptedRef = (0, import_react59.useRef)(false);
+  const oauthCodeProcessedRef = (0, import_react59.useRef)(false);
+  const handleRedirection = (response) => {
+    if (response.type === import_browser51.EmbeddedSignInFlowTypeV2.Redirection) {
+      const redirectURL = response.data?.redirectURL || response?.redirectURL;
+      if (redirectURL) {
+        if (response.flowId) {
+          sessionStorage.setItem("asgardeo_flow_id", response.flowId);
+        }
+        const urlParams = new URL(window.location.href).searchParams;
+        const sessionDataKeyFromUrl = urlParams.get("sessionDataKey");
+        if (sessionDataKeyFromUrl) {
+          sessionStorage.setItem("asgardeo_session_data_key", sessionDataKeyFromUrl);
+        }
+        window.location.href = redirectURL;
+        return true;
+      }
+    }
+    return false;
+  };
   (0, import_react59.useEffect)(() => {
-    if (isInitialized && !isLoading && !isFlowInitialized && !initializationAttemptedRef.current) {
+    const storedFlowId = sessionStorage.getItem("asgardeo_flow_id");
+    const urlParams = new URL(window.location.href).searchParams;
+    const code = urlParams.get("code");
+    const state = urlParams.get("state");
+    const sessionDataKeyFromUrl = urlParams.get("sessionDataKey");
+    if (sessionDataKeyFromUrl) {
+      sessionStorage.setItem("asgardeo_session_data_key", sessionDataKeyFromUrl);
+    }
+    if (code) {
+      const flowIdFromUrl = urlParams.get("flowId");
+      const flowIdFromState = state || flowIdFromUrl || storedFlowId;
+      if (flowIdFromState) {
+        setCurrentFlowId(flowIdFromState);
+        setIsFlowInitialized(true);
+        sessionStorage.setItem("asgardeo_flow_id", flowIdFromState);
+        initializationAttemptedRef.current = true;
+      }
+      return;
+    }
+    if (isInitialized && !isLoading && !isFlowInitialized && !initializationAttemptedRef.current && !currentFlowId) {
       initializationAttemptedRef.current = true;
       initializeFlow();
     }
-  }, [isInitialized, isLoading, isFlowInitialized]);
+  }, [isInitialized, isLoading, isFlowInitialized, currentFlowId]);
   const initializeFlow = async () => {
     const urlParams = new URL(window.location.href).searchParams;
+    const code = urlParams.get("code");
+    if (code) {
+      return;
+    }
     const flowIdFromUrl = urlParams.get("flowId");
     const applicationIdFromUrl = urlParams.get("applicationId");
+    const sessionDataKeyFromUrl = urlParams.get("sessionDataKey");
+    if (sessionDataKeyFromUrl) {
+      sessionStorage.setItem("asgardeo_session_data_key", sessionDataKeyFromUrl);
+    }
     const effectiveApplicationId = applicationId || applicationIdFromUrl;
     if (!flowIdFromUrl && !effectiveApplicationId) {
       const error = new import_browser51.AsgardeoRuntimeError(
@@ -7650,6 +7722,9 @@ var SignIn = ({ className, size = "medium", onSuccess, onError, variant, childre
           flowType: import_browser51.EmbeddedFlowType.Authentication
         });
       }
+      if (handleRedirection(response)) {
+        return;
+      }
       const { flowId, components: components2 } = normalizeFlowResponse(response, t);
       if (flowId && components2) {
         setCurrentFlowId(flowId);
@@ -7669,29 +7744,53 @@ var SignIn = ({ className, size = "medium", onSuccess, onError, variant, childre
     }
   };
   const handleSubmit = async (payload) => {
-    if (!currentFlowId) {
+    const effectiveFlowId = payload.flowId || currentFlowId;
+    if (!effectiveFlowId) {
+      console.error("[SignIn] handleSubmit - ERROR: No flowId available", {
+        payloadFlowId: payload.flowId,
+        currentFlowId
+      });
       throw new Error("No active flow ID");
     }
     try {
       setIsSubmitting(true);
       setFlowError(null);
       const response = await signIn({
-        flowId: currentFlowId,
+        flowId: effectiveFlowId,
         ...payload
       });
+      if (handleRedirection(response)) {
+        return;
+      }
       const { flowId, components: components2 } = normalizeFlowResponse(response, t);
       if (response.flowStatus === import_browser51.EmbeddedSignInFlowStatusV2.Complete) {
+        const redirectUrl = response.redirectUrl || response.redirect_uri;
+        sessionStorage.removeItem("asgardeo_flow_id");
+        if (redirectUrl) {
+          sessionStorage.removeItem("asgardeo_session_data_key");
+        }
+        const url = new URL(window.location.href);
+        url.searchParams.delete("code");
+        url.searchParams.delete("state");
+        url.searchParams.delete("nonce");
+        window.history.replaceState({}, "", url.toString());
+        const finalRedirectUrl = redirectUrl || afterSignInUrl;
         onSuccess && onSuccess({
-          redirectUrl: response.redirectUrl || afterSignInUrl,
+          redirectUrl: finalRedirectUrl,
           ...response.data
         });
-        window.location.href = response.redirectUrl || afterSignInUrl;
+        if (finalRedirectUrl) {
+          window.location.href = finalRedirectUrl;
+        }
         return;
       }
       if (flowId && components2) {
         setCurrentFlowId(flowId);
         setComponents(components2);
       }
+      if (!currentFlowId && effectiveFlowId) {
+        setCurrentFlowId(effectiveFlowId);
+      }
     } catch (error) {
       const err = error;
       setFlowError(err);
@@ -7711,6 +7810,36 @@ var SignIn = ({ className, size = "medium", onSuccess, onError, variant, childre
     setFlowError(error);
     onError?.(error);
   };
+  (0, import_react59.useEffect)(() => {
+    const urlParams = new URL(window.location.href).searchParams;
+    const code = urlParams.get("code");
+    const nonce = urlParams.get("nonce");
+    const state = urlParams.get("state");
+    const flowIdFromUrl = urlParams.get("flowId");
+    const storedFlowId = sessionStorage.getItem("asgardeo_flow_id");
+    if (!code || oauthCodeProcessedRef.current || isSubmitting) {
+      return;
+    }
+    const flowIdToUse = currentFlowId || state || flowIdFromUrl || storedFlowId;
+    if (!flowIdToUse || !signIn) {
+      return;
+    }
+    oauthCodeProcessedRef.current = true;
+    if (!currentFlowId) {
+      setCurrentFlowId(flowIdToUse);
+      setIsFlowInitialized(true);
+    }
+    const submitPayload = {
+      flowId: flowIdToUse,
+      inputs: {
+        code,
+        ...nonce && { nonce }
+      }
+    };
+    handleSubmit(submitPayload).catch(() => {
+      oauthCodeProcessedRef.current = false;
+    });
+  }, [isFlowInitialized, currentFlowId, isInitialized, isLoading, isSubmitting, signIn]);
   if (children) {
     const renderProps = {
       initialize: initializeFlow,
@@ -8509,6 +8638,7 @@ var BaseSignUpContent = ({
   const { theme, colorScheme } = useTheme_default();
   const { t } = useTranslation_default();
   const { subtitle: flowSubtitle, title: flowTitle, messages: flowMessages, addMessage, clearMessages } = useFlow_default();
+  const { platform } = useAsgardeo_default();
   const styles = BaseSignUp_styles_default(theme, colorScheme);
   const handleError = (0, import_react61.useCallback)(
     (error) => {
@@ -8634,11 +8764,12 @@ var BaseSignUpContent = ({
           }
         });
       }
+      const actionId = platform === import_browser61.Platform.AsgardeoV2 ? component.config?.actionId : component.id;
       const payload = {
         ...currentFlow.flowId && { flowId: currentFlow.flowId },
         flowType: currentFlow.flowType || "REGISTRATION",
         inputs: filteredInputs,
-        actionId: component.id
+        ...actionId && { actionId }
       };
       const rawResponse = await onSubmit(payload);
       const response = normalizeFlowResponse2(rawResponse);