@savers_app/react-native-sandbox-sdk 1.2.6

package/src/utils/dependencyManager.ts

@@ -0,0 +1,82 @@
+type AsyncStorageModule =
+  | {
+      getItem: (key: string) => Promise<string | null>;
+      setItem: (key: string, value: string) => Promise<void>;
+    }
+  | undefined;
+
+type GeolocationModule =
+  | {
+      getCurrentPosition: (
+        success: (pos: {
+          coords: { latitude: number; longitude: number };
+        }) => void,
+        error?: (err: unknown) => void,
+        options?: {
+          enableHighAccuracy?: boolean;
+          timeout?: number;
+          maximumAge?: number;
+        }
+      ) => void;
+    }
+  | undefined;
+
+type DeviceInfoModule =
+  | {
+      getUniqueId?: () => Promise<string>;
+    }
+  | undefined;
+
+let AsyncStorage: AsyncStorageModule;
+let Geolocation: GeolocationModule;
+let DeviceInfo: DeviceInfoModule;
+
+function loadAsyncStorage(): AsyncStorageModule {
+  try {
+    const mod = require('@react-native-async-storage/async-storage');
+    return mod?.default ?? mod;
+  } catch {
+    return undefined;
+  }
+}
+
+function loadGeolocation(): GeolocationModule {
+  try {
+    const mod = require('@react-native-community/geolocation');
+    return mod?.default ?? mod;
+  } catch {
+    return undefined;
+  }
+}
+
+function loadDeviceInfo(): DeviceInfoModule {
+  try {
+    const mod = require('react-native-device-info');
+    return mod?.default ?? mod;
+  } catch {
+    return undefined;
+  }
+}
+
+export function resolveNativeDependencies() {
+  if (!AsyncStorage) AsyncStorage = loadAsyncStorage();
+  if (!Geolocation) Geolocation = loadGeolocation();
+  if (!DeviceInfo) DeviceInfo = loadDeviceInfo();
+  return {
+    AsyncStorage,
+    Geolocation,
+    DeviceInfo,
+  };
+}
+
+export const SDKRequirements = {
+  get asyncStorage() {
+    return Boolean(resolveNativeDependencies().AsyncStorage);
+  },
+  get geolocation() {
+    return Boolean(resolveNativeDependencies().Geolocation);
+  },
+  get deviceInfo() {
+    return Boolean(resolveNativeDependencies().DeviceInfo);
+  },
+};

package/src/utils/encryption.ts

@@ -0,0 +1,96 @@
+import { NativeModules } from 'react-native';
+import AesGcmCrypto from 'react-native-aes-gcm-crypto';
+
+/**
+ * Ensure native module is installed & linked
+ */
+function ensureAesAvailable() {
+  const nativeModule =
+    NativeModules.AesGcmCrypto || NativeModules.RNAesGcmCrypto;
+
+  if (!AesGcmCrypto || !nativeModule) {
+    throw new Error(
+      'react-native-aes-gcm-crypto is not installed or linked correctly.\n\n' +
+        'Fix:\n' +
+        '1. yarn add react-native-aes-gcm-crypto\n' +
+        '2. cd ios && pod install\n' +
+        '3. Rebuild the app\n'
+    );
+  }
+
+  if (typeof AesGcmCrypto.encrypt !== 'function') {
+    throw new Error(
+      'AES-GCM native functions unavailable. Please rebuild the app.'
+    );
+  }
+}
+
+function isBase64(input: string): boolean {
+  return /^[A-Za-z0-9+/]+={0,2}$/.test(input);
+}
+
+function base64ByteLength(b64: string): number {
+  const cleaned = b64.replace(/[=]+$/, '');
+  return Math.floor((cleaned.length * 3) / 4);
+}
+
+export async function aesEncrypt(text: string, key: string): Promise<string> {
+  ensureAesAvailable();
+
+  if (!isBase64(key) || base64ByteLength(key) !== 32) {
+    throw new Error(
+      'Encryption key must be base64-encoded 32-byte (256-bit) value'
+    );
+  }
+
+  try {
+    const { iv, tag, content } = await AesGcmCrypto.encrypt(text, false, key);
+
+    return base64Encrypt(`${iv}:${content}:${tag}`);
+  } catch (err: any) {
+    throw new Error(`AES encryption failed: ${err?.message || err}`);
+  }
+}
+
+export async function aesDecrypt(
+  ciphertext: string,
+  key: string
+): Promise<string> {
+  ensureAesAvailable();
+
+  if (!isBase64(key) || base64ByteLength(key) !== 32) {
+    throw new Error(
+      'Encryption key must be base64-encoded 32-byte (256-bit) value'
+    );
+  }
+
+  try {
+    const [iv = '', content = '', tag = ''] = ciphertext.split(':');
+
+    const decrypted = await AesGcmCrypto.decrypt(content, key, iv, tag, false);
+
+    return decrypted;
+  } catch (err: any) {
+    throw new Error(`AES decryption failed: ${err?.message || err}`);
+  }
+}
+
+declare function btoa(data: string): string;
+declare function atob(data: string): string;
+
+export function base64Encrypt(plain: string): string {
+  const utf8 = encodeURIComponent(plain).replace(
+    /%([0-9A-F]{2})/g,
+    (_, p1: string) => String.fromCharCode(parseInt(p1, 16))
+  );
+  return btoa(utf8);
+}
+
+export function base64Decrypt(encoded: string): string {
+  const binary = atob(encoded);
+  const utf8 = binary
+    .split('')
+    .map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
+    .join('');
+  return decodeURIComponent(utf8);
+}

package/src/utils/errors.ts

@@ -0,0 +1,6 @@
+export class SDKError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'SDKError';
+  }
+}

package/src/utils/logger.ts

@@ -0,0 +1,11 @@
+export const logger = {
+  info: (...args: unknown[]) => {
+    console.info(...args);
+  },
+  warn: (...args: unknown[]) => {
+    console.warn(...args);
+  },
+  error: (...args: unknown[]) => {
+    console.error(...args);
+  },
+};

package/src/utils/platformManager.ts

@@ -0,0 +1,14 @@
+// React Native Core
+import { Platform } from 'react-native';
+
+export function isIOS(): boolean {
+  return Platform.OS === 'ios';
+}
+
+export function isAndroid(): boolean {
+  return Platform.OS === 'android';
+}
+
+export function platformVersion(): number {
+  return Number(Platform.Version);
+}

package/src/utils/validator.ts

@@ -0,0 +1,29 @@
+// React Native Core
+import { Linking } from 'react-native';
+
+// Platform / Environment helpers
+import { isIOS } from './platformManager';
+
+export function isValidPhoneNumber(input: string): boolean {
+  if (!input) return false;
+  return /^\+?[0-9]{8,15}$/.test(input);
+}
+
+export async function isMapAppAvailable(): Promise<boolean> {
+  if (isIOS()) {
+    // Apple Maps scheme
+    return Linking.canOpenURL('maps:0,0?q=test');
+  }
+  // Android geo scheme
+  return Linking.canOpenURL('geo:0,0?q=0,0');
+}
+
+export async function isValidCoordinates(
+  lat: number,
+  lng: number
+): Promise<boolean> {
+  if (!Number.isFinite(lat) || !Number.isFinite(lng)) return false;
+  if (lat < -90 || lat > 90) return false;
+  if (lng < -180 || lng > 180) return false;
+  return true;
+}