@trustchex/react-native-sdk 1.161.0

package/lib/module/Shared/EIDReader/lds/icao/comFile.js

@@ -0,0 +1,101 @@
+"use strict";
+
+import { TLVInputStream } from "../../tlv/tlvInputStream.js";
+import { TLVOutputStream } from "../../tlv/tlvOutputStream.js";
+import { AbstractTaggedLDSFile } from "../abstractTaggedLDSFile.js";
+export class COMFile extends AbstractTaggedLDSFile {
+  static TAG_LIST_TAG = 0x5c;
+  static VERSION_UNICODE_TAG = 0x5f36;
+  static VERSION_LDS_TAG = 0x5f01;
+  tagList = [];
+  constructor(versionLDS, updateLevelLDS, majorVersionUnicode, minorVersionUnicode, releaseLevelUnicode, tagList) {
+    super(COMFile.EF_COM_TAG, null);
+    if (versionLDS === null || versionLDS.length !== 2 || updateLevelLDS === null || updateLevelLDS.length !== 2 || majorVersionUnicode === null || majorVersionUnicode.length !== 2 || minorVersionUnicode === null || minorVersionUnicode.length !== 2 || releaseLevelUnicode === null || releaseLevelUnicode.length !== 2 || tagList === null) {
+      throw new Error('Invalid arguments');
+    }
+    this.versionLDS = versionLDS;
+    this.updateLevelLDS = updateLevelLDS;
+    this.majorVersionUnicode = majorVersionUnicode;
+    this.minorVersionUnicode = minorVersionUnicode;
+    this.releaseLevelUnicode = releaseLevelUnicode;
+    this.tagList = [...tagList];
+  }
+  async readContent(is) {
+    const tlvIn = is instanceof TLVInputStream ? is : new TLVInputStream(is);
+    const versionLDSTag = await tlvIn.readTag();
+    if (versionLDSTag !== COMFile.VERSION_LDS_TAG) {
+      throw new Error(`Expected VERSION_LDS_TAG (${COMFile.VERSION_LDS_TAG.toString(16)}), found ${versionLDSTag.toString(16)}`);
+    }
+    const versionLDSLength = await tlvIn.readLength();
+    if (versionLDSLength !== 4) {
+      throw new Error('Wrong length of LDS version object');
+    }
+    const versionLDSBytes = await tlvIn.readValue();
+    this.versionLDS = new TextDecoder().decode(new Uint8Array(versionLDSBytes.slice(0, 2)).buffer);
+    this.updateLevelLDS = new TextDecoder().decode(new Uint8Array(versionLDSBytes.slice(2, 4)).buffer);
+    const versionUnicodeTag = await tlvIn.readTag();
+    if (versionUnicodeTag !== COMFile.VERSION_UNICODE_TAG) {
+      throw new Error(`Expected VERSION_UNICODE_TAG (${COMFile.VERSION_UNICODE_TAG.toString(16)}), found ${versionUnicodeTag.toString(16)}`);
+    }
+    const versionUnicodeLength = await tlvIn.readLength();
+    if (versionUnicodeLength !== 6) {
+      throw new Error('Wrong length of LDS version object');
+    }
+    const versionUnicodeBytes = await tlvIn.readValue();
+    this.majorVersionUnicode = new TextDecoder().decode(new Uint8Array(versionUnicodeBytes.slice(0, 2)).buffer);
+    this.minorVersionUnicode = new TextDecoder().decode(new Uint8Array(versionUnicodeBytes.slice(2, 4)).buffer);
+    this.releaseLevelUnicode = new TextDecoder().decode(new Uint8Array(versionUnicodeBytes.slice(4, 6)).buffer);
+    const tagListTag = await tlvIn.readTag();
+    if (tagListTag !== COMFile.TAG_LIST_TAG) {
+      throw new Error(`Expected TAG_LIST_TAG (${COMFile.TAG_LIST_TAG.toString(16)}), found ${tagListTag.toString(16)}`);
+    }
+    tlvIn.readLength(); // Ignore tagListLength
+    const tagBytes = await tlvIn.readValue();
+    this.tagList = Array.from(tagBytes);
+  }
+  getLDSVersion() {
+    let ldsVersion = `${this.versionLDS}.${this.updateLevelLDS}`;
+    try {
+      const major = parseInt(this.versionLDS, 10);
+      const minor = parseInt(this.updateLevelLDS, 10);
+      ldsVersion = major + '.' + minor;
+    } catch (error) {
+      // Leave ldsVersion as is
+    }
+    return ldsVersion;
+  }
+  getUnicodeVersion() {
+    let unicodeVersion = `${this.majorVersionUnicode}.${this.minorVersionUnicode}.${this.releaseLevelUnicode}`;
+    try {
+      const major = parseInt(this.majorVersionUnicode, 10);
+      const minor = parseInt(this.minorVersionUnicode, 10);
+      const releaseLevel = parseInt(this.releaseLevelUnicode, 10);
+      unicodeVersion = `${major}.${minor}.${releaseLevel}`;
+    } catch (error) {
+      // Leave unicodeVersion as is
+    }
+    return unicodeVersion;
+  }
+  getTagList() {
+    return this.tagList;
+  }
+  insertTag(tag) {
+    if (this.tagList.includes(tag)) {
+      return;
+    }
+    this.tagList.push(tag);
+    this.tagList.sort();
+  }
+  writeContent(out) {
+    const tlvOut = out instanceof TLVOutputStream ? out : new TLVOutputStream(out);
+    tlvOut.writeTag(COMFile.VERSION_LDS_TAG);
+    tlvOut.writeValue(new TextEncoder().encode(this.versionLDS + this.updateLevelLDS));
+    tlvOut.writeTag(COMFile.VERSION_UNICODE_TAG);
+    tlvOut.writeValue(new TextEncoder().encode(this.majorVersionUnicode + this.minorVersionUnicode + this.releaseLevelUnicode));
+    tlvOut.writeTag(COMFile.TAG_LIST_TAG);
+    tlvOut.writeLength(this.tagList.length);
+    for (const tag of this.tagList) {
+      tlvOut.write(tag);
+    }
+  }
+}

package/lib/module/Shared/EIDReader/lds/icao/dg1File.js

@@ -0,0 +1,33 @@
+"use strict";
+
+import { TLVInputStream } from "../../tlv/tlvInputStream.js";
+import { TLVOutputStream } from "../../tlv/tlvOutputStream.js";
+import { DataGroup } from "../dataGroup.js";
+import { MRZInfo } from "./mrzInfo.js";
+export class DG1File extends DataGroup {
+  static MRZ_INFO_TAG = 0x5f1f;
+  constructor(mrzInfo, is) {
+    super(DG1File.EF_DG1_TAG, is);
+    if (this.mrzInfo) {
+      this.mrzInfo = mrzInfo;
+    }
+  }
+  async getMRZInfo() {
+    await super.readObject();
+    return this.mrzInfo;
+  }
+  async readContent(inputStream) {
+    const tlvIn = inputStream instanceof TLVInputStream ? inputStream : new TLVInputStream(inputStream);
+    await tlvIn.skipToTag(DG1File.MRZ_INFO_TAG);
+    const length = await tlvIn.readLength();
+    this.mrzInfo = await MRZInfo.fromStream(tlvIn, length);
+  }
+  writeContent(out) {
+    const tlvOut = out instanceof TLVOutputStream ? out : new TLVOutputStream(out);
+    tlvOut.writeTag(DG1File.MRZ_INFO_TAG);
+    const value = this.mrzInfo?.getEncoded();
+    if (value) {
+      tlvOut.writeValue(value);
+    }
+  }
+}

package/lib/module/Shared/EIDReader/lds/icao/dg2File.js

@@ -0,0 +1,42 @@
+"use strict";
+
+import { FaceDataBlockDecoder } from "../../cbeff/faceDataBlockDecoder.js";
+import { ISO781611Decoder } from "../../cbeff/iso781611Decoder.js";
+import { SimpleCBEFFInfo } from "../../cbeff/simpleCBEFFInfo.js";
+import { CBEFFDataGroup } from "../cbeffDataGroup.js";
+import { FaceInfo } from "../iso19794/faceInfo.js";
+export class DG2File extends CBEFFDataGroup {
+  static DECODER = new ISO781611Decoder(new FaceDataBlockDecoder());
+  constructor(faceInfos, is) {
+    super(DG2File.EF_DG2_TAG, faceInfos, is);
+  }
+  async readContent(inputStream) {
+    const complexCBEFFInfo = await DG2File.DECODER.decode(inputStream);
+    const records = complexCBEFFInfo?.getSubRecords() ?? [];
+    for (const cbeffInfo of records) {
+      if (!(cbeffInfo instanceof SimpleCBEFFInfo)) {
+        throw new Error(`Was expecting a SimpleCBEFFInfo, found ${cbeffInfo.constructor.name}`);
+      }
+      const simpleCBEFFInfo = cbeffInfo;
+      const bdb = simpleCBEFFInfo.getBiometricDataBlock();
+      if (!(bdb instanceof FaceInfo)) {
+        throw new Error(`Was expecting a FaceInfo, found ${bdb.constructor.name}`);
+      }
+      const faceInfo = bdb;
+      this.add(faceInfo);
+    }
+  }
+  async getFaceInfos() {
+    await this.readObject();
+    return this.getSubRecords();
+  }
+  addFaceInfo(faceInfo) {
+    this.add(faceInfo);
+  }
+  removeFaceInfo(index) {
+    this.remove(index);
+  }
+  writeContent(_outputStream) {
+    throw new Error('Method not implemented.');
+  }
+}

package/lib/module/Shared/EIDReader/lds/icao/icaoCountry.js

@@ -0,0 +1,114 @@
+"use strict";
+
+import { Country } from "../../data/country.js";
+export class ICAOCountry extends Country {
+  static DE = new ICAOCountry('DE', 'D<<', 'Germany', 'German');
+  static RKS = new ICAOCountry('KS', 'RKS', 'Republic of Kosovo', 'Kosovar');
+  static GBD = new ICAOCountry('GB', 'GBD', 'British Dependent territories citizen');
+  static GBN = new ICAOCountry('GB', 'GBN', 'British National (Overseas)');
+  static GBO = new ICAOCountry('GB', 'GBO', 'British Overseas citizen');
+  static GBP = new ICAOCountry('GB', 'GBP', 'British Protected person');
+  static GBS = new ICAOCountry('GB', 'GBS', 'British Subject');
+  static XXA = new ICAOCountry('XX', 'XXA', 'Stateless person', 'Stateless');
+  static XXB = new ICAOCountry('XX', 'XXB', 'Refugee', 'Refugee');
+  static XXC = new ICAOCountry('XX', 'XXC', 'Refugee (other)', 'Refugee (other)');
+  static XXX = new ICAOCountry('XX', 'XXX', 'Unspecified', 'Unspecified');
+
+  /** Part B: Europe. */
+  static EUE = new ICAOCountry('EU', 'EUE', 'Europe', 'European');
+
+  /** Part C: Codes for Use in United Nations Travel Documents. */
+  static UNO = new ICAOCountry('UN', 'UNO', 'United Nations Organization');
+  static UNA = new ICAOCountry('UN', 'UNA', 'United Nations Agency');
+  static UNK = new ICAOCountry('UN', 'UNK', 'United Nations Interim Administration Mission in Kosovo');
+
+  /** Part D: Other issuing authorities. */
+  static XBA = new ICAOCountry('XX', 'XBA', 'African Development Bank (ADB)');
+  static XIM = new ICAOCountry('XX', 'XIM', 'African Export-Import Bank (AFREXIM bank)');
+  static XCC = new ICAOCountry('XC', 'XCC', 'Carribean Community or one of its emissaries (CARICOM)');
+  static XCE = new ICAOCountry('XX', 'XCE', 'Council of Europe');
+  static XCO = new ICAOCountry('XX', 'XCO', 'Common Market for Eastern an Southern Africa (COMESA)');
+  static XEC = new ICAOCountry('XX', 'XEC', 'Economic Community of West African States (ECOWAS)');
+  static XPO = new ICAOCountry('XP', 'XPO', 'International Criminal Police Organization (INTERPOL)');
+  static XES = new ICAOCountry('XX', 'XES', 'Organization of Eastern Caribbean States (OECS)');
+  static XMP = new ICAOCountry('XX', 'XMP', 'Parliamentary Assembly of the Mediterranean (PAM)');
+  static XOM = new ICAOCountry('XO', 'XOM', 'Sovereign Military Order of Malta or one of its emissaries');
+  static XDC = new ICAOCountry('XX', 'XDC', 'Southern African Development Community');
+  static VALUES = [ICAOCountry.DE, ICAOCountry.RKS, ICAOCountry.GBD, ICAOCountry.GBN, ICAOCountry.GBO, ICAOCountry.GBP, ICAOCountry.GBS, ICAOCountry.XXA, ICAOCountry.XXB, ICAOCountry.XXC, ICAOCountry.XXX, ICAOCountry.EUE, ICAOCountry.UNO, ICAOCountry.UNA, ICAOCountry.UNK, ICAOCountry.XBA, ICAOCountry.XIM, ICAOCountry.XCC, ICAOCountry.XCO, ICAOCountry.XEC, ICAOCountry.XPO, ICAOCountry.XOM];
+  /**
+   * Constructs a country.
+   *
+   * @param alpha2Code the 2-letter alpha code
+   * @param alpha3Code the 3-letter alpha code
+   * @param name a name for the country
+   * @param nationality a name for nationals of the country
+   */
+  constructor(alpha2Code, alpha3Code, name, nationality) {
+    super();
+    this.alpha2Code = alpha2Code;
+    this.alpha3Code = alpha3Code;
+    this.name = name;
+    this.nationality = nationality || name;
+  }
+
+  /**
+   * Returns an ICAO country instance.
+   *
+   * @param alpha3Code a three-digit ICAO country code
+   *
+   * @return an ICAO country
+   */
+  static getInstance(alpha3Code) {
+    for (const country of ICAOCountry.VALUES) {
+      if (country.alpha3Code === alpha3Code) {
+        return country;
+      }
+    }
+    try {
+      return Country.getInstance(alpha3Code);
+    } catch (e) {
+      /* NOTE: ignore this exception if it's not a legal 3 digit code. */
+      console.debug('Unknown country', e);
+    }
+    throw new Error('Illegal ICAO country alpha 3 code ' + alpha3Code);
+  }
+  valueOf() {
+    return -1;
+  }
+
+  /**
+   * Returns the full name of the country.
+   *
+   * @return a country name
+   */
+  getName() {
+    return this.name;
+  }
+
+  /**
+   * Returns the adjectival form corresponding to the country.
+   *
+   * @return the nationality
+   */
+  getNationality() {
+    return this.nationality;
+  }
+
+  /**
+   * Returns the two-digit country code.
+   *
+   * @return a two-digit country code
+   */
+  toAlpha2Code() {
+    return this.alpha2Code;
+  }
+
+  /**
+   * Returns the three-digit country code.
+   *
+   * @return a three-digit country code
+   */
+  toAlpha3Code() {
+    return this.alpha3Code;
+  }
+}