@insforge/react 0.5.11 → 0.6.0

package/dist/index.cjs

@@ -20,7 +20,9 @@ var sdk = require('@insforge/sdk');
 var lucideReact = require('lucide-react');
 var zod = require('zod');
 
-// src/components/SignIn.tsx
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var NavigationContext = react.createContext(null);
 function NavigationProvider({ adapter, children }) {
   return /* @__PURE__ */ jsxRuntime.jsx(NavigationContext.Provider, { value: adapter, children });
@@ -64,34 +66,80 @@ function useSearchParams() {
   const adapter = useNavigationAdapter();
   return adapter.useSearchParams();
 }
-var InsforgeContext = react.createContext(void 0);
-function InsforgeProviderCore({
-  children,
-  baseUrl,
-  afterSignInUrl = "/",
-  onAuthChange,
-  onSignIn,
-  onSignOut
-}) {
-  const [user, setUser] = react.useState(null);
-  const [isLoaded, setIsLoaded] = react.useState(false);
-  const refreshIntervalRef = react.useRef(null);
-  const hasProcessedCallbackRef = react.useRef(false);
-  const [insforge] = react.useState(() => sdk.createClient({ baseUrl }));
-  const loadAuthState = react.useCallback(async () => {
+var _InsforgeManager = class _InsforgeManager {
+  // Private constructor (prevents external instantiation)
+  constructor(config) {
+    // State storage
+    __publicField(this, "user", null);
+    __publicField(this, "isLoaded", false);
+    __publicField(this, "sdk");
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    // Config
+    __publicField(this, "config");
+    __publicField(this, "refreshIntervalRef", null);
+    __publicField(this, "hasProcessedCallbackRef", false);
+    this.config = config;
+    this.sdk = sdk.createClient({ baseUrl: config.baseUrl });
+  }
+  // Public access method (Singleton core)
+  static getInstance(config) {
+    if (typeof window !== "undefined" && _InsforgeManager.instance) {
+      _InsforgeManager.instance.updateConfig(config);
+      return _InsforgeManager.instance;
+    }
+    _InsforgeManager.instance = new _InsforgeManager(config);
+    return _InsforgeManager.instance;
+  }
+  // Clear instance (used for testing or cleanup)
+  static clearInstance() {
+    if (_InsforgeManager.instance) {
+      _InsforgeManager.instance.cleanup();
+    }
+    _InsforgeManager.instance = null;
+  }
+  // Update config (for hot reloads)
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  // Public initialization method
+  async initialize() {
+    if (!this.isLoaded) {
+      await this.loadAuthState();
+    }
+  }
+  // Get current state
+  getState() {
+    return {
+      user: this.user,
+      isLoaded: this.isLoaded,
+      isSignedIn: !!this.user
+    };
+  }
+  // Subscription mechanism
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notifyListeners() {
+    const state = this.getState();
+    this.listeners.forEach((listener) => listener(state));
+  }
+  // Load auth state
+  async loadAuthState() {
     try {
-      const sessionResult = insforge.auth.getCurrentSession();
+      const sessionResult = this.sdk.auth.getCurrentSession();
       const session = sessionResult.data?.session;
       const token = session?.accessToken || null;
       if (!token) {
-        setUser(null);
-        if (onAuthChange) {
-          onAuthChange(null);
+        this.user = null;
+        if (this.config.onAuthChange) {
+          this.config.onAuthChange(null);
         }
-        setIsLoaded(true);
+        this.isLoaded = true;
+        this.notifyListeners();
         return { success: false, error: "no_session" };
       }
-      const userResult = await insforge.auth.getCurrentUser();
+      const userResult = await this.sdk.auth.getCurrentUser();
       if (userResult.data) {
         const profile = userResult.data.profile;
         const userData = {
@@ -100,326 +148,362 @@ function InsforgeProviderCore({
           name: profile?.nickname || "",
           avatarUrl: profile?.avatarUrl || ""
         };
-        setUser(userData);
-        if (onAuthChange) {
-          onAuthChange(userData);
+        this.user = userData;
+        if (this.config.onAuthChange) {
+          this.config.onAuthChange(userData);
         }
-        setIsLoaded(true);
+        this.isLoaded = true;
+        this.notifyListeners();
         return { success: true };
       } else {
-        await insforge.auth.signOut();
-        if (onSignOut) {
+        await this.sdk.auth.signOut();
+        if (this.config.onSignOut) {
           try {
-            await onSignOut();
+            await this.config.onSignOut();
           } catch (error) {
             if (error instanceof Error) {
-              console.error("[InsforgeProvider] Error clearing cookie:", error.message);
+              console.error("[InsforgeManager] Error clearing cookie:", error.message);
             }
           }
         }
-        setUser(null);
-        if (onAuthChange) {
-          onAuthChange(null);
+        this.user = null;
+        if (this.config.onAuthChange) {
+          this.config.onAuthChange(null);
         }
-        setIsLoaded(true);
+        this.isLoaded = true;
+        this.notifyListeners();
         return { success: false, error: "invalid_token" };
       }
     } catch (error) {
-      console.error("[InsforgeProvider] Token validation failed:", error);
-      await insforge.auth.signOut();
-      if (onSignOut) {
+      console.error("[InsforgeManager] Token validation failed:", error);
+      await this.sdk.auth.signOut();
+      if (this.config.onSignOut) {
         try {
-          await onSignOut();
+          await this.config.onSignOut();
         } catch (error2) {
           if (error2 instanceof Error) {
-            console.error("[InsforgeProvider] Error clearing cookie:", error2.message);
+            console.error("[InsforgeManager] Error clearing cookie:", error2.message);
           }
         }
       }
-      setUser(null);
-      if (onAuthChange) {
-        onAuthChange(null);
+      this.user = null;
+      if (this.config.onAuthChange) {
+        this.config.onAuthChange(null);
       }
-      setIsLoaded(true);
+      this.isLoaded = true;
+      this.notifyListeners();
       return {
         success: false,
         error: error instanceof Error ? error.message : "Authentication failed"
       };
     }
-  }, [insforge, onAuthChange, onSignOut]);
-  react.useEffect(() => {
-    loadAuthState();
-    const intervalId = refreshIntervalRef.current;
-    return () => {
-      if (intervalId) {
-        clearInterval(intervalId);
-      }
-    };
-  }, [loadAuthState]);
-  react.useEffect(() => {
-    if (!isLoaded || hasProcessedCallbackRef.current) {
-      return;
-    }
-    const searchParams = new URLSearchParams(window.location.search);
-    const accessToken = searchParams.get("access_token");
-    if (accessToken && !!user) {
-      hasProcessedCallbackRef.current = true;
-      const url = new URL(window.location.href);
-      url.search = "";
-      window.history.replaceState({}, "", url.toString());
-      setTimeout(() => {
-        window.location.href = afterSignInUrl;
-      }, 100);
-    }
-  }, [isLoaded, user, afterSignInUrl]);
-  const getPublicAuthConfig = react.useCallback(async () => {
-    try {
-      const result = await insforge.auth.getPublicAuthConfig();
-      if (result.data) {
-        return result.data;
-      } else {
-        console.error("[InsforgeProvider] Failed to get public auth config:", result.error);
-        return null;
+  }
+  // Helper to handle auth success
+  async handleAuthSuccess(authToken, fallbackUser) {
+    const userResult = await this.sdk.auth.getCurrentUser();
+    if (userResult.data) {
+      const profile = userResult.data.profile;
+      const userData = {
+        id: userResult.data.user.id,
+        email: userResult.data.user.email,
+        name: profile?.nickname || "",
+        avatarUrl: profile?.avatarUrl || ""
+      };
+      this.user = userData;
+      if (this.config.onAuthChange) {
+        this.config.onAuthChange(userData);
       }
-    } catch (error) {
-      console.error("[InsforgeProvider] Failed to get public auth config:", error);
-      return null;
-    }
-  }, [insforge]);
-  const handleAuthSuccess = react.useCallback(
-    async (authToken, fallbackUser) => {
-      const userResult = await insforge.auth.getCurrentUser();
-      if (userResult.data) {
-        const profile = userResult.data.profile;
-        const userData = {
-          id: userResult.data.user.id,
-          email: userResult.data.user.email,
-          name: profile?.nickname || "",
-          avatarUrl: profile?.avatarUrl || ""
-        };
-        setUser(userData);
-        if (onAuthChange) {
-          onAuthChange(userData);
-        }
-        if (onSignIn) {
-          try {
-            await onSignIn(authToken);
-          } catch (error) {
-            if (error instanceof Error) {
-              console.error("[InsforgeProvider] Error syncing token to cookie:", error.message);
-            }
+      if (this.config.onSignIn) {
+        try {
+          await this.config.onSignIn(authToken);
+        } catch (error) {
+          if (error instanceof Error) {
+            console.error("[InsforgeManager] Error syncing token to cookie:", error.message);
           }
         }
-      } else if (fallbackUser) {
-        const userData = {
-          id: fallbackUser.id || "",
-          email: fallbackUser.email || "",
-          name: fallbackUser.name || "",
-          avatarUrl: ""
-        };
-        setUser(userData);
-        if (onAuthChange) {
-          onAuthChange(userData);
-        }
       }
-    },
-    [insforge, onAuthChange, onSignIn]
-  );
-  const signIn = react.useCallback(
-    async (email, password) => {
-      const sdkResult = await insforge.auth.signInWithPassword({
-        email,
-        password
-      });
-      if (sdkResult.data) {
-        await handleAuthSuccess(
-          sdkResult.data.accessToken || "",
+      this.notifyListeners();
+    } else if (fallbackUser) {
+      const userData = {
+        id: fallbackUser.id || "",
+        email: fallbackUser.email || "",
+        name: fallbackUser.name || "",
+        avatarUrl: ""
+      };
+      this.user = userData;
+      if (this.config.onAuthChange) {
+        this.config.onAuthChange(userData);
+      }
+      this.notifyListeners();
+    }
+  }
+  // Business methods
+  async signIn(email, password) {
+    const sdkResult = await this.sdk.auth.signInWithPassword({
+      email,
+      password
+    });
+    if (sdkResult.data) {
+      await this.handleAuthSuccess(
+        sdkResult.data.accessToken || "",
+        sdkResult.data.user ? {
+          id: sdkResult.data.user.id,
+          email: sdkResult.data.user.email,
+          name: sdkResult.data.user.name
+        } : void 0
+      );
+      return sdkResult.data;
+    } else {
+      return {
+        error: sdkResult.error?.message || "Invalid email or password",
+        statusCode: sdkResult.error?.statusCode,
+        errorCode: sdkResult.error?.error
+      };
+    }
+  }
+  async signUp(email, password) {
+    const sdkResult = await this.sdk.auth.signUp({ email, password });
+    if (sdkResult.data) {
+      if (sdkResult.data.accessToken) {
+        await this.handleAuthSuccess(
+          sdkResult.data.accessToken,
           sdkResult.data.user ? {
             id: sdkResult.data.user.id,
             email: sdkResult.data.user.email,
             name: sdkResult.data.user.name
           } : void 0
         );
-        return sdkResult.data;
-      } else {
-        return {
-          error: sdkResult.error?.message || "Invalid email or password",
-          statusCode: sdkResult.error?.statusCode,
-          errorCode: sdkResult.error?.error
-        };
-      }
-    },
-    [insforge, handleAuthSuccess]
-  );
-  const signUp = react.useCallback(
-    async (email, password) => {
-      const sdkResult = await insforge.auth.signUp({ email, password });
-      if (sdkResult.data) {
-        if (sdkResult.data.accessToken) {
-          await handleAuthSuccess(
-            sdkResult.data.accessToken,
-            sdkResult.data.user ? {
-              id: sdkResult.data.user.id,
-              email: sdkResult.data.user.email,
-              name: sdkResult.data.user.name
-            } : void 0
-          );
-        }
-        return sdkResult.data;
-      } else {
-        return {
-          error: sdkResult.error?.message || "Sign up failed",
-          statusCode: sdkResult.error?.statusCode,
-          errorCode: sdkResult.error?.error
-        };
       }
-    },
-    [insforge, handleAuthSuccess]
-  );
-  const signOut = react.useCallback(async () => {
-    await insforge.auth.signOut();
-    if (onSignOut) {
+      return sdkResult.data;
+    } else {
+      return {
+        error: sdkResult.error?.message || "Sign up failed",
+        statusCode: sdkResult.error?.statusCode,
+        errorCode: sdkResult.error?.error
+      };
+    }
+  }
+  async signOut() {
+    await this.sdk.auth.signOut();
+    if (this.config.onSignOut) {
       try {
-        await onSignOut();
+        await this.config.onSignOut();
       } catch (error) {
         if (error instanceof Error) {
-          console.error("[InsforgeProvider] Error clearing cookie:", error.message);
+          console.error("[InsforgeManager] Error clearing cookie:", error.message);
         }
       }
     }
-    if (refreshIntervalRef.current) {
-      clearInterval(refreshIntervalRef.current);
+    if (this.refreshIntervalRef) {
+      clearInterval(this.refreshIntervalRef);
+      this.refreshIntervalRef = null;
     }
-    setUser(null);
-    if (onAuthChange) {
-      onAuthChange(null);
+    this.user = null;
+    if (this.config.onAuthChange) {
+      this.config.onAuthChange(null);
     }
-  }, [insforge, onAuthChange, onSignOut]);
-  const updateUser = react.useCallback(
-    async (data) => {
-      if (!user) {
-        return { error: "No user signed in" };
-      }
-      const profileUpdate = {
-        nickname: data.name,
-        avatarUrl: data.avatarUrl
-      };
-      const result = await insforge.auth.setProfile(profileUpdate);
-      if (result.data) {
-        const userResult = await insforge.auth.getCurrentUser();
-        if (userResult.data) {
-          const profile = userResult.data.profile;
-          const updatedUser = {
-            id: userResult.data.user.id,
-            email: userResult.data.user.email,
-            name: profile?.nickname || "",
-            avatarUrl: profile?.avatarUrl || ""
-          };
-          setUser(updatedUser);
-          if (onAuthChange) {
-            onAuthChange(updatedUser);
-          }
+    this.notifyListeners();
+  }
+  async updateUser(data) {
+    if (!this.user) {
+      return { error: "No user signed in" };
+    }
+    const profileUpdate = {
+      nickname: data.name,
+      avatarUrl: data.avatarUrl
+    };
+    const result = await this.sdk.auth.setProfile(profileUpdate);
+    if (result.data) {
+      const userResult = await this.sdk.auth.getCurrentUser();
+      if (userResult.data) {
+        const profile = userResult.data.profile;
+        const updatedUser = {
+          id: userResult.data.user.id,
+          email: userResult.data.user.email,
+          name: profile?.nickname || "",
+          avatarUrl: profile?.avatarUrl || ""
+        };
+        this.user = updatedUser;
+        if (this.config.onAuthChange) {
+          this.config.onAuthChange(updatedUser);
         }
-        return null;
-      } else {
-        return { error: result.error?.message || "Failed to update user" };
+        this.notifyListeners();
       }
-    },
-    [user, onAuthChange, insforge]
-  );
-  const sendVerificationEmail = react.useCallback(
-    async (email) => {
-      const sdkResult = await insforge.auth.sendVerificationEmail({ email });
-      return sdkResult.data;
-    },
-    [insforge]
-  );
-  const sendResetPasswordEmail = react.useCallback(
-    async (email) => {
-      const sdkResult = await insforge.auth.sendResetPasswordEmail({ email });
+      return null;
+    } else {
+      return { error: result.error?.message || "Failed to update user" };
+    }
+  }
+  async reloadAuth() {
+    return await this.loadAuthState();
+  }
+  async sendVerificationEmail(email) {
+    const sdkResult = await this.sdk.auth.sendVerificationEmail({ email });
+    return sdkResult.data;
+  }
+  async sendResetPasswordEmail(email) {
+    const sdkResult = await this.sdk.auth.sendResetPasswordEmail({ email });
+    return sdkResult.data;
+  }
+  async resetPassword(token, newPassword) {
+    const sdkResult = await this.sdk.auth.resetPassword({
+      newPassword,
+      otp: token
+    });
+    return sdkResult.data;
+  }
+  async verifyEmail(otp, email) {
+    const sdkResult = await this.sdk.auth.verifyEmail({ otp, email: email || void 0 });
+    if (sdkResult.data) {
       return sdkResult.data;
-    },
-    [insforge]
-  );
-  const resetPassword = react.useCallback(
-    async (token, newPassword) => {
-      const sdkResult = await insforge.auth.resetPassword({
-        newPassword,
-        otp: token
-      });
+    } else {
+      return {
+        accessToken: "",
+        error: {
+          message: sdkResult.error?.message || "Email verification failed"
+        }
+      };
+    }
+  }
+  async exchangeResetPasswordToken(email, code) {
+    const sdkResult = await this.sdk.auth.exchangeResetPasswordToken({ email, code });
+    if (sdkResult.data) {
       return sdkResult.data;
-    },
-    [insforge]
-  );
-  const verifyEmail = react.useCallback(
-    async (otp, email) => {
-      const sdkResult = await insforge.auth.verifyEmail({ otp, email: email || void 0 });
-      if (sdkResult.data) {
-        return sdkResult.data;
-      } else {
-        return {
-          accessToken: "",
-          error: {
-            message: sdkResult.error?.message || "Email verification failed"
-          }
-        };
-      }
-    },
-    [insforge]
-  );
-  const exchangeResetPasswordToken = react.useCallback(
-    async (email, code) => {
-      const sdkResult = await insforge.auth.exchangeResetPasswordToken({ email, code });
-      if (sdkResult.data) {
-        return sdkResult.data;
+    } else {
+      return {
+        error: {
+          message: sdkResult.error?.message || "Failed to exchange reset password token"
+        }
+      };
+    }
+  }
+  async loginWithOAuth(provider, redirectTo) {
+    const sdkResult = await this.sdk.auth.signInWithOAuth({
+      provider,
+      redirectTo: redirectTo || window.location.origin + (this.config.afterSignInUrl || "/")
+    });
+    if (sdkResult.error) {
+      throw new Error(sdkResult.error.message);
+    }
+  }
+  async getPublicAuthConfig() {
+    try {
+      const result = await this.sdk.auth.getPublicAuthConfig();
+      if (result.data) {
+        return result.data;
       } else {
-        return {
-          error: {
-            message: sdkResult.error?.message || "Failed to exchange reset password token"
-          }
-        };
-      }
-    },
-    [insforge]
-  );
-  const loginWithOAuth = react.useCallback(
-    async (provider, redirectTo) => {
-      const sdkResult = await insforge.auth.signInWithOAuth({
-        provider,
-        redirectTo: redirectTo || window.location.origin + afterSignInUrl
-      });
-      if (sdkResult.error) {
-        throw new Error(sdkResult.error.message);
+        console.error("[InsforgeManager] Failed to get public auth config:", result.error);
+        return null;
       }
-    },
-    [insforge, afterSignInUrl]
-  );
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    InsforgeContext.Provider,
-    {
-      value: {
-        user,
-        isLoaded,
-        isSignedIn: !!user,
-        setUser,
-        signIn,
-        signUp,
-        signOut,
-        updateUser,
-        reloadAuth: loadAuthState,
-        sendVerificationEmail,
-        sendResetPasswordEmail,
-        resetPassword,
-        verifyEmail,
-        exchangeResetPasswordToken,
-        getPublicAuthConfig,
-        loginWithOAuth,
-        baseUrl,
-        afterSignInUrl
-      },
-      children
+    } catch (error) {
+      console.error("[InsforgeManager] Failed to get public auth config:", error);
+      return null;
+    }
+  }
+  setUser(user) {
+    this.user = user;
+    if (this.config.onAuthChange) {
+      this.config.onAuthChange(user);
+    }
+    this.notifyListeners();
+  }
+  getConfig() {
+    return this.config;
+  }
+  getSDK() {
+    return this.sdk;
+  }
+  // Handle OAuth callback
+  handleOAuthCallback(isLoaded, user) {
+    if (!isLoaded || this.hasProcessedCallbackRef) {
+      return false;
+    }
+    const searchParams = new URLSearchParams(window.location.search);
+    const accessToken = searchParams.get("access_token");
+    if (accessToken && !!user) {
+      this.hasProcessedCallbackRef = true;
+      const url = new URL(window.location.href);
+      url.search = "";
+      window.history.replaceState({}, "", url.toString());
+      setTimeout(() => {
+        window.location.href = this.config.afterSignInUrl || "/";
+      }, 100);
+      return true;
+    }
+    return false;
+  }
+  // Cleanup
+  cleanup() {
+    if (this.refreshIntervalRef) {
+      clearInterval(this.refreshIntervalRef);
+      this.refreshIntervalRef = null;
     }
+    this.listeners.clear();
+  }
+};
+// Static private instance
+__publicField(_InsforgeManager, "instance", null);
+var InsforgeManager = _InsforgeManager;
+var InsforgeContext = react.createContext(void 0);
+InsforgeContext.displayName = "InsforgeContext";
+function InsforgeProviderCore({
+  children,
+  baseUrl,
+  afterSignInUrl = "/",
+  onAuthChange,
+  onSignIn,
+  onSignOut
+}) {
+  const manager = react.useMemo(
+    () => InsforgeManager.getInstance({
+      baseUrl,
+      afterSignInUrl,
+      onAuthChange,
+      onSignIn,
+      onSignOut
+    }),
+    [baseUrl, afterSignInUrl, onAuthChange, onSignIn, onSignOut]
+  );
+  const [state, setState] = react.useState(() => manager.getState());
+  react.useEffect(() => {
+    const unsubscribe = manager.subscribe((newState) => {
+      setState(newState);
+    });
+    manager.initialize();
+    return unsubscribe;
+  }, [manager]);
+  react.useEffect(() => {
+    if (typeof window !== "undefined") {
+      manager.handleOAuthCallback(state.isLoaded, state.user);
+    }
+  }, [manager, state.isLoaded, state.user]);
+  const contextValue = react.useMemo(
+    () => ({
+      // State from Manager
+      user: state.user,
+      isLoaded: state.isLoaded,
+      isSignedIn: state.isSignedIn,
+      // Methods delegated to Manager
+      setUser: (user) => manager.setUser(user),
+      signIn: (email, password) => manager.signIn(email, password),
+      signUp: (email, password) => manager.signUp(email, password),
+      signOut: () => manager.signOut(),
+      updateUser: (data) => manager.updateUser(data),
+      reloadAuth: () => manager.reloadAuth(),
+      sendVerificationEmail: (email) => manager.sendVerificationEmail(email),
+      sendResetPasswordEmail: (email) => manager.sendResetPasswordEmail(email),
+      resetPassword: (token, newPassword) => manager.resetPassword(token, newPassword),
+      verifyEmail: (otp, email) => manager.verifyEmail(otp, email),
+      exchangeResetPasswordToken: (email, code) => manager.exchangeResetPasswordToken(email, code),
+      loginWithOAuth: (provider, redirectTo) => manager.loginWithOAuth(provider, redirectTo),
+      getPublicAuthConfig: () => manager.getPublicAuthConfig(),
+      // Config
+      baseUrl: manager.getConfig().baseUrl,
+      afterSignInUrl: manager.getConfig().afterSignInUrl || "/"
+    }),
+    [state, manager]
   );
+  return /* @__PURE__ */ jsxRuntime.jsx(InsforgeContext.Provider, { value: contextValue, children });
 }
 function InsforgeProvider(props) {
   return /* @__PURE__ */ jsxRuntime.jsx(NavigationProvider, { adapter: BrowserNavigationAdapter, children: /* @__PURE__ */ jsxRuntime.jsx(InsforgeProviderCore, { ...props }) });