@fadyshawky/react-native-magic 2.0.4 → 2.0.5

package/template/src/core/theme/types.ts

@@ -1,170 +1,27 @@
 import {TextStyle} from 'react-native';
-import {ElevationShadow} from './shadows';
-import {PrimaryColors, NaturalColors, AlertColors} from './colors';
 
 export type ThemeMode = 'light' | 'dark';
 
-export interface ISize {
-  font: {
-    // Almarai Design System Typography
-    bodySmall: number;
-    bodyMedium: number;
-    bodyLarge: number;
-    bodyXLarge: number;
-    heading6: number;
-    heading4: number;
-    heading3: number;
-    heading2: number;
-    heading1: number;
-
-    // Legacy support
-    extraSmall: number;
-    extraSmallPlus: number;
-    small: number;
-    smallPlus: number;
-    medium: number;
-    mediumPlus: number;
-    extraMedium: number;
-    large: number;
-    largePlus: number;
-    extraLarge: number;
-    extraLargePlus: number;
-  };
-  letterSpacing: {
-    // Almarai Design System
-    bodySmall: number;
-    bodyMedium: number;
-    bodyLarge: number;
-    bodyXLarge: number;
-    heading6: number;
-    heading4: number;
-    heading3: number;
-    heading2: number;
-    heading1: number;
-
-    // Legacy support
-    extraSmall: number;
-    extraSmallPlus: number;
-    small: number;
-    smallPlus: number;
-    medium: number;
-    mediumPlus: number;
-    large: number;
-    largePlus: number;
-    extraLarge: number;
-    extraLargePlus: number;
-  };
-  lineHeight: {
-    // Almarai Design System
-    bodySmall: number;
-    bodyMedium: number;
-    bodyLarge: number;
-    bodyXLarge: number;
-    heading6: number;
-    heading4: number;
-    heading3: number;
-    heading2: number;
-    heading1: number;
-
-    // Legacy support
-    extraSmall: number;
-    extraSmallPlus: number;
-    small: number;
-    smallPlus: number;
-    medium: number;
-    mediumPlus: number;
-    large: number;
-    largePlus: number;
-    extraLarge: number;
-    extraLargePlus: number;
-  };
-  spacing: {
-    // Design System Spacing Scale
-    none: number; // space / 0
-    xSmall: number; // space / 2
-    small: number; // space / 4
-    medium: number; // space / 8
-    large: number; // space / 12
-    xLarge: number; // space / 16
-    xxLarge: number; // space / 24 (2X-Large)
-    xxxLarge: number; // space / 32 (3X-Large)
-    xxxxLarge: number; // space / 48 (4X-Large)
-    xxxxxLarge: number; // space / 64 (5X-Large)
-    xxxxxxLarge: number; // space / 80 (6X-Large)
-    full: number; // space / 100 (Full)
-
-    // Legacy support
-    xs: number;
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-  };
-  borderRadius: {
-    // Design System Border Radius Scale
-    none: number; // Border / 0
-    xSmall: number; // Border / 2
-    small: number; // Border / 4
-    medium: number; // Border / 8
-    large: number; // Border / 12
-    xLarge: number; // Border / 16
-    xxLarge: number; // Border / 24 (2X-Large)
-    full: number; // Border / 1000 (Full)
-
-    // Legacy support
-    xs: number;
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-  };
-  borderWidth: {
-    // Design System Stroke Scale
-    none: number; // Stroke / 0
-    xSmall: number; // Stroke / 0.5
-    small: number; // Stroke / 1
-    medium: number; // Stroke / 1.5
-    large: number; // Stroke / 2
-
-    // Legacy support
-    extraSmall: number;
-  };
-}
-
 export interface Theme {
   mode: ThemeMode;
-  colors: typeof PrimaryColors & typeof NaturalColors & typeof AlertColors;
+  colors: {
+    indigoBlue: string;
+    mutedLavender: string;
+    tintColor: string;
+    mutedLavender30: string;
+    balanceBackground: string;
+    white: string;
+    backgroundOpacity: string;
+    black: string;
+    background: string;
+    surface: string;
+    card: string;
+    shadow: string;
+    red: string;
+  };
   text: {
-    // Almarai Design System Typography
-    // Headings
     header1: TextStyle;
     header2: TextStyle;
-    header3: TextStyle;
-    header4: TextStyle;
-    header6: TextStyle;
-
-    // Body Text with different weights
-    bodyXLargeLight: TextStyle;
-    bodyXLargeRegular: TextStyle;
-    bodyXLargeBold: TextStyle;
-    bodyXLargeExtraBold: TextStyle;
-
-    bodyLargeLight: TextStyle;
-    bodyLargeRegular: TextStyle;
-    bodyLargeBold: TextStyle;
-    bodyLargeExtraBold: TextStyle;
-
-    bodyMediumLight: TextStyle;
-    bodyMediumRegular: TextStyle;
-    bodyMediumBold: TextStyle;
-    bodyMediumExtraBold: TextStyle;
-
-    bodySmallLight: TextStyle;
-    bodySmallRegular: TextStyle;
-    bodySmallBold: TextStyle;
-    bodySmallExtraBold: TextStyle;
-
-    // Legacy styles for backward compatibility
     balanceTitle: TextStyle;
     balanceAmount: TextStyle;
     balanceLabel: TextStyle;
@@ -178,21 +35,6 @@ export interface Theme {
     navBar: TextStyle;
   };
   spacing: {
-    // Design System Spacing Scale
-    none: number;
-    xSmall: number;
-    small: number;
-    medium: number;
-    large: number;
-    xLarge: number;
-    xxLarge: number;
-    xxxLarge: number;
-    xxxxLarge: number;
-    xxxxxLarge: number;
-    xxxxxxLarge: number;
-    full: number;
-
-    // Legacy support
     xs: number;
     sm: number;
     md: number;
@@ -200,38 +42,10 @@ export interface Theme {
     xl: number;
   };
   borderRadius: {
-    // Design System Border Radius Scale
-    none: number;
-    xSmall: number;
-    small: number;
-    medium: number;
-    large: number;
-    xLarge: number;
-    xxLarge: number;
-    full: number;
-
-    // Legacy support
     xs: number;
     sm: number;
     md: number;
     lg: number;
     xl: number;
   };
-  borderWidth: {
-    // Design System Stroke Scale
-    none: number;
-    xSmall: number;
-    small: number;
-    medium: number;
-    large: number;
-
-    // Legacy support
-    extraSmall: number;
-  };
-  shadows: {
-    elevation1: ElevationShadow;
-    elevation2: ElevationShadow;
-    elevation3: ElevationShadow;
-    elevation4: ElevationShadow;
-  };
 }

package/template/src/core/utils/stringUtils.ts

@@ -0,0 +1,114 @@
+/**
+ * Safely converts any value to a string
+ * This is especially useful for error messages that might be objects
+ */
+import CryptoJS from 'crypto-js';
+
+export const ensureString = (value: any): string => {
+  if (value === null || value === undefined) {
+    return '';
+  }
+
+  if (typeof value === 'string') {
+    return value;
+  }
+
+  if (typeof value === 'object') {
+    try {
+      // Try to extract a message property if it exists
+      if (value.message && typeof value.message === 'string') {
+        return value.message;
+      }
+
+      // Otherwise stringify the object
+      return JSON.stringify(value);
+    } catch (e) {
+      return '[Object]';
+    }
+  }
+
+  // For numbers, booleans, etc.
+  return String(value);
+};
+
+export function decryptTripleDES(
+  encryptedBase64: string,
+  secretKeyBase64: string,
+) {
+  try {
+    // Decode the key from base64
+    const decodedKey = CryptoJS.enc.Base64.parse(secretKeyBase64);
+
+    // Decode the encrypted value from base64
+    const encryptedWordArray = CryptoJS.enc.Base64.parse(encryptedBase64);
+
+    // Decrypt using Triple DES
+    const decrypted = CryptoJS.TripleDES.decrypt(
+      {ciphertext: encryptedWordArray},
+      decodedKey,
+      {
+        mode: CryptoJS.mode.ECB,
+        padding: CryptoJS.pad.Pkcs7,
+      },
+    );
+
+    let decryptedText = decrypted.toString(CryptoJS.enc.Utf8);
+
+    if (!decryptedText) {
+      throw new Error('Decryption resulted in empty string');
+    }
+
+    decryptedText = decryptedText.replace(/(.{4})/g, '$1-');
+    if (decryptedText.endsWith('-')) {
+      decryptedText = decryptedText.slice(0, -1);
+    }
+
+    return decryptedText;
+  } catch (error) {
+    throw new Error(`Decryption failed`);
+  }
+}
+
+// Example usage:
+// const decrypted = decryptBase64('encrypted_base64_string', 'your_secret_key');
+
+/**
+ * Converts a camelCase string to PascalCase with specific formatting
+ * Example: billerId -> BillerId
+ * @param str The camelCase string to convert
+ * @returns The converted PascalCase string
+ */
+export const toPascalCase = (str: string): string => {
+  if (!str) return '';
+
+  // Split by capital letters and convert to array
+  const words = str.split(/(?=[A-Z])/);
+
+  // Capitalize first letter of each word and join
+  return words
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join('');
+};
+
+// Example usage:
+// toPascalCase('billerId') => 'BillerId'
+// toPascalCase('customerName') => 'CustomerName'
+// toPascalCase('accountNumber') => 'AccountNumber'
+
+/**
+ * Converts a PascalCase string to camelCase
+ * Example: BillerId -> billerId
+ * @param str The PascalCase string to convert
+ * @returns The converted camelCase string
+ */
+export const toCamelCase = (str: string): string => {
+  if (!str) return '';
+
+  // Convert first character to lowercase and keep the rest as is
+  return str.charAt(0).toLowerCase() + str.slice(1);
+};
+
+// Example usage:
+// toCamelCase('BillerId') => 'billerId'
+// toCamelCase('CustomerName') => 'customerName'
+// toCamelCase('AccountNumber') => 'accountNumber'

package/template/src/modules/SunmiCard.js

@@ -0,0 +1,212 @@
+import {NativeModules, Platform} from 'react-native';
+
+const {SunmiCardModule} = NativeModules;
+
+if (!SunmiCardModule) {
+  throw new Error('SunmiCardModule is not available on this device');
+}
+
+/**
+ * Interface for Sunmi Card Reader functionality
+ */
+class SunmiCard {
+  /**
+   * Card types constants
+   */
+  static CARD_TYPE_MAGNETIC = SunmiCardModule.CARD_TYPE_MAGNETIC;
+  static CARD_TYPE_IC = SunmiCardModule.CARD_TYPE_IC;
+  static CARD_TYPE_NFC = SunmiCardModule.CARD_TYPE_NFC;
+  static CARD_TYPE_MAGNETIC_IC = SunmiCardModule.CARD_TYPE_MAGNETIC_IC;
+  static CARD_TYPE_MAGNETIC_NFC = SunmiCardModule.CARD_TYPE_MAGNETIC_NFC;
+  static CARD_TYPE_IC_NFC = SunmiCardModule.CARD_TYPE_IC_NFC;
+  static CARD_TYPE_MAGNETIC_IC_NFC = SunmiCardModule.CARD_TYPE_MAGNETIC_IC_NFC;
+
+  /**
+   * Card reader mode constants
+   */
+  static READ_MODE_MAGNETIC = SunmiCardModule.READ_MODE_MAGNETIC;
+  static READ_MODE_IC = SunmiCardModule.READ_MODE_IC;
+  static READ_MODE_NFC = SunmiCardModule.READ_MODE_NFC;
+
+  /**
+   * Track error code constants
+   */
+  static TRACK_ERROR_NONE = SunmiCardModule.TRACK_ERROR_NONE; // No error
+  static TRACK_ERROR_NO_DATA = SunmiCardModule.TRACK_ERROR_NO_DATA; // Track has no data
+  static TRACK_ERROR_PARITY = SunmiCardModule.TRACK_ERROR_PARITY; // Track parity check error
+  static TRACK_ERROR_LRC = SunmiCardModule.TRACK_ERROR_LRC; // Track LRC check error
+
+  /**
+   * Check if the Sunmi Pay SDK is connected
+   * @returns {Promise<boolean>} - True if connected
+   */
+  static isConnected() {
+    if (Platform.OS !== 'android') {
+      return Promise.reject(
+        new Error('SunmiCard is only available on Android'),
+      );
+    }
+
+    return SunmiCardModule.isConnected();
+  }
+
+  /**
+   * Check for a card to be presented
+   * @param {number} cardType - Type of card to check for (use CARD_TYPE_* constants)
+   * @param {number} timeout - Timeout in seconds
+   * @returns {Promise<Object>} - Card information or timeout/error
+   *
+   * For magnetic cards, the result will include:
+   * - type: "magnetic"
+   * - track1: Track 1 data (if available)
+   * - track2: Track 2 data (if available)
+   * - track3: Track 3 data (if available)
+   * - track1ErrorCode: Error code for track 1 (0 = no error, -1 = no data, -2 = parity error, -3 = LRC error)
+   * - track2ErrorCode: Error code for track 2
+   * - track3ErrorCode: Error code for track 3
+   *
+   * For IC cards, the result will include:
+   * - type: "ic"
+   * - atr: ATR data
+   *
+   * For NFC cards, the result will include:
+   * - type: "nfc"
+   * - uuid: Card UUID
+   *
+   * For timeout, the result will include:
+   * - type: "timeout"
+   */
+  static checkCard(cardType, timeout = 60) {
+    if (Platform.OS !== 'android') {
+      return Promise.reject(
+        new Error('SunmiCard is only available on Android'),
+      );
+    }
+
+    if (typeof cardType !== 'number') {
+      return Promise.reject(new Error('cardType must be a number'));
+    }
+
+    if (typeof timeout !== 'number') {
+      return Promise.reject(new Error('timeout must be a number'));
+    }
+
+    return SunmiCardModule.checkCard(cardType, timeout);
+  }
+
+  /**
+   * Cancel an ongoing card check operation
+   * @returns {Promise<boolean>} - True if successful
+   */
+  static cancelCardCheck() {
+    if (Platform.OS !== 'android') {
+      return Promise.reject(
+        new Error('SunmiCard is only available on Android'),
+      );
+    }
+
+    return SunmiCardModule.cancelCardCheck();
+  }
+
+  /**
+   * Read data from an IC card
+   * Note: This method is provided for backward compatibility.
+   * It's recommended to use checkCard with CARD_TYPE_IC instead.
+   * @returns {Promise<Object>} - IC card information
+   */
+  static readICCard() {
+    if (Platform.OS !== 'android') {
+      return Promise.reject(
+        new Error('SunmiCard is only available on Android'),
+      );
+    }
+
+    return SunmiCardModule.readICCard();
+  }
+
+  /**
+   * Read data from an NFC card
+   * Note: This method is provided for backward compatibility.
+   * It's recommended to use checkCard with CARD_TYPE_NFC instead.
+   * @returns {Promise<Object>} - NFC card information
+   */
+  static readNFCCard() {
+    if (Platform.OS !== 'android') {
+      return Promise.reject(
+        new Error('SunmiCard is only available on Android'),
+      );
+    }
+
+    return SunmiCardModule.readNFCCard();
+  }
+
+  /**
+   * Transaction types
+   */
+  static TRANS_TYPE_CONSUME = SunmiCardModule.TRANS_TYPE_CONSUME;
+  static TRANS_TYPE_REFUND = SunmiCardModule.TRANS_TYPE_REFUND;
+
+  /**
+   * Transaction result codes
+   */
+  static TRANS_RESULT_SUCCESS = SunmiCardModule.TRANS_RESULT_SUCCESS;
+  static TRANS_RESULT_OFFLINE_APPROVED =
+    SunmiCardModule.TRANS_RESULT_OFFLINE_APPROVED;
+  static TRANS_RESULT_DECLINED = SunmiCardModule.TRANS_RESULT_DECLINED;
+  static TRANS_RESULT_TERMINATED = SunmiCardModule.TRANS_RESULT_TERMINATED;
+  static TRANS_RESULT_CANCEL = SunmiCardModule.TRANS_RESULT_CANCEL;
+  static TRANS_RESULT_TIMEOUT = SunmiCardModule.TRANS_RESULT_TIMEOUT;
+  static TRANS_RESULT_OTHER_ERROR = SunmiCardModule.TRANS_RESULT_OTHER_ERROR;
+  static TRANS_RESULT_MAC_ERROR = SunmiCardModule.TRANS_RESULT_MAC_ERROR;
+  static TRANS_RESULT_FALLBACK = SunmiCardModule.TRANS_RESULT_FALLBACK;
+
+  /**
+   * Start a card payment transaction
+   * @param {number} amount - The transaction amount in cents (e.g., 1000 for $10.00)
+   * @param {string} currency - The currency code (e.g., "USD")
+   * @param {string} transactionType - The transaction type ("consume" or "refund")
+   * @param {number} timeout - Timeout in seconds for card detection
+   * @returns {Promise<Object>} - Transaction result object
+   */
+  static startCardPayment(
+    amount,
+    currency = 'USD',
+    transactionType = 'consume',
+    timeout = 60,
+  ) {
+    if (typeof amount !== 'number' || amount <= 0) {
+      return Promise.reject(new Error('Amount must be a positive number'));
+    }
+
+    // Convert transaction type string to integer
+    let transType = SunmiCard.TRANS_TYPE_CONSUME;
+    if (transactionType.toLowerCase() === 'refund') {
+      transType = SunmiCard.TRANS_TYPE_REFUND;
+    }
+
+    return SunmiCardModule.startCardPayment(
+      amount,
+      currency,
+      transactionType,
+      timeout,
+    );
+  }
+
+  /**
+   * Cancel an ongoing card payment transaction
+   * @returns {Promise<boolean>} - True if canceled successfully
+   */
+  static cancelCardPayment() {
+    return SunmiCardModule.cancelCardPayment();
+  }
+
+  /**
+   * Get the result of the last transaction
+   * @returns {Promise<Object|null>} - Transaction result object or null if no transaction
+   */
+  static getLastTransactionResult() {
+    return SunmiCardModule.getLastTransactionResult();
+  }
+}
+
+export default SunmiCard;

package/template/src/modules/SunmiPrepaid.ts

@@ -0,0 +1,122 @@
+import {NativeModules} from 'react-native';
+
+const {SunmiPrepaid} = NativeModules;
+
+export interface PrepaidResponse {
+  success: boolean;
+  message: string;
+  billingAcct: string;
+  extraBillingAcctKey: any[];
+  customProperties: any[];
+}
+
+export interface ServiceStatus {
+  isInitialized: boolean;
+}
+
+function checkMeeterFeedBack(response: any): {Key: string; Value: string}[] {
+  let chunksNum;
+  if (response.meterFeedback.length % 1024 == 0)
+    chunksNum = response.meterFeedback.length / 1024;
+  else {
+    chunksNum = response.meterFeedback.length / 1024 + 1;
+  }
+
+  let tmp = [];
+
+  for (let i = 1; i <= chunksNum; i++) {
+    let meterFeedbackKey = 'ESCFBT0';
+    meterFeedbackKey += i;
+    let chunkLength = i * 1024;
+    let previousChunkLength = (i - 1) * 1024;
+    if (chunkLength > response.meterFeedback.length)
+      chunkLength = response.meterFeedback.length;
+    let chunkData = response.meterFeedback.substring(
+      previousChunkLength,
+      chunkLength,
+    );
+    tmp.push({Key: meterFeedbackKey, Value: chunkData});
+  }
+  return tmp;
+}
+
+class SunmiPrepaidModule {
+  async initializePrepaid(): Promise<PrepaidResponse> {
+    try {
+      return await SunmiPrepaid.initializePrepaid();
+    } catch (error) {
+      throw new Error(`Failed to initialize prepaid service: ${error}`);
+    }
+  }
+
+  async forceCardFacadeDetection(): Promise<PrepaidResponse> {
+    try {
+      return await SunmiPrepaid.forceCardFacadeDetection();
+    } catch (error) {
+      throw new Error(`Failed to force card facade detection: ${error}`);
+    }
+  }
+
+  async readCardMetadata(
+    extraKeys: any,
+    type: string,
+  ): Promise<PrepaidResponse> {
+    try {
+      const response = await SunmiPrepaid.readCardMetadata(type);
+
+      let keysArray = [
+        {Key: 'Key1', Value: response.vendor},
+        {Key: 'Key2', Value: response.sectorIdentifier},
+        {Key: 'Key3', Value: response.meterIdentifier},
+      ];
+
+      let propertiesArray = [
+        {
+          Key:
+            type === 'SC' || type === 'GASSC'
+              ? 'ElectrictyCompany'
+              : 'WaterCompany',
+          Value: response.companyIdentifier,
+        },
+        {Key: 'ClientIdentifier', Value: response.clientIdentifier},
+        {Key: 'CardMetadata', Value: response.metaData},
+      ];
+
+      if (response.meterFeedback.length < 1024) {
+        propertiesArray.push({
+          Key: 'ESCFBT01',
+          Value: response.meterFeedback,
+        });
+      } else {
+        propertiesArray.push(...checkMeeterFeedBack(response));
+      }
+
+      if (response.metaData) {
+        propertiesArray.push({Key: 'CardMetadata', Value: response.metaData});
+      }
+
+      return {
+        success: true,
+        message: 'success',
+        billingAcct: response.identifier,
+        extraBillingAcctKey: keysArray,
+        customProperties: propertiesArray,
+      };
+    } catch (error) {
+      throw new Error(`Failed to read card metadata: ${error}`);
+    }
+  }
+
+  async writeCardCharge(
+    billEncryptInfo: string,
+    cardMetadata: string,
+  ): Promise<PrepaidResponse> {
+    try {
+      return await SunmiPrepaid.writeCardCharge(billEncryptInfo, cardMetadata);
+    } catch (error) {
+      throw new Error(`Failed to write card charge: ${error}`);
+    }
+  }
+}
+
+export default new SunmiPrepaidModule();

package/template/src/navigation/AuthStack.tsx

@@ -1,6 +1,7 @@
 import {createNativeStackNavigator} from '@react-navigation/native-stack';
 import {useTranslation} from '../common/localization/LocalizationProvider';
 import {Login} from '../screens/Login/Login';
+import {OTPScreen} from '../screens/OTP/OTPScreen';
 import {Splash} from '../screens/splash/Splash';
 
 const Stack = createNativeStackNavigator();
@@ -23,6 +24,13 @@ export function AuthStack() {
         headerShown: false,
       },
     },
+    {
+      id: 'OTP',
+      component: OTPScreen,
+      options: {
+        headerShown: false,
+      },
+    },
   ];
 
   return (