@passgage/sdk-react-native 1.0.1

package/dist/index.js

@@ -0,0 +1,721 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.tsx
+var index_exports = {};
+__export(index_exports, {
+  PassgageAccessProvider: () => PassgageAccessProvider,
+  SDK_VERSION: () => SDK_VERSION,
+  useCheckIn: () => useCheckIn,
+  useLocation: () => useLocation,
+  useNFCScanner: () => useNFCScanner,
+  usePassgageAccess: () => usePassgageAccess,
+  usePassgageAuth: () => usePassgageAuth,
+  useQRScanner: () => useQRScanner,
+  useRemoteWork: () => useRemoteWork
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/providers/PassgageAccessProvider.tsx
+var import_react = __toESM(require("react"));
+var import_sdk_core = require("@passgage/sdk-core");
+
+// src/utils/secureStorage.ts
+var Keychain = __toESM(require("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 = (0, import_react.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 } = (0, import_react.useMemo)(() => {
+    const secureStorage = createSecureStorage();
+    let authService;
+    const client = (0, import_sdk_core.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 import_sdk_core.AuthService(client);
+    authService.setTokenStorage(secureStorage);
+    const allServices = {
+      authService,
+      qrAccessService: new import_sdk_core.QRAccessService(client),
+      nfcAccessService: new import_sdk_core.NFCAccessService(client),
+      checkInService: new import_sdk_core.CheckInService(client),
+      remoteWorkService: new import_sdk_core.RemoteWorkService(client),
+      deviceAccessService: new import_sdk_core.DeviceAccessService(client),
+      locationService: new import_sdk_core.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__ */ import_react.default.createElement(PassgageAccessContext.Provider, { value: contextValue }, children);
+}
+function usePassgageAccess() {
+  const context = (0, import_react.useContext)(PassgageAccessContext);
+  if (!context) {
+    throw new Error(
+      "usePassgageAccess must be used within a PassgageAccessProvider"
+    );
+  }
+  return context;
+}
+
+// src/hooks/usePassgageAuth.ts
+var import_react2 = require("react");
+function usePassgageAuth(options = {}) {
+  const {
+    onLoginSuccess,
+    onLoginError,
+    onLogoutSuccess,
+    autoRestore = true
+  } = options;
+  const { authService } = usePassgageAccess();
+  const [isAuthenticated, setIsAuthenticated] = (0, import_react2.useState)(false);
+  const [user, setUser] = (0, import_react2.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  (0, import_react2.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 = (0, import_react2.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 = (0, import_react2.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 = (0, import_react2.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 = (0, import_react2.useCallback)(() => {
+    setError(null);
+  }, []);
+  return {
+    login,
+    logout,
+    refreshToken,
+    isAuthenticated,
+    user,
+    isLoading,
+    error,
+    clearError
+  };
+}
+
+// src/hooks/useQRScanner.ts
+var import_react4 = require("react");
+
+// src/hooks/useLocation.ts
+var import_react3 = require("react");
+var import_geolocation = __toESM(require("@react-native-community/geolocation"));
+function useLocation(options = {}) {
+  const [location, setLocation] = (0, import_react3.useState)(null);
+  const [error, setError] = (0, import_react3.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react3.useState)(true);
+  const config = {
+    enableHighAccuracy: options.enableHighAccuracy ?? true,
+    timeout: options.timeout ?? 15e3,
+    maximumAge: options.maximumAge ?? 1e4
+  };
+  const refreshLocation = (0, import_react3.useCallback)(async () => {
+    setIsLoading(true);
+    setError(null);
+    return new Promise((resolve) => {
+      import_geolocation.default.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]);
+  (0, import_react3.useEffect)(() => {
+    refreshLocation();
+    if (options.watchPosition) {
+      const watchId = import_geolocation.default.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 () => {
+        import_geolocation.default.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] = (0, import_react4.useState)(false);
+  const [error, setError] = (0, import_react4.useState)(null);
+  const scan = (0, import_react4.useCallback)(
+    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
+var import_react5 = require("react");
+var import_react_native_nfc_manager = __toESM(require("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] = (0, import_react5.useState)(false);
+  const [error, setError] = (0, import_react5.useState)(null);
+  const stopScanning = (0, import_react5.useCallback)(async () => {
+    try {
+      await import_react_native_nfc_manager.default.cancelTechnologyRequest();
+      setIsScanning(false);
+    } catch {
+    }
+  }, []);
+  const handleNFCTag = (0, import_react5.useCallback)(
+    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 = (0, import_react5.useCallback)(async () => {
+    setIsScanning(true);
+    setError(null);
+    try {
+      await import_react_native_nfc_manager.default.requestTechnology(import_react_native_nfc_manager.NfcTech.Ndef, {
+        invalidateAfterFirstRead: true
+      });
+      const tag = await import_react_native_nfc_manager.default.getTag();
+      await handleNFCTag(tag || {});
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      options.onError?.(error2);
+      setIsScanning(false);
+    }
+  }, [handleNFCTag, options]);
+  (0, import_react5.useEffect)(() => {
+    if (options.autoStart) {
+      startScanning();
+    }
+    return () => {
+      stopScanning();
+    };
+  }, [options.autoStart, startScanning, stopScanning]);
+  return {
+    startScanning,
+    stopScanning,
+    isScanning,
+    error
+  };
+}
+
+// src/hooks/useCheckIn.ts
+var import_react6 = require("react");
+function useCheckIn(options = {}) {
+  const { checkInService, config: _config } = usePassgageAccess();
+  const { location } = useLocation();
+  const [nearbyBranches, setNearbyBranches] = (0, import_react6.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react6.useState)(false);
+  const [error, setError] = (0, import_react6.useState)(null);
+  const fetchNearbyBranches = (0, import_react6.useCallback)(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 = (0, import_react6.useCallback)(
+    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]
+  );
+  (0, import_react6.useEffect)(() => {
+    if (options.autoFetch && location) {
+      fetchNearbyBranches();
+    }
+  }, [options.autoFetch, location, fetchNearbyBranches]);
+  return {
+    nearbyBranches,
+    fetchNearbyBranches,
+    checkIn,
+    isLoading,
+    error
+  };
+}
+
+// src/hooks/useRemoteWork.ts
+var import_react7 = require("react");
+var import_sdk_core2 = require("@passgage/sdk-core");
+function useRemoteWork() {
+  const { remoteWorkService } = usePassgageAccess();
+  const [isLoading, setIsLoading] = (0, import_react7.useState)(false);
+  const [error, setError] = (0, import_react7.useState)(null);
+  const logRemoteWork = (0, import_react7.useCallback)(
+    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 = (0, import_react7.useCallback)(
+    async (options) => {
+      return logRemoteWork(import_sdk_core2.EntranceType.ENTRY, options);
+    },
+    [logRemoteWork]
+  );
+  const logExit = (0, import_react7.useCallback)(
+    async (options) => {
+      return logRemoteWork(import_sdk_core2.EntranceType.EXIT, options);
+    },
+    [logRemoteWork]
+  );
+  return {
+    logEntry,
+    logExit,
+    logRemoteWork,
+    isLoading,
+    error
+  };
+}
+
+// src/index.tsx
+var SDK_VERSION = "1.0.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PassgageAccessProvider,
+  SDK_VERSION,
+  useCheckIn,
+  useLocation,
+  useNFCScanner,
+  usePassgageAccess,
+  usePassgageAuth,
+  useQRScanner,
+  useRemoteWork
+});