@savers_app/react-native-sandbox-sdk 1.2.6

package/src/data/storage/locationManager.ts

@@ -0,0 +1,39 @@
+class LocationManager {
+  private lat: number | null = null;
+  private lng: number | null = null;
+
+  setCoordinates(lat: number, lng: number): void {
+    this.lat = lat;
+    this.lng = lng;
+  }
+
+  getCoordinates(): { lat: number; lng: number } | null {
+    if (this.lat === null || this.lng === null) {
+      return null;
+    }
+    return { lat: this.lat, lng: this.lng };
+  }
+}
+
+export const locationManager = new LocationManager();
+
+export const setLocationCoordinates = async (
+  lat: number,
+  lng: number
+): Promise<void> => {
+  locationManager.setCoordinates(lat, lng);
+};
+
+export async function getLocationCoordinates(): Promise<{
+  lat: number;
+  lng: number;
+} | null> {
+  return locationManager.getCoordinates();
+}
+
+export function getLocationCoordinatesSync(): {
+  lat: number;
+  lng: number;
+} | null {
+  return locationManager.getCoordinates();
+}

package/src/data/storage/reactRefManager.ts

@@ -0,0 +1,25 @@
+class ReactRefManager {
+  private ref: any | null = null;
+
+  setRef(ref: any): void {
+    this.ref = ref;
+  }
+
+  getRef(): any | null {
+    return this.ref;
+  }
+}
+
+export const reactRefManager = new ReactRefManager();
+
+export const setReactRef = async (ref: any): Promise<void> => {
+  reactRefManager.setRef(ref);
+};
+
+export async function getReactRef(): Promise<any | null> {
+  return reactRefManager.getRef();
+}
+
+export function getReactRefSync(): any | null {
+  return reactRefManager.getRef();
+}

package/src/data/storage/sessionManager.ts

@@ -0,0 +1,11 @@
+// Storage Utilities
+import { storageSet, storageGet } from './asyncStorageManager';
+import { SDK_SESSION_ID } from './storageKeys';
+
+export const setSessionId = async (sessionId: string) => {
+  await storageSet(SDK_SESSION_ID, sessionId);
+};
+
+export const getSessionId = async (): Promise<string | null> => {
+  return storageGet(SDK_SESSION_ID);
+};

package/src/data/storage/storageKeys.ts

@@ -0,0 +1,4 @@
+export const SAVERS_API_KEY = 'SAVERS_API_KEY';
+export const SAVERS_ENCRYPTION_KEY = 'SAVERS_ENCRYPTION_KEY';
+export const SDK_SESSION_ID = 'SDK_SESSION_ID';
+export const SDK_DEVICE_ID = 'SDK_DEVICE_ID';

package/src/data/storage/storageManager.ts

@@ -0,0 +1,83 @@
+// Storage Utilities
+import { storageGet, storageSet, storageRemove } from './asyncStorageManager';
+
+const cachePrefix = 'cache_';
+
+const userIdKey = 'userId';
+const isOnboardingSkipedKey = 'isOnboardingSkipedKey';
+const isAuthSkipedKey = 'isAuthSkipedKey';
+const authSkippedTimestampKey = 'authSkippedTimestamp';
+const userSelectedLocationKey = 'userSelectedLocation';
+const browsingModeKey = 'browsingMode';
+
+export const StorageKeys = {
+  userId: userIdKey,
+  isOnboardingSkiped: isOnboardingSkipedKey,
+  isAuthSkiped: isAuthSkipedKey,
+  authSkippedTimestamp: authSkippedTimestampKey,
+  userSelectedLocation: userSelectedLocationKey,
+  browsingMode: browsingModeKey,
+};
+
+export async function save(key: string, value: any): Promise<void> {
+  const fullKey = cachePrefix + key;
+  let dataToSave: string;
+  if (typeof value === 'string') {
+    dataToSave = value;
+  } else {
+    try {
+      dataToSave = JSON.stringify(value);
+    } catch {
+      dataToSave = String(value);
+    }
+  }
+  await storageSet(fullKey, dataToSave);
+}
+
+export async function get(key: string): Promise<any> {
+  const fullKey = cachePrefix + key;
+  const raw = await storageGet(fullKey);
+  if (raw === null) return null;
+  if (raw.startsWith('{') || raw.startsWith('[')) {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+
+export async function clear(key: string): Promise<void> {
+  const fullKey = cachePrefix + key;
+  await storageRemove(fullKey);
+}
+
+export async function clearAll(): Promise<void> {
+  // Not supported by asyncStorageManager wrapper yet, would need extension.
+  // For now, we'll leave it as a TODO or implement using low level if exposed,
+  // but better to remove direct dependency on @react-native-async-storage/async-storage
+  // to support the unified approach.
+  // However, asyncStorageManager hides the implementation.
+  // Let's rely on the fact that clearAll was mainly for cache.
+  console.warn('clearAll not fully supported in unified storage yet');
+}
+
+export async function saveAuthSkippedTime(): Promise<void> {
+  const timestamp = new Date().toISOString();
+  await save(authSkippedTimestampKey, timestamp);
+}
+
+export async function getAuthSkippedTime(): Promise<Date | null> {
+  const data = await get(authSkippedTimestampKey);
+  if (typeof data === 'string') {
+    try {
+      return new Date(data);
+    } catch {}
+  }
+  return null;
+}
+
+export async function clearAuthSkippedTime(): Promise<void> {
+  await clear(authSkippedTimestampKey);
+}

package/src/index.tsx

@@ -0,0 +1,17 @@
+export * from './services/navigation/openMap';
+export * from './services/navigation/goBackNavigation';
+export * from './services/permissions/permissionManager';
+export * from './utils/platformManager';
+export * from './utils/errors';
+export * from './utils/logger';
+export * from './utils/validator';
+export * from './services/webview/messageHandler';
+export * from './data/storage/deviceIdManager';
+export * from './services/navigation/dialPad';
+export * from './services/navigation/openBrowser';
+export * from './data/storage/sessionManager';
+export * from './services/url/urlGenerator';
+export * from './data/network/apiService';
+export * from './core/runtime';
+export * from './data/storage/keysManager';
+export * from './data/storage/locationManager';

package/src/services/device/location.ts

@@ -0,0 +1,51 @@
+// Platform Utilities
+import { isAndroid } from '../../utils/platformManager';
+import { resolveNativeDependencies } from '../../utils/dependencyManager';
+
+// Permissions
+import { ensureLocationPermission } from '../permissions/permissionManager';
+
+export type DeviceLocation = { lat: number; lng: number };
+
+let locationProvider: (() => Promise<DeviceLocation | undefined>) | undefined;
+
+export function setLocationProvider(
+  provider: () => Promise<DeviceLocation | undefined>
+): void {
+  locationProvider = provider;
+}
+
+export const fetchLocation = async (): Promise<DeviceLocation> => {
+  const { Geolocation } = resolveNativeDependencies();
+  if (!Geolocation) {
+    throw new Error(
+      'GEOLOCATION_NOT_LINKED: install and link @react-native-community/geolocation'
+    );
+  }
+  return new Promise((resolve, reject) => {
+    Geolocation.getCurrentPosition(
+      (pos: { coords: { latitude: number; longitude: number } }) =>
+        resolve({ lat: pos.coords.latitude, lng: pos.coords.longitude }),
+      (err: unknown) => reject(err),
+      { enableHighAccuracy: true, timeout: 10000 }
+    );
+  });
+};
+
+export async function getDeviceLocation(): Promise<DeviceLocation | undefined> {
+  if (locationProvider) {
+    return locationProvider();
+  }
+  if (isAndroid()) {
+    const granted = await ensureLocationPermission();
+    if (!granted) {
+      throw new Error('LOCATION_PERMISSION_DENIED');
+    }
+  }
+  try {
+    const loc = await fetchLocation();
+    return loc;
+  } catch {
+    throw new Error('LOCATION_UNAVAILABLE');
+  }
+}

package/src/services/navigation/dialPad.ts

@@ -0,0 +1,39 @@
+// React Native Core
+import { Linking, Platform } from 'react-native';
+
+// Utilities / Validators
+import { isValidPhoneNumber } from '../../utils/validator';
+
+export const callPhone = async (phone: string): Promise<void> => {
+  if (!isValidPhoneNumber(phone)) {
+    throw new Error('INVALID_PHONE_NUMBER');
+  }
+
+  const url =
+    Platform.OS === 'ios'
+      ? `telprompt:${phone}` // iOS preferred
+      : `tel:${phone}`;
+
+  try {
+    await Linking.openURL(url);
+  } catch {
+    throw new Error('CALL_NOT_SUPPORTED');
+  }
+};
+
+export async function openDialPad(phone?: string): Promise<void> {
+  const url =
+    Platform.OS === 'ios'
+      ? phone
+        ? `telprompt:${phone}`
+        : 'tel:' // open empty dial pad
+      : phone
+        ? `tel:${phone}`
+        : 'tel:';
+
+  try {
+    await Linking.openURL(url);
+  } catch {
+    throw new Error('DIAL_PAD_NOT_SUPPORTED');
+  }
+}

package/src/services/navigation/goBackNavigation.ts

@@ -0,0 +1,19 @@
+// React Native Core
+import { BackHandler, Platform } from 'react-native';
+import { getReactRefSync } from '../../data/storage/reactRefManager';
+
+export function closeCurrentScreen(): boolean {
+  if (getReactRefSync().isReady() && getReactRefSync().canGoBack()) {
+    getReactRefSync().goBack();
+    return true;
+  }
+
+  return false;
+}
+
+export function closeCurrentScreenSafe(): void {
+  const closed = closeCurrentScreen();
+  if (!closed && Platform.OS === 'android') {
+    BackHandler.exitApp();
+  }
+}

package/src/services/navigation/openBrowser.ts

@@ -0,0 +1,6 @@
+// React Native Core
+import { Linking } from 'react-native';
+
+export async function openBrowser(url: string): Promise<void> {
+  await Linking.openURL(url);
+}

package/src/services/navigation/openMap.ts

@@ -0,0 +1,53 @@
+// React Native Core
+import { Linking } from 'react-native';
+
+// Utilities / Helpers
+import { isValidCoordinates } from '../../utils/validator';
+
+// Platform / Environment helpers
+import { isIOS } from '../../utils/platformManager';
+
+export async function openMap(
+  lat: number,
+  lng: number,
+  label?: string
+): Promise<void> {
+  if (!isValidCoordinates(lat, lng)) {
+    throw new Error('INVALID_COORDINATES');
+  }
+
+  const iosUrl = `maps:0,0?q=${encodeURIComponent(label ?? '')}@${lat},${lng}`;
+
+  if (isIOS()) {
+    try {
+      await Linking.openURL(iosUrl);
+      return;
+    } catch {}
+    const browserUrl = `https://maps.apple.com/?q=${encodeURIComponent(
+      label ?? ''
+    )}&ll=${lat},${lng}`;
+    await Linking.openURL(browserUrl);
+    return;
+  }
+
+  const encLabel = label ? encodeURIComponent(label) : undefined;
+  const query = `${lat},${lng}${encLabel ? `(${encLabel})` : ''}`;
+  const candidates = [
+    // Prefer geo to show a pin at the destination (not navigation)
+    `geo:${lat},${lng}?q=${query}`,
+    `geo:0,0?q=${query}`,
+    // Fallback to Google Maps custom scheme as a generic search/pin
+    `comgooglemaps://?q=${query}`,
+  ];
+  for (const url of candidates) {
+    try {
+      await Linking.openURL(url);
+      return;
+    } catch {}
+  }
+  const browserQuery = label ? `${label} ${lat},${lng}` : `${lat},${lng}`;
+  const browserUrl = `https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(
+    browserQuery
+  )}`;
+  await Linking.openURL(browserUrl);
+}

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,140 @@
+// 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';
+
+import { getBaseUrl } from '../../utils/config';
+
+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;
+  nonce: 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');
+  if (!input.nonce) errors.push('nonce 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;
+      nonce: string;
+    } = {
+    profile: input.profile,
+    screen: input.screen,
+    authType: input.authType ?? 'PHONE',
+    sessionId: sessionId ?? '',
+    deviceInfo,
+    nonce: input.nonce,
+  };
+
+  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,
+    nonce: normalized.nonce,
+  };
+
+  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 `${getBaseUrl()}?pRefCode=${encodeURIComponent(
+    programCode
+  )}&qP=${encodeURIComponent(encoded)}`;
+}

package/src/services/webview/messageHandler.ts

@@ -0,0 +1,45 @@
+import { openMap } from '../navigation/openMap';
+import { openDialPad } from '../navigation/dialPad';
+import { openBrowser } from '../navigation/openBrowser';
+import { closeCurrentScreenSafe } from '../navigation/goBackNavigation';
+import { setSessionId } from '../../data/storage/sessionManager';
+
+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/config.ts

@@ -0,0 +1,35 @@
+// config.ts
+
+export type Environment = 'sandbox' | 'production';
+
+// Default environment (build-time injected)
+const injectedEnv = 'sandbox' as string;
+const DEFAULT_ENVIRONMENT: Environment =
+  injectedEnv === 'production' ? 'production' : 'sandbox';
+
+const ENV_URLS: Record<Environment, string> = {
+  sandbox: 'https://testm.saversapp.com/',
+  production: 'https://m.saversapp.com/',
+};
+
+// Current environment
+let currentEnvironment: Environment = DEFAULT_ENVIRONMENT;
+
+// Current base URL
+let BASE_URL: string = ENV_URLS[currentEnvironment];
+
+// Change environment
+export const setEnvironment = (env: Environment) => {
+  currentEnvironment = env;
+  BASE_URL = ENV_URLS[env];
+};
+
+// Get current environment
+export const getEnvironment = (): Environment => {
+  return currentEnvironment;
+};
+
+// Get base URL
+export const getBaseUrl = (): string => {
+  return BASE_URL;
+};