@trustchex/react-native-sdk 1.161.0

package/lib/module/Shared/EIDReader/tlv/tlvOutputStream.js

@@ -0,0 +1,85 @@
+"use strict";
+
+import { DataOutputStream } from "../java/dataOutputStream.js";
+import { OutputStream } from "../java/outputStream.js";
+import TLVUtil from "./tlv.utils.js";
+import { TLVOutputState } from "./tlvOutputState.js";
+export class TLVOutputStream extends OutputStream {
+  constructor(outputStream) {
+    super();
+    this.outputStream = outputStream instanceof DataOutputStream ? outputStream : new DataOutputStream(outputStream);
+    this.state = new TLVOutputState();
+  }
+  writeTag(tag) {
+    const tagAsBytes = TLVUtil.getTagAsBytes(tag);
+    if (this.state.canBeWritten()) {
+      this.outputStream.writeBytes(Uint8Array.from(tagAsBytes));
+    }
+    this.state.setTagProcessed(tag);
+  }
+  writeLength(length) {
+    const lengthAsBytes = TLVUtil.getLengthAsBytes(length);
+    this.state.setLengthProcessed(length);
+    if (this.state.canBeWritten()) {
+      this.outputStream.writeBytes(Uint8Array.from(lengthAsBytes));
+    }
+  }
+  writeValue(value) {
+    if (value == null) {
+      throw new Error('Cannot write null.');
+    } else if (this.state.getIsAtStartOfTag()) {
+      throw new Error('Cannot write value bytes yet. Need to write a tag first.');
+    } else {
+      if (this.state.getIsAtStartOfLength()) {
+        this.writeLength(value.length);
+        this.writeBytes(value);
+      } else {
+        this.writeBytes(value);
+        this.state.updatePreviousLength(value.length);
+      }
+    }
+  }
+  write(b) {
+    this.writeBytesWithOffset(new Uint8Array([b]), 0, 1);
+  }
+  writeBytes(bytes) {
+    this.writeBytesWithOffset(bytes, 0, bytes.length);
+  }
+  writeBytesWithOffset(bytes, offset, length) {
+    if (this.state.getIsAtStartOfTag()) {
+      throw new Error('Cannot write value bytes yet. Need to write a tag first.');
+    } else {
+      if (this.state.getIsAtStartOfLength()) {
+        this.state.setDummyLengthProcessed();
+      }
+      this.state.updateValueBytesProcessed(Array.from(bytes), offset, length);
+      if (this.state.canBeWritten()) {
+        this.outputStream.writeBytes(bytes.slice(offset, offset + length));
+      }
+    }
+  }
+  writeValueEnd() {
+    if (this.state.getIsAtStartOfLength()) {
+      throw new Error('Not processing value yet.');
+    } else if (!this.state.getIsAtStartOfTag() || this.state.isDummyLengthSet()) {
+      const bufferedValueBytes = this.state.getValue();
+      const length = bufferedValueBytes.length;
+      this.state.updatePreviousLength(length);
+      if (this.state.canBeWritten()) {
+        const lengthAsBytes = TLVUtil.getLengthAsBytes(length);
+        this.outputStream.writeBytes(Uint8Array.from(lengthAsBytes));
+        this.outputStream.writeBytes(Uint8Array.from(bufferedValueBytes));
+      }
+    }
+  }
+  flush() {
+    this.outputStream.flush();
+  }
+  close() {
+    if (!this.state.canBeWritten()) {
+      throw new Error('Cannot close stream yet, illegal TLV state.');
+    } else {
+      this.outputStream.close();
+    }
+  }
+}

package/lib/module/Shared/EIDReader/tripleDesSecureMessagingWrapper.js

@@ -0,0 +1,37 @@
+"use strict";
+
+import { SecureMessagingWrapper } from "./secureMessagingWrapper.js";
+import { ByteArrayOutputStream } from "./java/byteArrayOutputStream.js";
+import { DataOutputStream } from "./java/dataOutputStream.js";
+export class TripleDesSecureMessagingWrapper extends SecureMessagingWrapper {
+  static ZERO_IV_PARAM_SPEC = [0, 0, 0, 0, 0, 0, 0, 0];
+  constructor(ksEnc, ksMac, maxTransceiveLength, shouldCheckMAC, ssc) {
+    super(ksEnc, ksMac, maxTransceiveLength, shouldCheckMAC, ssc);
+  }
+  getType() {
+    return '3DES';
+  }
+  getPadLength() {
+    return 8;
+  }
+  getEncodedSendSequenceCounter() {
+    const byteArrayOutputStream = new ByteArrayOutputStream();
+    try {
+      const dataOutputStream = new DataOutputStream(byteArrayOutputStream);
+      dataOutputStream.writeLong(this.getSendSequenceCounter());
+    } catch (ioe) {
+      /* Never happens. */
+      console.debug('Error writing to stream', ioe);
+    } finally {
+      try {
+        byteArrayOutputStream.close();
+      } catch (ioe) {
+        console.debug('Error closing stream', ioe);
+      }
+    }
+    return byteArrayOutputStream.toByteArray();
+  }
+  getIV() {
+    return TripleDesSecureMessagingWrapper.ZERO_IV_PARAM_SPEC;
+  }
+}

package/lib/module/Shared/EIDReader/utils/crypto.utils.js

@@ -0,0 +1,218 @@
+"use strict";
+
+import CryptoJS, { enc, SHA1 } from 'crypto-js';
+import { Buffer } from 'buffer';
+import 'react-native-get-random-values';
+const pad = (bytes, offset, length, blockSize) => {
+  const n = length;
+  const padLength = blockSize - n % blockSize;
+  const out = Buffer.alloc(n + padLength);
+  for (let i = 0; i < n; i++) {
+    out[i] = bytes[offset + i];
+  }
+  out[n] = 0x80;
+  for (let i = n + 1; i < n + padLength; i++) {
+    out[i] = 0x00;
+  }
+  return out;
+};
+const unpad = bytes => {
+  let i = bytes.length - 1;
+  while (i >= 0 && bytes[i] === 0x00) {
+    i--;
+  }
+  if ((bytes[i] & 0xff) !== 0x80) {
+    throw new Error(`Expected constant 0x80, found 0x${(bytes[i] & 0x000000ff).toString(16)}`);
+  }
+  const out = bytes.slice(0, i);
+  return out;
+};
+
+// Function to encrypt data using 3DES key KEnc
+const encryptWith3DES = (data, KEnc) => {
+  const SWordArray = CryptoJS.enc.Hex.parse(data);
+  const KEncWordArray = CryptoJS.enc.Hex.parse(KEnc);
+  const encrypted = CryptoJS.algo.TripleDES.createEncryptor(KEncWordArray, {
+    mode: CryptoJS.mode.CBC,
+    padding: CryptoJS.pad.NoPadding,
+    iv: CryptoJS.enc.Hex.parse('0000000000000000'),
+    blockSize: 64
+  }).finalize(SWordArray);
+  return encrypted.toString(CryptoJS.enc.Hex);
+};
+
+// Function to decrypt data using 3DES key KEnc
+const decryptWith3DES = (data, KEnc) => {
+  const SWordArray = CryptoJS.enc.Hex.parse(data);
+  const KEncWordArray = CryptoJS.enc.Hex.parse(KEnc);
+  const decrypted = CryptoJS.algo.TripleDES.createDecryptor(KEncWordArray, {
+    mode: CryptoJS.mode.CBC,
+    padding: CryptoJS.pad.NoPadding,
+    iv: CryptoJS.enc.Hex.parse('0000000000000000'),
+    blockSize: 64
+  }).finalize(SWordArray);
+  return decrypted.toString(CryptoJS.enc.Hex);
+};
+
+// https://en.wikipedia.org/wiki/ISO/IEC_9797-1
+const computeMac = (data, key, padData = false) => {
+  // Split the 16 byte MAC key into two keys
+  const key1 = key.substring(0, 16);
+  const key2 = key.substring(16, 32);
+  const des1 = CryptoJS.algo.DES.createEncryptor(CryptoJS.enc.Hex.parse(key1), {
+    mode: CryptoJS.mode.CBC,
+    padding: CryptoJS.pad.NoPadding,
+    iv: CryptoJS.enc.Hex.parse('0000000000000000'),
+    blockSize: 64
+  });
+  const des2 = CryptoJS.algo.DES.createDecryptor(CryptoJS.enc.Hex.parse(key2), {
+    mode: CryptoJS.mode.CBC,
+    padding: CryptoJS.pad.NoPadding,
+    iv: CryptoJS.enc.Hex.parse('0000000000000000'),
+    blockSize: 64
+  });
+  const out = Buffer.from(data, 'hex');
+  const dataBytes = padData ?
+  // Pad the data with Padding Method 2 (Bit Padding)
+  pad(out, 0, out.byteLength, 8) : out;
+  const numberOfBytes = dataBytes.byteLength / 8;
+  let d1 = dataBytes.subarray(0, 8);
+  let dN = Buffer.alloc(8);
+  let hN = Buffer.alloc(8);
+  let intN = Buffer.alloc(8);
+
+  // MAC Algorithm 3
+  // Initial Transformation 1
+  hN = Buffer.from(des1.finalize(CryptoJS.enc.Hex.parse(Buffer.from(d1).toString('hex'))).toString(CryptoJS.enc.Hex), 'hex');
+
+  // Split the blocks
+  // Iteration on the rest of blocks
+  for (let j = 1; j < numberOfBytes; j++) {
+    dN = dataBytes.subarray(8 * j, 8 * j + 8);
+
+    // XOR
+    for (let i = 0; i < 8; i++) {
+      intN[i] = hN[i] ^ dN[i];
+    }
+
+    // Encrypt
+    des1.reset();
+    hN = Buffer.from(des1.finalize(CryptoJS.enc.Hex.parse(Buffer.from(intN).toString('hex'))).toString(CryptoJS.enc.Hex), 'hex');
+  }
+
+  // Output Transformation 3
+  des2.reset();
+  const hNdecrypt = des2.finalize(CryptoJS.enc.Hex.parse(Buffer.from(hN).toString('hex')));
+  des1.reset();
+  const mac = des1.finalize(hNdecrypt);
+
+  // Get check Sum CC
+  return mac.toString(CryptoJS.enc.Hex);
+};
+
+// Helper function to adjust parity bits for DES keys
+const adjustParityBits = key => {
+  const bytes = Buffer.from(key, 'hex');
+  for (let i = 0; i < bytes.length; i++) {
+    let parity = 0;
+    for (let j = 0; j < 8; j++) {
+      if ((bytes[i] & 1 << j) !== 0) {
+        parity++;
+      }
+    }
+    if (parity % 2 === 0) {
+      bytes[i] ^= 1;
+    }
+  }
+  return bytes.toString('hex');
+};
+
+// Function to derive 3DES keys from a seed
+const derive3DESKeysFromSeed = (kSeed, type) => {
+  // Concatenate Kseed with '00000001' for ENC and '00000002' for MAC
+  const D = kSeed + (type === 'ENC' ? '00000001' : '00000002');
+
+  // Calculate the SHA-1 hash of D
+  const hash = SHA1(enc.Hex.parse(D)).toString();
+
+  // Form DES keys Ka and Kb
+  let KaPrime = hash.substring(0, 16);
+  let KbPrime = hash.substring(16, 32);
+
+  // Adjust parity bits
+  const Ka = adjustParityBits(KaPrime);
+  const Kb = adjustParityBits(KbPrime);
+  return Ka + Kb;
+};
+const computeKeySeed = (text, digestAlg, doTruncate) => {
+  let hash;
+  if (digestAlg === 'SHA-1') {
+    hash = SHA1(text).toString();
+  } else {
+    throw new Error('Unsupported digest algorithm');
+  }
+  if (!doTruncate) {
+    return hash;
+  }
+  return hash.substring(0, 32);
+};
+const getRandomValues = length => {
+  return Buffer.from(crypto.getRandomValues(new Uint8Array(length))).toString('hex');
+};
+const computeSendSequenceCounter = (rndICC, rndIFD) => {
+  if (rndICC == null || rndICC.length !== 8 || rndIFD == null || rndIFD.length !== 8) {
+    throw new Error('Wrong length input');
+  }
+  let ssc = 0;
+  for (let i = 4; i < 8; i++) {
+    ssc <<= 8;
+    ssc += rndICC[i] & 0x000000ff;
+  }
+  for (let i = 4; i < 8; i++) {
+    ssc <<= 8;
+    ssc += rndIFD[i] & 0x000000ff;
+  }
+  return ssc;
+};
+
+// TODO move to a separate file
+const partition = (segmentSize, data) => {
+  const segments = [];
+  if (data == null || segmentSize <= 0) {
+    throw new Error('Cannot partition');
+  }
+
+  /* Check if all data fits in one segment. */
+  segmentSize = Math.min(data.length, segmentSize);
+  const segmentCount = Math.floor(data.length / segmentSize); // Excluding the remainder.
+  const lastSegmentSize = data.length % segmentSize;
+  let offset = 0;
+  for (let i = 0; i < segmentCount; i++) {
+    const segment = new Array(segmentSize);
+    for (let j = 0; j < segmentSize; j++) {
+      segment[j] = data[offset + j];
+    }
+    segments.push(segment);
+    offset += segmentSize;
+  }
+  if (lastSegmentSize !== 0) {
+    const segment = new Array(lastSegmentSize);
+    for (let j = 0; j < lastSegmentSize; j++) {
+      segment[j] = data[offset + j];
+    }
+    segments.push(segment);
+  }
+  return segments;
+};
+export default {
+  pad,
+  unpad,
+  encryptWith3DES,
+  decryptWith3DES,
+  computeMac,
+  derive3DESKeysFromSeed,
+  getRandomValues,
+  computeSendSequenceCounter,
+  computeKeySeed,
+  partition
+};

package/lib/module/Shared/EIDReader/utils/random.js

@@ -0,0 +1,166 @@
+"use strict";
+
+//
+// An almost complete implementation in JS of the `java.util.Random`
+// class from J2SE, designed to so far as possible produce the same
+// output sequences as the Java original when supplied with the same
+// seed.
+//
+
+const p2_16 = 0x0000000010000;
+const p2_24 = 0x0000001000000;
+const p2_27 = 0x0000008000000;
+const p2_31 = 0x0000080000000;
+const p2_32 = 0x0000100000000;
+const p2_48 = 0x1000000000000;
+const p2_53 = Math.pow(2, 53); // NB: exceeds Number.MAX_SAFE_INTEGER
+
+const m2_16 = 0xffff;
+
+//
+// multiplicative term for the PRNG
+//
+const [c2, c1, c0] = [0x0005, 0xdeec, 0xe66d];
+export class JavaRandom {
+  haveNextNextGaussian = false;
+  constructor(seedVal) {
+    // perform seed initialization
+    if (!seedVal) {
+      seedVal = Math.floor(Math.random() * p2_48);
+    }
+    this.checkIsPositiveInt(seedVal);
+    this.s0 = seedVal & m2_16 ^ c0;
+    this.s1 = seedVal / p2_16 & m2_16 ^ c1;
+    this.s2 = seedVal / p2_32 & m2_16 ^ c2;
+  }
+
+  // 53-bit safe version of
+  // seed = (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1)
+  //
+  _next = () => {
+    let carry = 0xb;
+    let r0 = this.s0 * c0 + carry;
+    carry = r0 >>> 16;
+    r0 &= m2_16;
+    let r1 = this.s1 * c0 + this.s0 * c1 + carry;
+    carry = r1 >>> 16;
+    r1 &= m2_16;
+    let r2 = this.s2 * c0 + this.s1 * c1 + this.s0 * c2 + carry;
+    r2 &= m2_16;
+    [this.s2, this.s1, this.s0] = [r2, r1, r0];
+    return this.s2 * p2_16 + this.s1;
+  };
+  next_signed(bits) {
+    return this._next() >> 32 - bits;
+  }
+  next(bits) {
+    return this._next() >>> 32 - bits;
+  }
+  checkIsNumber(n) {
+    if (typeof n !== 'number') {
+      throw TypeError();
+    }
+  }
+  checkIsPositiveInt(n, r = Number.MAX_SAFE_INTEGER) {
+    this.checkIsNumber(n);
+    if (n < 0 || n > r) {
+      throw RangeError();
+    }
+  }
+  nextInt(bound) {
+    if (bound === undefined) {
+      return this.next_signed(32);
+    }
+    this.checkIsPositiveInt(bound, 0x7fffffff);
+
+    // special case if bound is a power of two
+    if ((bound & -bound) === bound) {
+      let r = this.next(31) / p2_31;
+      return ~~(bound * r);
+    }
+    var bits, val;
+    do {
+      bits = this.next(31);
+      val = bits % bound;
+    } while (bits - val + (bound - 1) < 0);
+    return val;
+  }
+  nextLong() {
+    if (typeof BigInt !== 'function') {
+      throw Error('BigInt unsupported');
+    }
+    let msb = BigInt(this.next_signed(32));
+    let lsb = BigInt(this.next_signed(32));
+    const p2_32n = BigInt(p2_32);
+    return msb * p2_32n + lsb;
+  }
+  nextBoolean() {
+    return this.next(1) !== 0;
+  }
+  nextFloat() {
+    return this.next(24) / p2_24;
+  }
+  nextDouble() {
+    return (p2_27 * this.next(26) + this.next(27)) / p2_53;
+  }
+  nextBytes(bytes) {
+    if (!Array.isArray(bytes)) {
+      throw TypeError;
+    }
+    for (let i = 0; i < bytes.length;) {
+      for (let rnd = this.nextInt(), n = Math.min(bytes.length - i, 4); n-- > 0; rnd >>= 8) {
+        // double shift extends bit sign in bit 7
+        bytes[i++] = rnd << 24 >> 24;
+      }
+    }
+  }
+  nextGaussian() {
+    if (this.haveNextNextGaussian) {
+      this.haveNextNextGaussian = false;
+      return this.nextNextGaussian;
+    } else {
+      let v1, v2, s;
+      do {
+        v1 = 2 * this.nextDouble() - 1.0;
+        v2 = 2 * this.nextDouble() - 1.0;
+        s = v1 * v1 + v2 * v2;
+      } while (s >= 1 || s === 0);
+      let multiplier = Math.sqrt(-2 * Math.log(s) / s);
+      this.nextNextGaussian = v2 * multiplier;
+      this.haveNextNextGaussian = true;
+      return v1 * multiplier;
+    }
+  }
+
+  //
+  // stream functions replaced with JS generators
+  //
+  checkStreamSize(streamSize) {
+    if (streamSize === undefined) {
+      return undefined;
+    }
+    this.checkIsPositiveInt(streamSize);
+    return streamSize;
+  }
+  *ints(streamSize) {
+    streamSize = this.checkStreamSize(streamSize);
+    let forever = streamSize === undefined;
+    while (forever || streamSize && streamSize-- > 0) {
+      yield this.nextInt();
+    }
+  }
+  *longs(streamSize) {
+    streamSize = this.checkStreamSize(streamSize);
+    let forever = streamSize === undefined;
+    while (forever || streamSize && streamSize-- > 0) {
+      yield this.nextLong();
+    }
+  }
+  *doubles(streamSize) {
+    streamSize = this.checkStreamSize(streamSize);
+    let forever = streamSize === undefined;
+    while (forever || streamSize && streamSize-- > 0) {
+      yield this.nextDouble();
+    }
+  }
+}

package/lib/module/Shared/EIDReader/wrappedAPDUEvent.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import { APDUEvent } from "./smartcards/apduEvent.js";
+export class WrappedAPDUEvent extends APDUEvent {
+  constructor(source, type, sequenceNumber, plainTextCommandAPDU, plainTextResponseAPDU, wrappedCommandAPDU, wrappedResponseAPDU) {
+    super(source, type, sequenceNumber, wrappedCommandAPDU, wrappedResponseAPDU);
+    this.plainTextCommandAPDU = plainTextCommandAPDU;
+    this.plainTextResponseAPDU = plainTextResponseAPDU;
+  }
+  getPlainTextCommandAPDU() {
+    return this.plainTextCommandAPDU;
+  }
+  getPlainTextResponseAPDU() {
+    return this.plainTextResponseAPDU;
+  }
+}

package/lib/module/Shared/Libs/camera.utils.js

@@ -0,0 +1,32 @@
+"use strict";
+
+const getAverageBrightness = frame => {
+  'worklet';
+
+  const buffer = frame.toArrayBuffer();
+  const data = new Uint8Array(buffer);
+  const width = frame.width;
+  const height = frame.height;
+  const centerX = Math.floor(width / 2);
+  const centerY = Math.floor(height / 2);
+  const halfSizeX = Math.floor(width / 2);
+  const halfSizeY = Math.floor(height / 2);
+  let luminanceSum = 0;
+  let pixelCount = 0;
+  for (let y = centerY - halfSizeY; y < centerY + halfSizeY; y++) {
+    for (let x = centerX - halfSizeX; x < centerX + halfSizeX; x++) {
+      const index = y * width + x;
+      if (data[index] !== undefined) {
+        luminanceSum += data[index];
+        pixelCount++;
+      }
+    }
+  }
+  return luminanceSum / pixelCount;
+};
+const isFrameBright = frame => {
+  'worklet';
+
+  return getAverageBrightness(frame) > 80;
+};
+export { isFrameBright, getAverageBrightness };

package/lib/module/Shared/Libs/contains.js

@@ -0,0 +1,40 @@
+"use strict";
+
+export function contains({
+  outside,
+  inside
+}) {
+  const outsideMaxX = outside.minX + outside.width;
+  const insideMaxX = inside.minX + inside.width;
+  const outsideMaxY = outside.minY + outside.height;
+  const insideMaxY = inside.minY + inside.height;
+  if (inside.minX < outside.minX) {
+    return false;
+  }
+  if (insideMaxX > outsideMaxX) {
+    return false;
+  }
+  if (inside.minY < outside.minY) {
+    return false;
+  }
+  if (insideMaxY > outsideMaxY) {
+    return false;
+  }
+  return true;
+}
+export function contains2({
+  outside,
+  inside
+}) {
+  const outsideMaxX = outside.minX + outside.width;
+  const insideMaxX = inside.minX + inside.width;
+  const outsideMaxY = outside.minY + outside.height;
+  const insideMaxY = inside.minY + inside.height;
+  const xIntersect = Math.max(0, Math.min(insideMaxX, outsideMaxX) - Math.max(inside.minX, outside.minX));
+  const yIntersect = Math.max(0, Math.min(insideMaxY, outsideMaxY) - Math.max(inside.minY, outside.minY));
+  const intersectArea = xIntersect * yIntersect;
+  const insideArea = inside.width * inside.height;
+  const outsideArea = outside.width * outside.height;
+  const unionArea = insideArea + outsideArea - intersectArea;
+  return unionArea === outsideArea;
+}

package/lib/module/Shared/Libs/crypto.utils.js

@@ -0,0 +1,35 @@
+"use strict";
+
+import 'react-native-get-random-values';
+import { Buffer } from 'buffer';
+import { gcm } from '@noble/ciphers/aes';
+import { randomBytes } from '@noble/ciphers/webcrypto';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import httpClient from "./http-client.js";
+const getSessionKey = async (apiUrl, sessionId) => {
+  const clientPrivateKey = secp256k1.utils.randomPrivateKey();
+  const clientPublicKey = secp256k1.getPublicKey(clientPrivateKey);
+  const serverResponse = await httpClient.post(`${apiUrl}/verification-sessions/${sessionId}/auth`, {
+    clientPublicKey: Buffer.from(clientPublicKey).toString('hex')
+  });
+  const sharedKey = secp256k1.getSharedSecret(clientPrivateKey, Buffer.from(serverResponse.serverPublicKey, 'hex').toString('hex'));
+  const sessionKey = (Buffer.from(new Date().getUTCDate().toString(), 'utf-8').toString('hex') + Buffer.from(sharedKey).toString('hex')).substring(0, 32);
+  return sessionKey;
+};
+const encryptWithAes = (data, key) => {
+  const nonce = randomBytes(32);
+  const dataBytes = Buffer.from(data, 'utf-8');
+  const aes = gcm(Buffer.from(key, 'hex'), nonce);
+  const ciphertext = aes.encrypt(dataBytes);
+  return {
+    encryptedData: Buffer.from(ciphertext).toString('hex'),
+    nonce: Buffer.from(nonce).toString('hex')
+  };
+};
+const decryptWithAes = (data, key, nonce) => {
+  const dataBytes = Buffer.from(data, 'hex');
+  const aes = gcm(Buffer.from(key, 'hex'), Buffer.from(nonce, 'hex'));
+  const decrypted = aes.decrypt(dataBytes);
+  return Buffer.from(decrypted).toString('utf-8');
+};
+export { getSessionKey, encryptWithAes, decryptWithAes };

package/lib/module/Shared/Libs/debounce.utils.js

@@ -0,0 +1,35 @@
+"use strict";
+
+/**
+ * Leading edge debounce - executes immediately on first call, then ignores subsequent calls
+ * until the wait period has passed without any calls
+ * @param func Function to debounce
+ * @param wait Wait time in milliseconds
+ * @returns Debounced function that executes immediately on first call
+ */
+const debounce = (func, wait) => {
+  let timeout = null;
+  let lastCallTime = 0;
+  return (...args) => {
+    const now = Date.now();
+
+    // If this is the first call or enough time has passed since last execution
+    if (!timeout || now - lastCallTime >= wait) {
+      // Execute immediately
+      func(...args);
+      lastCallTime = now;
+
+      // Clear any existing timeout
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+
+      // Set new timeout to reset the debounce state
+      timeout = setTimeout(() => {
+        timeout = null;
+      }, wait);
+    }
+    // Subsequent calls within the wait period are ignored
+  };
+};
+export default debounce;

package/lib/module/Shared/Libs/deeplink.utils.js

@@ -0,0 +1,20 @@
+"use strict";
+
+const handleDeepLink = ({
+  url
+}) => {
+  const isHttps = url.includes('https');
+  const route = url.replace(/http(s)?(:)?(\/\/)?/g, '');
+  const segments = route.split('/');
+  let baseUrl = '';
+  let sessionId = '';
+  for (let i = 0; i < segments.length; i++) {
+    if (segments[i] === 'verification-session') {
+      sessionId = segments[i + 1] ?? '';
+    } else if (segments[i] === 'app-url') {
+      baseUrl = `${isHttps ? 'https' : 'http'}://${segments[i + 1]}`;
+    }
+  }
+  return [baseUrl, sessionId];
+};
+export { handleDeepLink };