@asgardeo/react 0.5.7 → 0.5.8

package/dist/AsgardeoReactClient.d.ts

@@ -25,7 +25,19 @@ import { AsgardeoReactConfig } from './models/config';
  */
 declare class AsgardeoReactClient<T extends AsgardeoReactConfig = AsgardeoReactConfig> extends AsgardeoBrowserClient<T> {
     private asgardeo;
+    private _isLoading;
     constructor();
+    /**
+     * Set the loading state of the client
+     * @param loading - Boolean indicating if the client is in a loading state
+     */
+    private setLoading;
+    /**
+     * Wrap async operations with loading state management
+     * @param operation - The async operation to execute
+     * @returns Promise with the result of the operation
+     */
+    private withLoading;
     initialize(config: AsgardeoReactConfig): Promise<boolean>;
     updateUserProfile(payload: any, userId?: string): Promise<User>;
     getUser(options?: any): Promise<User>;
@@ -41,6 +53,7 @@ declare class AsgardeoReactClient<T extends AsgardeoReactConfig = AsgardeoReactC
     getConfiguration(): T;
     signIn(options?: SignInOptions, sessionId?: string, onSignInSuccess?: (afterSignInUrl: string) => void): Promise<User>;
     signIn(payload: EmbeddedSignInFlowHandleRequestPayload, request: EmbeddedFlowExecuteRequestConfig, sessionId?: string, onSignInSuccess?: (afterSignInUrl: string) => void): Promise<User>;
+    signInSilently(options?: SignInOptions): Promise<User | boolean>;
     signOut(options?: SignOutOptions, afterSignOut?: (afterSignOutUrl: string) => void): Promise<string>;
     signOut(options?: SignOutOptions, sessionId?: string, afterSignOut?: (afterSignOutUrl: string) => void): Promise<string>;
     signUp(options?: SignUpOptions): Promise<void>;

package/dist/__temp__/api.d.ts

@@ -224,10 +224,10 @@ declare class AuthAPI {
      *
      * @example
      *```
-     * client.trySignInSilently()
+     * client.signInSilently()
      *```
      */
-    trySignInSilently(state: AuthStateInterface, dispatch: (state: AuthStateInterface) => void, additionalParams?: Record<string, string | boolean>, tokenRequestConfig?: {
+    signInSilently(additionalParams?: Record<string, string | boolean>, tokenRequestConfig?: {
         params: Record<string, unknown>;
     }): Promise<User | boolean | undefined>;
 }

package/dist/__temp__/models.d.ts

@@ -78,7 +78,7 @@ export interface AuthContextInterface {
     enableHttpHandler(): Promise<boolean>;
     disableHttpHandler(): Promise<boolean>;
     reInitialize(config: Partial<AuthClientConfig<Config>>): Promise<void>;
-    trySignInSilently: (additionalParams?: Record<string, string | boolean>, tokenRequestConfig?: {
+    signInSilently: (additionalParams?: Record<string, string | boolean>, tokenRequestConfig?: {
         params: Record<string, unknown>;
     }) => Promise<boolean | User>;
     on(hook: Hooks.CustomGrant, callback: (response?: any) => void, id: string): void;

package/dist/cjs/index.js

@@ -37,6 +37,7 @@ __export(index_exports, {
   AsgardeoContext: () => AsgardeoContext_default,
   AsgardeoLoading: () => AsgardeoLoading_default,
   AsgardeoProvider: () => AsgardeoProvider_default,
+  AsgardeoRuntimeError: () => import_browser66.AsgardeoRuntimeError,
   BaseCreateOrganization: () => BaseCreateOrganization,
   BaseOrganization: () => BaseOrganization_default,
   BaseOrganizationList: () => BaseOrganizationList_default,
@@ -167,6 +168,7 @@ var AsgardeoContext = (0, import_react.createContext)({
   isSignedIn: false,
   organization: null,
   signIn: null,
+  signInSilently: null,
   signOut: null,
   signUp: null,
   user: null
@@ -486,29 +488,14 @@ var _AuthAPI = class _AuthAPI {
    *
    * @example
    *```
-   * client.trySignInSilently()
+   * client.signInSilently()
    *```
    */
-  async trySignInSilently(state, dispatch, additionalParams, tokenRequestConfig) {
-    return this._client.trySignInSilently(additionalParams, tokenRequestConfig).then(async (response) => {
+  async signInSilently(additionalParams, tokenRequestConfig) {
+    return this._client.signInSilently(additionalParams, tokenRequestConfig).then(async (response) => {
       if (!response) {
-        this.updateState({ ...this.getState(), isLoading: false });
-        dispatch({ ...state, isLoading: false });
         return false;
       }
-      if (await this._client.isSignedIn()) {
-        const basicUserInfo = response;
-        const stateToUpdate = {
-          displayName: basicUserInfo.displayName,
-          email: basicUserInfo.email,
-          isSignedIn: true,
-          isLoading: false,
-          isSigningOut: false,
-          username: basicUserInfo.username
-        };
-        this.updateState(stateToUpdate);
-        dispatch({ ...state, ...stateToUpdate });
-      }
       return response;
     }).catch((error) => Promise.reject(error));
   }
@@ -632,14 +619,38 @@ var AsgardeoReactClient = class extends import_browser6.AsgardeoBrowserClient {
   constructor() {
     super();
     __publicField(this, "asgardeo");
+    __publicField(this, "_isLoading", false);
     this.asgardeo = new api_default();
   }
+  /**
+   * Set the loading state of the client
+   * @param loading - Boolean indicating if the client is in a loading state
+   */
+  setLoading(loading) {
+    this._isLoading = loading;
+  }
+  /**
+   * Wrap async operations with loading state management
+   * @param operation - The async operation to execute
+   * @returns Promise with the result of the operation
+   */
+  async withLoading(operation) {
+    this.setLoading(true);
+    try {
+      const result = await operation();
+      return result;
+    } finally {
+      this.setLoading(false);
+    }
+  }
   initialize(config) {
     let resolvedOrganizationHandle = config?.organizationHandle;
     if (!resolvedOrganizationHandle) {
       resolvedOrganizationHandle = (0, import_browser6.deriveOrganizationHandleFromBaseUrl)(config?.baseUrl);
     }
-    return this.asgardeo.init({ ...config, organizationHandle: resolvedOrganizationHandle });
+    return this.withLoading(async () => {
+      return this.asgardeo.init({ ...config, organizationHandle: resolvedOrganizationHandle });
+    });
   }
   async updateUserProfile(payload, userId) {
     throw new Error("Not implemented");
@@ -728,47 +739,49 @@ var AsgardeoReactClient = class extends import_browser6.AsgardeoBrowserClient {
     };
   }
   async switchOrganization(organization, sessionId) {
-    try {
-      const configData = await this.asgardeo.getConfigData();
-      const scopes = configData?.scopes;
-      if (!organization.id) {
+    return this.withLoading(async () => {
+      try {
+        const configData = await this.asgardeo.getConfigData();
+        const scopes = configData?.scopes;
+        if (!organization.id) {
+          throw new import_browser6.AsgardeoRuntimeError(
+            "Organization ID is required for switching organizations",
+            "react-AsgardeoReactClient-SwitchOrganizationError-001",
+            "react",
+            "The organization object must contain a valid ID to perform the organization switch."
+          );
+        }
+        const exchangeConfig = {
+          attachToken: false,
+          data: {
+            client_id: "{{clientId}}",
+            grant_type: "organization_switch",
+            scope: "{{scopes}}",
+            switching_organization: organization.id,
+            token: "{{accessToken}}"
+          },
+          id: "organization-switch",
+          returnsSession: true,
+          signInRequired: true
+        };
+        return await this.asgardeo.exchangeToken(
+          exchangeConfig,
+          (user) => {
+          },
+          () => null
+        );
+      } catch (error) {
         throw new import_browser6.AsgardeoRuntimeError(
-          "Organization ID is required for switching organizations",
-          "react-AsgardeoReactClient-SwitchOrganizationError-001",
+          `Failed to switch organization: ${error.message || error}`,
+          "react-AsgardeoReactClient-SwitchOrganizationError-003",
           "react",
-          "The organization object must contain a valid ID to perform the organization switch."
+          "An error occurred while switching to the specified organization. Please try again."
         );
       }
-      const exchangeConfig = {
-        attachToken: false,
-        data: {
-          client_id: "{{clientId}}",
-          grant_type: "organization_switch",
-          scope: "{{scopes}}",
-          switching_organization: organization.id,
-          token: "{{accessToken}}"
-        },
-        id: "organization-switch",
-        returnsSession: true,
-        signInRequired: true
-      };
-      return await this.asgardeo.exchangeToken(
-        exchangeConfig,
-        (user) => {
-        },
-        () => null
-      );
-    } catch (error) {
-      throw new import_browser6.AsgardeoRuntimeError(
-        `Failed to switch organization: ${error.message || error}`,
-        "react-AsgardeoReactClient-SwitchOrganizationError-003",
-        "react",
-        "An error occurred while switching to the specified organization. Please try again."
-      );
-    }
+    });
   }
   isLoading() {
-    return this.asgardeo.isLoading();
+    return this._isLoading || this.asgardeo.isLoading();
   }
   async isInitialized() {
     return this.asgardeo.isInitialized();
@@ -780,15 +793,22 @@ var AsgardeoReactClient = class extends import_browser6.AsgardeoBrowserClient {
     return this.asgardeo.getConfigData();
   }
   async signIn(...args) {
-    const arg1 = args[0];
-    const arg2 = args[1];
-    if (typeof arg1 === "object" && "flowId" in arg1 && typeof arg2 === "object" && "url" in arg2) {
-      return (0, import_browser6.executeEmbeddedSignInFlow)({
-        payload: arg1,
-        url: arg2.url
-      });
-    }
-    return await this.asgardeo.signIn(arg1);
+    return this.withLoading(async () => {
+      const arg1 = args[0];
+      const arg2 = args[1];
+      if (typeof arg1 === "object" && "flowId" in arg1 && typeof arg2 === "object" && "url" in arg2) {
+        return (0, import_browser6.executeEmbeddedSignInFlow)({
+          payload: arg1,
+          url: arg2.url
+        });
+      }
+      return await this.asgardeo.signIn(arg1);
+    });
+  }
+  async signInSilently(options) {
+    return this.withLoading(async () => {
+      return this.asgardeo.signInSilently(options);
+    });
   }
   async signOut(...args) {
     if (args[1] && typeof args[1] !== "function") {
@@ -1459,6 +1479,7 @@ var AsgardeoProvider = ({
   const [currentOrganization, setCurrentOrganization] = (0, import_react15.useState)(null);
   const [isSignedInSync, setIsSignedInSync] = (0, import_react15.useState)(false);
   const [isInitializedSync, setIsInitializedSync] = (0, import_react15.useState)(false);
+  const [isLoadingSync, setIsLoadingSync] = (0, import_react15.useState)(true);
   const [myOrganizations, setMyOrganizations] = (0, import_react15.useState)([]);
   const [userProfile, setUserProfile] = (0, import_react15.useState)(null);
   const [baseUrl, setBaseUrl] = (0, import_react15.useState)(_baseUrl);
@@ -1552,16 +1573,32 @@ var AsgardeoProvider = ({
       }
     })();
   }, [asgardeo]);
+  (0, import_react15.useEffect)(() => {
+    const checkLoadingState = () => {
+      const loadingState = asgardeo.isLoading();
+      setIsLoadingSync(loadingState);
+    };
+    checkLoadingState();
+    const interval = setInterval(checkLoadingState, 100);
+    return () => {
+      clearInterval(interval);
+    };
+  }, [asgardeo]);
   const updateSession = async () => {
-    let _baseUrl2 = baseUrl;
-    if ((await asgardeo.getDecodedIdToken())?.["user_org"]) {
-      _baseUrl2 = `${(await asgardeo.getConfiguration()).baseUrl}/o`;
-      setBaseUrl(_baseUrl2);
-    }
-    setUser(await asgardeo.getUser({ baseUrl: _baseUrl2 }));
-    setUserProfile(await asgardeo.getUserProfile({ baseUrl: _baseUrl2 }));
-    setCurrentOrganization(await asgardeo.getCurrentOrganization());
-    setMyOrganizations(await asgardeo.getMyOrganizations());
+    try {
+      setIsLoadingSync(true);
+      let _baseUrl2 = baseUrl;
+      if ((await asgardeo.getDecodedIdToken())?.["user_org"]) {
+        _baseUrl2 = `${(await asgardeo.getConfiguration()).baseUrl}/o`;
+        setBaseUrl(_baseUrl2);
+      }
+      setUser(await asgardeo.getUser({ baseUrl: _baseUrl2 }));
+      setUserProfile(await asgardeo.getUserProfile({ baseUrl: _baseUrl2 }));
+      setCurrentOrganization(await asgardeo.getCurrentOrganization());
+      setMyOrganizations(await asgardeo.getMyOrganizations());
+    } finally {
+      setIsLoadingSync(asgardeo.isLoading());
+    }
   };
   const fetchBranding = (0, import_react15.useCallback)(async () => {
     if (!baseUrl) {
@@ -1609,6 +1646,7 @@ var AsgardeoProvider = ({
   ]);
   const signIn = async (...args) => {
     try {
+      setIsLoadingSync(true);
       const response = await asgardeo.signIn(...args);
       if (await asgardeo.isSignedIn()) {
         await updateSession();
@@ -1616,6 +1654,27 @@ var AsgardeoProvider = ({
       return response;
     } catch (error) {
       throw new Error(`Error while signing in: ${error}`);
+    } finally {
+      setIsLoadingSync(asgardeo.isLoading());
+    }
+  };
+  const signInSilently = async (options) => {
+    try {
+      setIsLoadingSync(true);
+      const response = await asgardeo.signInSilently(options);
+      if (await asgardeo.isSignedIn()) {
+        await updateSession();
+      }
+      return response;
+    } catch (error) {
+      throw new import_browser13.AsgardeoRuntimeError(
+        `Error while signing in silently: ${error.message || error}`,
+        "asgardeo-signInSilently-Error",
+        "react",
+        "An error occurred while trying to sign in silently."
+      );
+    } finally {
+      setIsLoadingSync(asgardeo.isLoading());
     }
   };
   const signUp = async (payload) => {
@@ -1633,6 +1692,7 @@ var AsgardeoProvider = ({
   const signOut = async (options, afterSignOut) => asgardeo.signOut(options, afterSignOut);
   const switchOrganization = async (organization) => {
     try {
+      setIsLoadingSync(true);
       await asgardeo.switchOrganization(organization);
       if (await asgardeo.isSignedIn()) {
         await updateSession();
@@ -1644,6 +1704,8 @@ var AsgardeoProvider = ({
         "react",
         "An error occurred while switching to the specified organization."
       );
+    } finally {
+      setIsLoadingSync(asgardeo.isLoading());
     }
   };
   const isDarkMode = (0, import_react15.useMemo)(() => {
@@ -1671,10 +1733,11 @@ var AsgardeoProvider = ({
         afterSignInUrl,
         baseUrl,
         isInitialized: isInitializedSync,
-        isLoading: asgardeo.isLoading(),
+        isLoading: isLoadingSync,
         isSignedIn: isSignedInSync,
         organization: currentOrganization,
         signIn,
+        signInSilently,
         signOut,
         signUp,
         user
@@ -11043,4 +11106,7 @@ var OrganizationSwitcher = ({
   ] });
 };
 var OrganizationSwitcher_default = OrganizationSwitcher;
+
+// src/index.ts
+var import_browser66 = require("@asgardeo/browser");
 //# sourceMappingURL=index.js.map