@test-web/react-native-sdk 1.0.0

package/src/styles/ThankYouStyles.ts

@@ -0,0 +1,31 @@
+import { StyleSheet } from 'react-native';
+import { Theme } from '../types';
+import { Orientation } from '../hooks/useOrientation';
+
+export default (theme: Theme, orientation: Orientation) => {
+  const isPortrait = orientation === 'portrait';
+
+  return StyleSheet.create({
+    container: {
+      flex: 1,
+      backgroundColor: theme.colors.background,
+      alignItems: 'center',
+      justifyContent: 'center',
+      paddingHorizontal: 20,
+    },
+    maintitle: {
+      textAlign: 'center',
+      fontWeight: 'bold',
+      marginBottom: 20,
+      color: theme.colors.text,
+      fontSize: 32,
+    },
+    subtitle: {
+      textAlign: 'center',
+      fontWeight: '300',
+      color: theme.colors.subtitle,
+      fontSize: 20,
+      lineHeight: 30,
+    },
+  });
+};

package/src/styles/VerifyIdentityStyles.ts

@@ -0,0 +1,86 @@
+import { StyleSheet } from 'react-native';
+import { Theme } from '../types';
+import { Orientation } from '../hooks/useOrientation';
+
+export default (theme: Theme, orientation: Orientation) => {
+  const isPortrait = orientation === 'portrait';
+
+  return StyleSheet.create({
+    container: {
+      flex: 1,
+      backgroundColor: theme.colors.background,
+      alignItems: 'center',
+      paddingHorizontal: 20,
+      paddingTop: isPortrait ? 40 : 20,
+    },
+    maintitle: {
+      textAlign: 'center',
+      fontWeight: '300',
+      marginBottom: isPortrait ? 30 : 15,
+      color: theme.colors.text,
+    },
+    subtitle: {
+      fontSize: 17,
+      lineHeight: 24,
+      fontWeight: '400',
+      textAlign: 'center',
+      color: theme.colors.subtitle,
+    },
+    list: {
+      marginTop: isPortrait ? 30 : 15,
+      marginBottom: isPortrait ? 20 : 10,
+      marginLeft: 'auto',
+      marginRight: 'auto',
+      justifyContent: 'center',
+      alignItems: 'center',
+      width: 135,
+    },
+    listItem: {
+      flexDirection: 'row',
+      marginBottom: 15,
+    },
+    numberCircle: {
+      width: 24,
+      height: 24,
+      borderRadius: 12,
+      backgroundColor: theme.colors.primary,
+      justifyContent: 'center',
+      alignItems: 'center',
+      marginRight: 10,
+    },
+    numberText: {
+      color: theme.colors.buttonText,
+      fontWeight: 'bold',
+      fontSize: 14,
+    },
+    listText: {
+      fontSize: 16,
+      fontWeight: 'bold',
+      color: theme.colors.text,
+    },
+    saprater: {
+      height: 10,
+      width: 4,
+      backgroundColor: '#ee7e22',
+      position: 'absolute',
+      left: 14,
+      top: 27,
+    },
+    buttonplace: {
+      position: 'absolute',
+      bottom: isPortrait ? 80 : 20,
+      justifyContent: 'center',
+      alignItems: 'center',
+    },
+    button: {
+      backgroundColor: theme.colors.buttonBackground,
+      color: theme.colors.buttonText,
+      fontSize: 16,
+      fontWeight: 'bold',
+      paddingVertical: 6,
+      paddingHorizontal: 15,
+      borderRadius: 5,
+      textAlign: 'center',
+    },
+  });
+};

package/src/types/IDMConf.ts

@@ -0,0 +1,28 @@
+export interface IDMConf {
+  theme?: string | any;
+  userDetails?: UserDetails;
+  accessToken?: string;
+  verificationCode?: string;
+  requestData?: any;
+  configuration?: any;
+  countryDetails?: CountryDetail[];
+  selectedCountryDetails?: any;
+  requestConfiguration?: any;
+}
+
+export interface UserDetails {
+  permissionGranted?: boolean;
+  location?: {
+    coords: {
+      latitude: number;
+      longitude: number;
+    };
+  };
+  [key: string]: any;
+}
+
+export interface CountryDetail {
+  label: string;
+  value: string;
+  metadata: any[];
+}

package/src/types/index.ts

@@ -0,0 +1,12 @@
+export interface Theme {
+  colors: {
+    primary: string;
+    background: string;
+    text: string;
+    subtitle: string;
+    buttonBackground: string;
+    buttonText: string;
+  };
+}
+
+export * from './IDMConf';

package/src/utils/index.ts

@@ -0,0 +1,19 @@
+export const formatDate = (date: Date): string => {
+  return date.toLocaleDateString();
+};
+
+export const validateApiKey = (key: string): boolean => {
+  return key.length > 0;
+};
+
+// Performance utilities
+export {
+  debounce,
+  throttle,
+  memoize,
+  shallowEqual,
+  measurePerformance,
+  measureAsyncPerformance,
+  BatchUpdater,
+  createStableRef,
+} from './performance';

package/src/utils/metadata_new.json

@@ -0,0 +1 @@
+[]

package/src/utils/performance.ts

@@ -0,0 +1,176 @@
+/**
+ * Performance utilities for the SDK
+ */
+
+/**
+ * Debounce function to limit how often a function can be called
+ * Useful for search inputs, scroll handlers, etc.
+ */
+export function debounce<T extends (...args: any[]) => any>(
+  func: T,
+  wait: number
+): (...args: Parameters<T>) => void {
+  let timeout: NodeJS.Timeout | null = null;
+
+  return function executedFunction(...args: Parameters<T>) {
+    const later = () => {
+      timeout = null;
+      func(...args);
+    };
+
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(later, wait);
+  };
+}
+
+/**
+ * Throttle function to ensure a function is called at most once per interval
+ * Useful for scroll handlers, resize handlers, etc.
+ */
+export function throttle<T extends (...args: any[]) => any>(
+  func: T,
+  limit: number
+): (...args: Parameters<T>) => void {
+  let inThrottle: boolean;
+
+  return function executedFunction(...args: Parameters<T>) {
+    if (!inThrottle) {
+      func(...args);
+      inThrottle = true;
+      setTimeout(() => (inThrottle = false), limit);
+    }
+  };
+}
+
+/**
+ * Memoize function results to avoid expensive recalculations
+ * Simple implementation for single-argument functions
+ */
+export function memoize<T extends (...args: any[]) => any>(fn: T): T {
+  const cache = new Map();
+
+  return ((...args: any[]) => {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn(...args);
+    cache.set(key, result);
+    return result;
+  }) as T;
+}
+
+/**
+ * Check if two objects are shallowly equal
+ * Useful for custom comparison in React.memo
+ */
+export function shallowEqual(obj1: any, obj2: any): boolean {
+  if (obj1 === obj2) return true;
+  if (!obj1 || !obj2) return false;
+
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+
+  if (keys1.length !== keys2.length) return false;
+
+  for (const key of keys1) {
+    if (obj1[key] !== obj2[key]) return false;
+  }
+
+  return true;
+}
+
+/**
+ * Performance logger for development
+ * Measures execution time of functions
+ */
+export function measurePerformance<T extends (...args: any[]) => any>(
+  fn: T,
+  label: string
+): T {
+  return ((...args: any[]) => {
+    const start = performance.now();
+    const result = fn(...args);
+    const end = performance.now();
+    console.log(`[Performance] ${label}: ${(end - start).toFixed(2)}ms`);
+    return result;
+  }) as T;
+}
+
+/**
+ * Async performance logger
+ */
+export function measureAsyncPerformance<T extends (...args: any[]) => Promise<any>>(
+  fn: T,
+  label: string
+): T {
+  return (async (...args: any[]) => {
+    const start = performance.now();
+    const result = await fn(...args);
+    const end = performance.now();
+    console.log(`[Performance] ${label}: ${(end - start).toFixed(2)}ms`);
+    return result;
+  }) as T;
+}
+
+/**
+ * Batch updates to reduce re-renders
+ * Collects multiple state updates and applies them together
+ */
+export class BatchUpdater<T> {
+  private updates: Partial<T>[] = [];
+  private timeout: NodeJS.Timeout | null = null;
+  private callback: (updates: Partial<T>) => void;
+
+  constructor(callback: (updates: Partial<T>) => void, delay: number = 16) {
+    this.callback = callback;
+  }
+
+  add(update: Partial<T>) {
+    this.updates.push(update);
+    
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+    }
+
+    this.timeout = setTimeout(() => {
+      this.flush();
+    }, 16);
+  }
+
+  flush() {
+    if (this.updates.length === 0) return;
+
+    const merged = Object.assign({}, ...this.updates);
+    this.callback(merged);
+    this.updates = [];
+    this.timeout = null;
+  }
+}
+
+/**
+ * Create a stable reference that only changes when dependencies change
+ * Similar to useMemo but for non-React contexts
+ */
+export function createStableRef<T>(
+  factory: () => T,
+  deps: any[]
+): { current: T; update: () => void } {
+  let value = factory();
+  let lastDeps = deps;
+
+  return {
+    get current() {
+      return value;
+    },
+    update() {
+      const depsChanged = lastDeps.some((dep, i) => dep !== deps[i]);
+      if (depsChanged) {
+        value = factory();
+        lastDeps = deps;
+      }
+    },
+  };
+}