@passgage/sdk-react-native 1.0.1

package/dist/index.mjs

@@ -0,0 +1,685 @@
+// src/providers/PassgageAccessProvider.tsx
+import React, { createContext, useContext, useMemo } from "react";
+import {
+  createApiClient,
+  AuthService,
+  QRAccessService,
+  NFCAccessService,
+  CheckInService,
+  RemoteWorkService,
+  DeviceAccessService,
+  LocationService
+} from "@passgage/sdk-core";
+
+// src/utils/secureStorage.ts
+import * as Keychain from "react-native-keychain";
+var STORAGE_KEYS = {
+  TOKENS: "passgage_auth_tokens",
+  USER: "passgage_user_info"
+};
+var SecureStorage = class {
+  /**
+   * Save tokens to secure storage
+   */
+  async saveTokens(tokens) {
+    try {
+      await Keychain.setGenericPassword(
+        STORAGE_KEYS.TOKENS,
+        JSON.stringify(tokens),
+        {
+          service: STORAGE_KEYS.TOKENS,
+          accessible: Keychain.ACCESSIBLE.WHEN_UNLOCKED
+        }
+      );
+    } catch (error) {
+      console.error("Failed to save tokens to secure storage:", error);
+      throw new Error("Failed to save tokens");
+    }
+  }
+  /**
+   * Get tokens from secure storage
+   */
+  async getTokens() {
+    try {
+      const credentials = await Keychain.getGenericPassword({
+        service: STORAGE_KEYS.TOKENS
+      });
+      if (!credentials) {
+        return null;
+      }
+      const tokens = JSON.parse(credentials.password);
+      return tokens;
+    } catch (error) {
+      console.error("Failed to get tokens from secure storage:", error);
+      return null;
+    }
+  }
+  /**
+   * Clear tokens from secure storage
+   */
+  async clearTokens() {
+    try {
+      await Keychain.resetGenericPassword({
+        service: STORAGE_KEYS.TOKENS
+      });
+    } catch (error) {
+      console.error("Failed to clear tokens from secure storage:", error);
+    }
+  }
+  /**
+   * Save user information
+   */
+  async saveUser(user) {
+    try {
+      await Keychain.setGenericPassword(
+        STORAGE_KEYS.USER,
+        JSON.stringify(user),
+        {
+          service: STORAGE_KEYS.USER,
+          accessible: Keychain.ACCESSIBLE.WHEN_UNLOCKED
+        }
+      );
+    } catch (error) {
+      console.error("Failed to save user to secure storage:", error);
+      throw new Error("Failed to save user");
+    }
+  }
+  /**
+   * Get user information
+   */
+  async getUser() {
+    try {
+      const credentials = await Keychain.getGenericPassword({
+        service: STORAGE_KEYS.USER
+      });
+      if (!credentials) {
+        return null;
+      }
+      const user = JSON.parse(credentials.password);
+      return user;
+    } catch (error) {
+      console.error("Failed to get user from secure storage:", error);
+      return null;
+    }
+  }
+  /**
+   * Clear user information
+   */
+  async clearUser() {
+    try {
+      await Keychain.resetGenericPassword({
+        service: STORAGE_KEYS.USER
+      });
+    } catch (error) {
+      console.error("Failed to clear user from secure storage:", error);
+    }
+  }
+  /**
+   * Clear all data (tokens + user)
+   */
+  async clearAll() {
+    await this.clearTokens();
+    await this.clearUser();
+  }
+};
+function createSecureStorage() {
+  return new SecureStorage();
+}
+
+// src/providers/PassgageAccessProvider.tsx
+var PassgageAccessContext = createContext(void 0);
+function PassgageAccessProvider({
+  children,
+  baseURL,
+  token,
+  apiVersion = "v2",
+  timeout = 3e4,
+  onUnauthorized,
+  onError
+}) {
+  const config = {
+    baseURL,
+    token,
+    apiVersion,
+    timeout,
+    onUnauthorized,
+    onError
+  };
+  const { apiClient, services } = useMemo(() => {
+    const secureStorage = createSecureStorage();
+    let authService;
+    const client = createApiClient({
+      baseURL: config.baseURL,
+      token: config.token,
+      apiVersion: config.apiVersion,
+      timeout: config.timeout,
+      onUnauthorized: config.onUnauthorized,
+      onError: config.onError,
+      onTokenRefreshNeeded: async () => {
+        const storedTokens = await authService.getStoredTokens();
+        if (!storedTokens) {
+          return null;
+        }
+        const result = await authService.refreshToken(storedTokens.refresh.token);
+        if (result.success) {
+          return result.tokens.access.token;
+        }
+        return null;
+      }
+    });
+    authService = new AuthService(client);
+    authService.setTokenStorage(secureStorage);
+    const allServices = {
+      authService,
+      qrAccessService: new QRAccessService(client),
+      nfcAccessService: new NFCAccessService(client),
+      checkInService: new CheckInService(client),
+      remoteWorkService: new RemoteWorkService(client),
+      deviceAccessService: new DeviceAccessService(client),
+      locationService: new LocationService(client)
+    };
+    return {
+      apiClient: client,
+      services: allServices
+    };
+  }, [config.baseURL, config.token, config.apiVersion, config.timeout, config.onUnauthorized, config.onError]);
+  const setToken = (newToken) => {
+    apiClient.setToken(newToken);
+  };
+  const clearToken = () => {
+    apiClient.clearToken();
+  };
+  const contextValue = {
+    apiClient,
+    ...services,
+    config,
+    setToken,
+    clearToken
+  };
+  return /* @__PURE__ */ React.createElement(PassgageAccessContext.Provider, { value: contextValue }, children);
+}
+function usePassgageAccess() {
+  const context = useContext(PassgageAccessContext);
+  if (!context) {
+    throw new Error(
+      "usePassgageAccess must be used within a PassgageAccessProvider"
+    );
+  }
+  return context;
+}
+
+// src/hooks/usePassgageAuth.ts
+import { useState, useEffect, useCallback } from "react";
+function usePassgageAuth(options = {}) {
+  const {
+    onLoginSuccess,
+    onLoginError,
+    onLogoutSuccess,
+    autoRestore = true
+  } = options;
+  const { authService } = usePassgageAccess();
+  const [isAuthenticated, setIsAuthenticated] = useState(false);
+  const [user, setUser] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    if (!autoRestore) {
+      return;
+    }
+    const restoreAuth = async () => {
+      try {
+        setIsLoading(true);
+        const authenticated = await authService.isAuthenticated();
+        if (authenticated) {
+          const storedTokens = await authService.getStoredTokens();
+          const storedUser = await authService.getStoredUser();
+          if (storedTokens && storedUser) {
+            authService["apiClient"].setToken(storedTokens.access.token);
+            setIsAuthenticated(true);
+            setUser(storedUser);
+            try {
+              const userResult = await authService.getCurrentUser();
+              if (userResult.success) {
+                setUser(userResult.user);
+              }
+            } catch (error2) {
+              console.warn("Failed to fetch fresh user info:", error2);
+            }
+          }
+        }
+      } catch (error2) {
+        console.error("Failed to restore authentication:", error2);
+        setError(error2.message || "Failed to restore authentication");
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    restoreAuth();
+  }, [authService, autoRestore]);
+  const login = useCallback(
+    async (credentials) => {
+      try {
+        setIsLoading(true);
+        setError(null);
+        const result = await authService.login(credentials);
+        if (result.success) {
+          setIsAuthenticated(true);
+          setUser(result.user || null);
+          if (onLoginSuccess) {
+            onLoginSuccess(result.user);
+          }
+        } else {
+          setError(result.error);
+          if (onLoginError) {
+            onLoginError(result.error);
+          }
+        }
+        return result;
+      } catch (error2) {
+        const errorMessage = error2.message || "An error occurred during login";
+        setError(errorMessage);
+        if (onLoginError) {
+          onLoginError(errorMessage);
+        }
+        return {
+          success: false,
+          error: errorMessage,
+          code: "UNKNOWN_ERROR"
+        };
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [authService, onLoginSuccess, onLoginError]
+  );
+  const logout = useCallback(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      await authService.logout();
+      setIsAuthenticated(false);
+      setUser(null);
+      if (onLogoutSuccess) {
+        onLogoutSuccess();
+      }
+    } catch (error2) {
+      const errorMessage = error2.message || "An error occurred during logout";
+      setError(errorMessage);
+      console.error("Logout failed:", error2);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [authService, onLogoutSuccess]);
+  const refreshToken = useCallback(async () => {
+    try {
+      const storedTokens = await authService.getStoredTokens();
+      if (!storedTokens) {
+        return false;
+      }
+      const result = await authService.refreshToken(storedTokens.refresh.token);
+      if (result.success) {
+        return true;
+      } else {
+        await logout();
+        return false;
+      }
+    } catch (error2) {
+      console.error("Token refresh failed:", error2);
+      await logout();
+      return false;
+    }
+  }, [authService, logout]);
+  const clearError = useCallback(() => {
+    setError(null);
+  }, []);
+  return {
+    login,
+    logout,
+    refreshToken,
+    isAuthenticated,
+    user,
+    isLoading,
+    error,
+    clearError
+  };
+}
+
+// src/hooks/useQRScanner.ts
+import { useState as useState3, useCallback as useCallback3 } from "react";
+
+// src/hooks/useLocation.ts
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2 } from "react";
+import Geolocation from "@react-native-community/geolocation";
+function useLocation(options = {}) {
+  const [location, setLocation] = useState2(null);
+  const [error, setError] = useState2(null);
+  const [isLoading, setIsLoading] = useState2(true);
+  const config = {
+    enableHighAccuracy: options.enableHighAccuracy ?? true,
+    timeout: options.timeout ?? 15e3,
+    maximumAge: options.maximumAge ?? 1e4
+  };
+  const refreshLocation = useCallback2(async () => {
+    setIsLoading(true);
+    setError(null);
+    return new Promise((resolve) => {
+      Geolocation.getCurrentPosition(
+        (position) => {
+          setLocation({
+            latitude: position.coords.latitude,
+            longitude: position.coords.longitude,
+            accuracy: position.coords.accuracy,
+            altitude: position.coords.altitude ?? void 0,
+            altitudeAccuracy: position.coords.altitudeAccuracy ?? void 0,
+            heading: position.coords.heading ?? void 0,
+            speed: position.coords.speed ?? void 0
+          });
+          setIsLoading(false);
+          resolve();
+        },
+        (err) => {
+          setError(new Error(err.message));
+          setIsLoading(false);
+          resolve();
+        },
+        config
+      );
+    });
+  }, [config.enableHighAccuracy, config.timeout, config.maximumAge]);
+  useEffect2(() => {
+    refreshLocation();
+    if (options.watchPosition) {
+      const watchId = Geolocation.watchPosition(
+        (position) => {
+          setLocation({
+            latitude: position.coords.latitude,
+            longitude: position.coords.longitude,
+            accuracy: position.coords.accuracy,
+            altitude: position.coords.altitude ?? void 0,
+            altitudeAccuracy: position.coords.altitudeAccuracy ?? void 0,
+            heading: position.coords.heading ?? void 0,
+            speed: position.coords.speed ?? void 0
+          });
+        },
+        (err) => {
+          setError(new Error(err.message));
+        },
+        config
+      );
+      return () => {
+        Geolocation.clearWatch(watchId);
+      };
+    }
+    return void 0;
+  }, [options.watchPosition, refreshLocation]);
+  return {
+    location,
+    error,
+    isLoading,
+    refreshLocation
+  };
+}
+
+// src/hooks/useQRScanner.ts
+function useQRScanner(options = {}) {
+  const { qrAccessService, deviceAccessService } = usePassgageAccess();
+  const { location } = useLocation();
+  const [isLoading, setIsLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const scan = useCallback3(
+    async (qrCode, device) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        let qrDevice = device;
+        if (!qrDevice) {
+          qrDevice = await deviceAccessService.findDeviceByQRCode(qrCode);
+          if (!qrDevice) {
+            throw new Error("QR device not found");
+          }
+        }
+        const result = await qrAccessService.validateQR({
+          qrCode,
+          device: qrDevice,
+          userLocation: location || void 0,
+          skipLocationCheck: options.skipLocationCheck,
+          skipRepetitiveCheck: options.skipRepetitiveCheck
+        });
+        if (!result.success) {
+          throw new Error(result.message);
+        }
+        options.onSuccess?.(result.entrance);
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        options.onError?.(error2);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [qrAccessService, deviceAccessService, location, options]
+  );
+  return {
+    scan,
+    isLoading,
+    error
+  };
+}
+
+// src/hooks/useNFCScanner.ts
+import { useState as useState4, useCallback as useCallback4, useEffect as useEffect3 } from "react";
+import NfcManager, { NfcTech } from "react-native-nfc-manager";
+function reversedHexToDec(hexString) {
+  const hex = hexString.replace(/:/g, "");
+  return parseInt(hex, 16).toString();
+}
+function useNFCScanner(options = {}) {
+  const { nfcAccessService, deviceAccessService } = usePassgageAccess();
+  const { location } = useLocation();
+  const [isScanning, setIsScanning] = useState4(false);
+  const [error, setError] = useState4(null);
+  const stopScanning = useCallback4(async () => {
+    try {
+      await NfcManager.cancelTechnologyRequest();
+      setIsScanning(false);
+    } catch {
+    }
+  }, []);
+  const handleNFCTag = useCallback4(
+    async (tag) => {
+      if (!tag.id) {
+        return;
+      }
+      try {
+        const nfcCode = reversedHexToDec(tag.id);
+        const device = await deviceAccessService.findDeviceByNFCCode(nfcCode);
+        if (!device) {
+          throw new Error("NFC device not found");
+        }
+        const result = await nfcAccessService.validateNFC({
+          nfcCode,
+          device,
+          userLocation: location || void 0,
+          skipLocationCheck: options.skipLocationCheck,
+          skipRepetitiveCheck: options.skipRepetitiveCheck
+        });
+        if (!result.success) {
+          throw new Error(result.message);
+        }
+        options.onSuccess?.(result.entrance);
+        await stopScanning();
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        options.onError?.(error2);
+        await stopScanning();
+      }
+    },
+    [nfcAccessService, deviceAccessService, location, options, stopScanning]
+  );
+  const startScanning = useCallback4(async () => {
+    setIsScanning(true);
+    setError(null);
+    try {
+      await NfcManager.requestTechnology(NfcTech.Ndef, {
+        invalidateAfterFirstRead: true
+      });
+      const tag = await NfcManager.getTag();
+      await handleNFCTag(tag || {});
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      options.onError?.(error2);
+      setIsScanning(false);
+    }
+  }, [handleNFCTag, options]);
+  useEffect3(() => {
+    if (options.autoStart) {
+      startScanning();
+    }
+    return () => {
+      stopScanning();
+    };
+  }, [options.autoStart, startScanning, stopScanning]);
+  return {
+    startScanning,
+    stopScanning,
+    isScanning,
+    error
+  };
+}
+
+// src/hooks/useCheckIn.ts
+import { useState as useState5, useEffect as useEffect4, useCallback as useCallback5 } from "react";
+function useCheckIn(options = {}) {
+  const { checkInService, config: _config } = usePassgageAccess();
+  const { location } = useLocation();
+  const [nearbyBranches, setNearbyBranches] = useState5([]);
+  const [isLoading, setIsLoading] = useState5(false);
+  const [error, setError] = useState5(null);
+  const fetchNearbyBranches = useCallback5(async () => {
+    if (!location) {
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await checkInService.getNearbyBranches({
+        latitude: location.latitude,
+        longitude: location.longitude,
+        radius: options.radius
+      });
+      if (response.success && response.data) {
+        setNearbyBranches(response.data);
+      }
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [checkInService, location, options.radius]);
+  const checkIn = useCallback5(
+    async (params) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const userId = "";
+        const result = await checkInService.checkIn({
+          ...params,
+          userId,
+          userLocation: location || void 0
+        });
+        if (!result.success) {
+          throw new Error(result.message);
+        }
+        return result.entrance;
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [checkInService, location]
+  );
+  useEffect4(() => {
+    if (options.autoFetch && location) {
+      fetchNearbyBranches();
+    }
+  }, [options.autoFetch, location, fetchNearbyBranches]);
+  return {
+    nearbyBranches,
+    fetchNearbyBranches,
+    checkIn,
+    isLoading,
+    error
+  };
+}
+
+// src/hooks/useRemoteWork.ts
+import { useState as useState6, useCallback as useCallback6 } from "react";
+import { EntranceType } from "@passgage/sdk-core";
+function useRemoteWork() {
+  const { remoteWorkService } = usePassgageAccess();
+  const [isLoading, setIsLoading] = useState6(false);
+  const [error, setError] = useState6(null);
+  const logRemoteWork = useCallback6(
+    async (entranceType, options = {}) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const userId = "";
+        const result = await remoteWorkService.logRemoteWork({
+          userId,
+          entranceType,
+          timestamp: options.timestamp,
+          description: options.description
+        });
+        if (!result.success) {
+          throw new Error(result.message);
+        }
+        return result.entrance;
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [remoteWorkService]
+  );
+  const logEntry = useCallback6(
+    async (options) => {
+      return logRemoteWork(EntranceType.ENTRY, options);
+    },
+    [logRemoteWork]
+  );
+  const logExit = useCallback6(
+    async (options) => {
+      return logRemoteWork(EntranceType.EXIT, options);
+    },
+    [logRemoteWork]
+  );
+  return {
+    logEntry,
+    logExit,
+    logRemoteWork,
+    isLoading,
+    error
+  };
+}
+
+// src/index.tsx
+var SDK_VERSION = "1.0.0";
+export {
+  PassgageAccessProvider,
+  SDK_VERSION,
+  useCheckIn,
+  useLocation,
+  useNFCScanner,
+  usePassgageAccess,
+  usePassgageAuth,
+  useQRScanner,
+  useRemoteWork
+};