@savers_app/react-native-sdk 1.1.0

package/src/services/permissions/permissionManager.ts

@@ -0,0 +1,33 @@
+// React Native Core
+import { Platform, PermissionsAndroid } from 'react-native';
+
+export const requestPermission = async (
+  permission: Parameters<typeof PermissionsAndroid.request>[0]
+) => {
+  if (Platform.OS === 'ios') return true;
+
+  const already = await PermissionsAndroid.check(permission);
+  if (already) return true;
+  const result = await PermissionsAndroid.request(permission);
+  if (result === PermissionsAndroid.RESULTS.NEVER_ASK_AGAIN) return false;
+  return result === PermissionsAndroid.RESULTS.GRANTED;
+};
+
+export async function ensureLocationPermission(): Promise<boolean> {
+  if (Platform.OS === 'ios') return true;
+  const fine = PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION;
+  const coarse = PermissionsAndroid.PERMISSIONS.ACCESS_COARSE_LOCATION;
+  const fineGranted = await PermissionsAndroid.check(fine);
+  const coarseGranted = await PermissionsAndroid.check(coarse);
+  if (fineGranted || coarseGranted) return true;
+  const res = await PermissionsAndroid.requestMultiple([fine, coarse]);
+  const fineOk = res[fine] === PermissionsAndroid.RESULTS.GRANTED;
+  const coarseOk = res[coarse] === PermissionsAndroid.RESULTS.GRANTED;
+  if (
+    res[fine] === PermissionsAndroid.RESULTS.NEVER_ASK_AGAIN ||
+    res[coarse] === PermissionsAndroid.RESULTS.NEVER_ASK_AGAIN
+  ) {
+    return false;
+  }
+  return fineOk || coarseOk;
+}

package/src/services/url/urlGenerator.ts

@@ -0,0 +1,132 @@
+// Utilities / Helpers
+import { SDKError } from '../../utils/errors';
+import { aesEncrypt } from '../../utils/encryption';
+
+// Storage / Session
+import { getDeviceId } from '../../data/storage/deviceIdManager';
+import { getSessionId } from '../../data/storage/sessionManager';
+import { getLocationCoordinates } from '../../data/storage/locationManager';
+import { getEncryptionKey, getPRefCode } from '../../data/storage/keysManager';
+
+export type Attribute = { key: string; value: string };
+export type Screen = { name?: string; attributes?: Attribute[] };
+export type Profile = {
+  userId: string;
+  phone?: string;
+  firstname: string;
+  lastname: string;
+  email: string;
+  dob?: string;
+  pv?: '0' | '1';
+  ev?: '0' | '1';
+  city?: string;
+  zipcode?: string;
+  referrer_user_id?: string;
+  username?: string;
+};
+export type AuthType = 'PHONE' | 'EMAIL' | 'USERNAME';
+export type DeviceInfo = {
+  dId: string;
+  location?: { lat: number; lng: number };
+};
+
+export type UrlInput = {
+  screen?: Screen;
+  profile: Profile;
+  authType?: AuthType;
+  deviceInfo?: DeviceInfo;
+  sessionId?: string;
+};
+export function validateInput(input: UrlInput): {
+  ok: boolean;
+  errors: string[];
+} {
+  const errors: string[] = [];
+  const auth = input.authType ?? 'PHONE';
+  if (!input.profile) errors.push('profile is mandatory');
+  if (!input.profile?.userId) errors.push('userId is mandatory');
+  if (!input.profile?.email) errors.push('email is mandatory');
+  const pv = input.profile?.pv;
+  const ev = input.profile?.ev;
+  if (typeof pv !== 'undefined' && pv !== '0' && pv !== '1') {
+    errors.push('pv must be 0 or 1');
+  }
+  if (typeof ev !== 'undefined' && ev !== '0' && ev !== '1') {
+    errors.push('ev must be 0 or 1');
+  }
+  if (!auth) errors.push('authType is mandatory');
+
+  if (auth === 'USERNAME' && !input.profile?.username) {
+    errors.push('username is mandatory for USERNAME authType');
+  }
+  if (auth === 'PHONE' && !input.profile?.phone) {
+    errors.push('phone is mandatory for PHONE authType');
+  }
+
+  const screenName = input.screen?.name;
+  if (screenName === 'OfrDetails') {
+    const attrs = input.screen?.attributes ?? [];
+    if (!attrs.length) {
+      errors.push(
+        'screen.attributes is mandatory when screen.name is OfrDetails'
+      );
+    }
+  }
+
+  return { ok: errors.length === 0, errors };
+}
+
+export async function generateUrl(input: UrlInput): Promise<string> {
+  const deviceId = await getDeviceId();
+  const storedLocation = await getLocationCoordinates();
+  const sessionId = await getSessionId();
+
+  const deviceInfo: DeviceInfo =
+    storedLocation != null
+      ? { dId: deviceId, location: storedLocation }
+      : { dId: deviceId };
+
+  const normalized: Required<Pick<UrlInput, 'profile'>> &
+    Pick<UrlInput, 'screen' | 'authType' | 'sessionId'> & {
+      deviceInfo: DeviceInfo;
+    } = {
+    profile: input.profile,
+    screen: input.screen,
+    authType: input.authType ?? 'PHONE',
+    sessionId: sessionId ?? '',
+    deviceInfo,
+  };
+
+  const validation = validateInput({
+    ...normalized,
+    deviceInfo: normalized.deviceInfo,
+  });
+  if (!validation.ok) {
+    throw new SDKError(`Validation failed: ${validation.errors.join(', ')}`);
+  }
+
+  const payload = {
+    screen: normalized.screen ?? { name: 'Explore' },
+    profile: normalized.profile,
+    authType: normalized.authType,
+    deviceInfo: normalized.deviceInfo,
+    sessionId: normalized.sessionId,
+  };
+
+  const json = JSON.stringify(payload);
+  const key = await getEncryptionKey();
+  if (!key || key === '-') {
+    throw new SDKError(
+      'Encryption key is mandatory. Initialize SDK with encryptionKey.'
+    );
+  }
+  const encoded = await aesEncrypt(json, key);
+
+  const programCode = await getPRefCode();
+  if (!programCode || programCode === '-') {
+    throw new SDKError('pRefCode is mandatory. Initialize SDK with pRefCode.');
+  }
+  return `https://m.saversapp.com/?pRefCode=${encodeURIComponent(
+    programCode
+  )}&qP=${encodeURIComponent(encoded)}`;
+}

package/src/services/webview/messageHandler.ts

@@ -0,0 +1,48 @@
+// Screens / SDKs / External packages
+import {
+  openMap,
+  openDialPad,
+  openBrowser,
+  closeCurrentScreenSafe,
+  setSessionId,
+} from '@saversapp/react-native-sdk';
+
+export function handleWebMessage(raw: string, postBack?: (data: any) => void) {
+  let msg: { action?: string; payload?: any };
+  try {
+    msg = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  const action = msg?.action;
+  const payload = msg?.payload;
+
+  const reply = (data: any) => postBack?.(data);
+
+  (async () => {
+    try {
+      if (action === 'OPEN_MAP') {
+        const { lat, lng, label } = payload || {};
+        await openMap(lat, lng, label);
+        reply({ ok: true, action });
+      } else if (action === 'SHOW_DIAL_PAD') {
+        await openDialPad(payload?.number);
+        reply({ ok: true, action });
+      } else if (action === 'MERCHANT_PORTAL_REDIRECT') {
+        await openBrowser(payload?.url);
+        reply({ ok: true, action });
+      } else if (action === 'SESSION_ID') {
+        const { sessionId } = payload || {};
+        const id = await setSessionId(sessionId);
+        reply({ ok: true, action, sessionId: id });
+      } else if (action === 'END_SESSION') {
+        closeCurrentScreenSafe();
+        // reply({ ok: true, action, closed });
+      } else {
+        reply({ ok: false, error: 'UNKNOWN_ACTION', action });
+      }
+    } catch (e: any) {
+      reply({ ok: false, error: e?.message ?? String(e), action });
+    }
+  })();
+}

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,58 @@
+// Third-party libraries
+import AesGcmCrypto from 'react-native-aes-gcm-crypto';
+
+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> {
+  if (!isBase64(key) || base64ByteLength(key) !== 32) {
+    throw new Error(
+      'Encryption key must be base64-encoded 32-byte (256-bit) value'
+    );
+  }
+  const { iv, tag, content } = await AesGcmCrypto.encrypt(text, false, key);
+  return base64Encrypt(`${iv}:${content}:${tag}`);
+}
+
+export async function aesDecrypt(
+  ciphertext: string,
+  key: string
+): Promise<string> {
+  if (!isBase64(key) || base64ByteLength(key) !== 32) {
+    throw new Error(
+      'Encryption key must be base64-encoded 32-byte (256-bit) value'
+    );
+  }
+  const parts = ciphertext.split(':');
+  const iv = parts[0] ?? '';
+  const content = parts[1] ?? '';
+  const tag = parts[2] ?? '';
+  const decrypted = await AesGcmCrypto.decrypt(content, key, iv, tag, false);
+  return decrypted;
+}
+
+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;
+}