@trustchex/react-native-sdk 1.161.0

package/lib/module/Shared/EIDReader/java/filterOutputStream.js

@@ -0,0 +1,124 @@
+"use strict";
+
+import { OutputStream } from "./outputStream.js";
+export class FilterOutputStream extends OutputStream {
+  /**
+   * The underlying output stream to be filtered.
+   */
+
+  /**
+   * Whether the stream is closed; implicitly initialized to false.
+   */
+
+  /**
+   * Creates an output stream filter built on top of the specified
+   * underlying output stream.
+   *
+   * @param out the underlying output stream to be assigned to
+   *            the field `this.out` for later use, or
+   *            `null` if this instance is to be
+   *            created without an underlying stream.
+   */
+  constructor(out) {
+    super();
+    this.out = out;
+    this.closed = false;
+  }
+
+  /**
+   * Writes the specified `byte` to this output stream.
+   * <p>
+   * The `write` method of `FilterOutputStream`
+   * calls the `write` method of its underlying output stream,
+   * that is, it performs `out.write(b)`.
+   * <p>
+   * Implements the abstract `write` method of `OutputStream`.
+   *
+   * @param b the byte to be written.
+   * @throws IOException if an I/O error occurs.
+   */
+  write(b) {
+    this.out.write(b);
+  }
+
+  /**
+   * Writes `b.length` bytes to this output stream.
+   *
+   * The `write` method of `FilterOutputStream`
+   * calls its `write` method of three arguments with the
+   * arguments `b`, `0`, and
+   * `b.length`.
+   *
+   * @param b the data to be written.
+   * @throws IOException if an I/O error occurs.
+   */
+  writeBytes(b) {
+    this.writeBytesWithOffset(b, 0, b.length);
+  }
+
+  /**
+   * Writes `len` bytes from the specified
+   * byte array starting at offset `off` to
+   * this output stream.
+   *
+   * The `write` method of `FilterOutputStream`
+   * calls the `write` method of one argument on each
+   * byte to output.
+   *
+   * @param b the data to be written.
+   * @param off the start offset in the data.
+   * @param len the number of bytes to write.
+   * @throws IOException if an I/O error occurs.
+   */
+  writeBytesWithOffset(b, off, len) {
+    for (let i = 0; i < len; i++) {
+      this.write(b[off + i]);
+    }
+  }
+
+  /**
+   * Flushes this output stream and forces any buffered output bytes
+   * to be written out to the stream.
+   *
+   * The `flush` method of `FilterOutputStream`
+   * calls the `flush` method of its underlying output stream.
+   *
+   * @throws IOException if an I/O error occurs.
+   */
+  flush() {
+    this.out.flush();
+  }
+
+  /**
+   * Closes this output stream and releases any system resources
+   * associated with the stream.
+   *
+   * When not already closed, the `close` method of `FilterOutputStream`
+   * calls its `flush` method, and then
+   * calls the `close` method of its underlying output stream.
+   *
+   * @throws IOException if an I/O error occurs.
+   */
+  close() {
+    if (this.closed) {
+      return;
+    }
+    let flushException = null;
+    try {
+      this.flush();
+    } catch (e) {
+      flushException = e;
+      throw e;
+    } finally {
+      if (flushException === null) {
+        this.out.close();
+      } else {
+        try {
+          this.out.close();
+        } catch (closeException) {
+          throw closeException;
+        }
+      }
+    }
+  }
+}

package/lib/module/Shared/EIDReader/java/inputStream.js

@@ -0,0 +1,139 @@
+"use strict";
+
+export class InputStream {
+  // Constants
+  static MAX_SKIP_BUFFER_SIZE = 2048;
+  static DEFAULT_BUFFER_SIZE = 16384;
+  static MAX_BUFFER_SIZE = Number.MAX_SAFE_INTEGER - 8;
+  static listeners = [];
+  readBytes(b) {
+    return this.readBytesWithOffset(b, 0, b.length);
+  }
+  async readBytesWithOffset(b, off, len) {
+    if (off < 0 || len < 0 || off + len > b.length) {
+      throw new RangeError('Invalid offset or length');
+    }
+    if (len === 0) {
+      return 0;
+    }
+    let c = await this.read();
+    if (c === -1) {
+      return -1;
+    }
+    b[off] = c;
+    InputStream.listeners.forEach(listener => {
+      listener(0, len);
+    });
+    let i = 1;
+    try {
+      for (; i < len; i++) {
+        c = await this.read();
+        if (c === -1) {
+          break;
+        }
+        b[off + i] = c;
+        if (i % 1000 === 0) {
+          InputStream.listeners.forEach(listener => {
+            listener(i, len);
+          });
+        }
+      }
+    } catch (e) {}
+    return i;
+  }
+  readAllBytes() {
+    return this.readNBytesAsArray(Number.MAX_SAFE_INTEGER);
+  }
+  async readNBytesAsArray(len) {
+    if (len < 0) {
+      throw new Error('len < 0');
+    }
+    let bufs = [];
+    let total = 0;
+    let remaining = len;
+    let n;
+    do {
+      let buf = new Uint8Array(Math.min(remaining, InputStream.DEFAULT_BUFFER_SIZE));
+      let nread = 0;
+
+      // read to EOF which may read more or less than buffer size
+      while ((n = await this.readBytesWithOffset(buf, nread, Math.min(buf.length - nread, remaining))) > 0) {
+        nread += n;
+        remaining -= n;
+      }
+      if (nread > 0) {
+        if (InputStream.MAX_BUFFER_SIZE - total < nread) {
+          throw new Error('Required array size too large');
+        }
+        total += nread;
+        if (nread < buf.length) {
+          buf = buf.subarray(0, nread);
+        }
+        bufs.push(buf);
+      }
+    } while (n >= 0 && remaining > 0);
+    const result = new Uint8Array(total);
+    let offset = 0;
+    remaining = total;
+    for (let b of bufs) {
+      result.set(b, offset);
+      offset += b.length;
+      remaining -= b.length;
+    }
+    return result;
+  }
+  async readNBytes(b, off, len) {
+    if (off < 0 || len < 0 || off + len > b.length) {
+      throw new RangeError('Invalid offset or length');
+    }
+    let n = 0;
+    while (n < len) {
+      const count = await this.readBytesWithOffset(b, off + n, len - n);
+      if (count < 0) {
+        break;
+      }
+      n += count;
+    }
+    return n;
+  }
+  async skip(n) {
+    let remaining = n;
+    let nr;
+    if (n <= 0) {
+      return 0;
+    }
+    const size = Math.min(InputStream.MAX_SKIP_BUFFER_SIZE, remaining);
+    const skipBuffer = new Uint8Array(size);
+    while (remaining > 0) {
+      nr = await this.readBytesWithOffset(skipBuffer, 0, Math.min(size, remaining));
+      if (nr < 0) {
+        break;
+      }
+      remaining -= nr;
+    }
+    return n - remaining;
+  }
+  async skipNBytes(n) {
+    while (n > 0) {
+      const skipped = await this.skip(n);
+      if (skipped < n) {
+        if ((await this.read()) === -1) {
+          throw new Error('skipNBytes: EOFException');
+        }
+        n -= skipped;
+      }
+    }
+  }
+  markSupported() {
+    return false;
+  }
+  mark(_readLimit) {}
+  available() {
+    return 0;
+  }
+  reset() {}
+  close() {}
+  static onRead(listener) {
+    InputStream.listeners.push(listener);
+  }
+}

package/lib/module/Shared/EIDReader/java/inputStreamBuffer.js

@@ -0,0 +1,144 @@
+"use strict";
+
+import { FragmentBuffer } from "../fragmentBuffer.js";
+import { InputStream } from "./inputStream.js";
+import { PositionInputStream } from "./positionInputStream.js";
+export class InputStreamBuffer {
+  constructor(inputStream, length) {
+    this.carrier = new PositionInputStream(inputStream);
+    this.carrier.mark(length);
+    this.buffer = new FragmentBuffer(length);
+  }
+  updateFrom(other) {
+    this.buffer.updateFrom(other.buffer);
+  }
+  getInputStream() {
+    return new SubInputStream(this.carrier, this.buffer);
+  }
+  getPosition() {
+    return this.buffer.getPosition();
+  }
+  getBytesBuffered() {
+    return this.buffer.getBytesBuffered();
+  }
+  getLength() {
+    return this.buffer.getLength();
+  }
+}
+export class SubInputStream extends InputStream {
+  constructor(carrier, buffer) {
+    super();
+    this.position = 0;
+    this.markedPosition = -1;
+    this.carrier = carrier;
+    this.buffer = buffer;
+  }
+  getBuffer() {
+    return this.buffer;
+  }
+  async read() {
+    if (this.position >= this.buffer.getLength()) {
+      return -1;
+    } else if (this.buffer.isCoveredByFragment(this.position)) {
+      return this.buffer.getBuffer()[this.position++] & 0xff;
+    } else {
+      if (this.carrier.markSupported()) {
+        await this.syncCarrierPosition(this.position);
+      }
+      try {
+        const result = await this.carrier.read();
+        if (result < 0) {
+          return -1;
+        }
+        this.buffer.addFragment(this.position++, result);
+        return result;
+      } catch (ioe) {
+        throw ioe;
+      }
+    }
+  }
+  async readBytesWithOffset(b, off, len) {
+    if (b == null) {
+      throw new Error('Null buffer');
+    } else if (off < 0 || len < 0 || len > b.length - off) {
+      throw new RangeError('Invalid offset or length');
+    } else if (len === 0) {
+      return 0;
+    }
+    if (len > this.buffer.getLength() - this.position) {
+      len = this.buffer.getLength() - this.position;
+    }
+    if (this.position >= this.buffer.getLength()) {
+      return -1;
+    }
+    if (this.carrier.markSupported()) {
+      await this.syncCarrierPosition(this.position);
+    }
+    const fragment = this.buffer.getSmallestUnbufferedFragment(this.position, len);
+    if (fragment.getLength() > 0) {
+      const alreadyBufferedPrefixLength = fragment.getOffset() - this.position;
+      const unbufferedPostfixLength = fragment.getLength();
+      b.set(this.buffer.getBuffer().subarray(this.position, this.position + alreadyBufferedPrefixLength), off);
+      this.position += alreadyBufferedPrefixLength;
+      if (this.carrier.markSupported()) {
+        await this.syncCarrierPosition(this.position);
+      }
+      const bytesReadFromCarrier = await this.carrier.readBytesWithOffset(b, off + alreadyBufferedPrefixLength, unbufferedPostfixLength);
+      this.buffer.addFragmentBytesWithOffset(fragment.getOffset(), b, off + alreadyBufferedPrefixLength, bytesReadFromCarrier);
+      this.position += bytesReadFromCarrier;
+      return alreadyBufferedPrefixLength + bytesReadFromCarrier;
+    } else {
+      const length = Math.min(len, this.buffer.getLength() - this.position);
+      b.set(this.buffer.getBuffer().subarray(this.position, this.position + length), off);
+      this.position += length;
+      return length;
+    }
+  }
+  async skip(n) {
+    const leftInBuffer = this.buffer.getBufferedLength(this.position);
+    if (n <= leftInBuffer) {
+      this.position += n;
+      return n;
+    } else {
+      this.position += leftInBuffer;
+      let skippedBytes = 0;
+      if (this.carrier.markSupported()) {
+        await this.syncCarrierPosition(this.position);
+        skippedBytes = await this.carrier.skip(n - leftInBuffer);
+        this.position += skippedBytes;
+      } else {
+        skippedBytes = await super.skip(n - leftInBuffer);
+      }
+      return leftInBuffer + skippedBytes;
+    }
+  }
+  available() {
+    return this.buffer.getBufferedLength(this.position);
+  }
+  close() {}
+  mark(_readLimit) {
+    this.markedPosition = this.position;
+  }
+  reset() {
+    if (this.markedPosition < 0) {
+      throw new Error('Invalid reset, was mark() called?');
+    }
+    this.position = this.markedPosition;
+  }
+  markSupported() {
+    return true;
+  }
+  getPosition() {
+    return this.position;
+  }
+  async syncCarrierPosition(position) {
+    if (position === this.carrier.getPosition()) {
+      return;
+    }
+    this.carrier.reset();
+    let bytesSkipped = 0;
+    while (bytesSkipped < position) {
+      bytesSkipped += await this.carrier.skip(position - bytesSkipped);
+    }
+  }
+}

package/lib/module/Shared/EIDReader/java/objectInputStream.js

@@ -0,0 +1,39 @@
+"use strict";
+
+import { InputStream } from "./inputStream.js";
+export class ObjectInputStream extends InputStream {
+  constructor(buffer) {
+    super();
+    this.buffer = buffer;
+    this.pos = 0;
+  }
+  readObject() {
+    const jsonString = new TextDecoder().decode(this.buffer.slice(this.pos));
+    try {
+      const obj = JSON.parse(jsonString);
+      this.pos = this.buffer.length; // Move position to the end after reading
+      return obj;
+    } catch (e) {
+      throw new Error('Failed to deserialize object');
+    }
+  }
+  readUnshared() {
+    const jsonString = new TextDecoder().decode(this.buffer.slice(this.pos));
+    try {
+      const obj = JSON.parse(jsonString);
+      this.pos = this.buffer.length; // Move position to the end after reading
+      return JSON.parse(JSON.stringify(obj)); // Return a deep copy
+    } catch (e) {
+      throw new Error('Failed to deserialize object');
+    }
+  }
+  read() {
+    if (this.pos >= this.buffer.length) {
+      return Promise.resolve(-1);
+    }
+    return Promise.resolve(this.buffer[this.pos++]);
+  }
+  close() {
+    // No resources to release, but this method is here for compatibility
+  }
+}

package/lib/module/Shared/EIDReader/java/outputStream.js

@@ -0,0 +1,77 @@
+"use strict";
+
+export class OutputStream {
+  /**
+   * Writes the specified byte to this output stream. The general
+   * contract for `write` is that one byte is written to the output stream.
+   * The byte to be written is the eight low-order bits of the argument `b`.
+   * The 24 high-order bits of `b` are ignored.
+   *
+   * @param b - the byte to write.
+   * @throws an error if an I/O error occurs. In particular,
+   * an error may be thrown if the output stream has been closed.
+   */
+
+  /**
+   * Writes `b.length` bytes from the specified byte array to this output stream.
+   * The general contract for `write(b)` is that it should have exactly the same
+   * effect as the call `write(b, 0, b.length)`.
+   *
+   * @param b - the data to write.
+   * @throws an error if an I/O error occurs.
+   */
+  writeBytes(b) {
+    this.writeBytesWithOffset(b, 0, b.length);
+  }
+
+  /**
+   * Writes `len` bytes from the specified byte array starting at offset `off`
+   * to this output stream. The general contract for `write(b, off, len)` is that
+   * some of the bytes in the array `b` are written to the output stream in order;
+   * element `b[off]` is the first byte written and `b[off+len-1]` is the last byte written
+   * by this operation.
+   *
+   * @param b - the data to write.
+   * @param off - the start offset in the data.
+   * @param len - the number of bytes to write.
+   * @throws an error if an I/O error occurs.
+   */
+  writeBytesWithOffset(b, off, len) {
+    if (off < 0 || len < 0 || off + len > b.length) {
+      throw new RangeError('Invalid offset or length');
+    }
+    for (let i = 0; i < len; i++) {
+      this.write(b[off + i]);
+    }
+  }
+
+  /**
+   * Flushes this output stream and forces any buffered output bytes
+   * to be written out. The general contract of `flush` is that calling it is
+   * an indication that, if any bytes previously written have been buffered by
+   * the implementation of the output stream, such bytes should immediately be
+   * written to their intended destination.
+   *
+   * If the intended destination of this stream is an abstraction provided by
+   * the underlying operating system, for example a file, then flushing the
+   * stream guarantees only that bytes previously written to the stream are
+   * passed to the operating system for writing; it does not guarantee that
+   * they are actually written to a physical device such as a disk drive.
+   *
+   * The `flush` method of `OutputStream` does nothing by default.
+   *
+   * @throws an error if an I/O error occurs.
+   */
+  flush() {}
+
+  /**
+   * Closes this output stream and releases any system resources associated with this stream.
+   * The general contract of `close` is that it closes the output stream.
+   * A closed stream cannot perform output operations and cannot be reopened.
+   *
+   * The `close` method of `OutputStream` does nothing by default.
+   *
+   * @throws an error if an I/O error occurs.
+   */
+  close() {}
+}

package/lib/module/Shared/EIDReader/java/positionInputStream.js

@@ -0,0 +1,50 @@
+"use strict";
+
+import { InputStream } from "./inputStream.js";
+import { Buffer } from 'buffer';
+export class PositionInputStream extends InputStream {
+  static MARK_NOT_SET = -1;
+  constructor(carrier) {
+    super();
+    this.carrier = carrier;
+    this.position = 0;
+    this.markedPosition = PositionInputStream.MARK_NOT_SET;
+  }
+  async read() {
+    const buffer = Buffer.alloc(1);
+    const bytesRead = await this.carrier.readBytes(buffer);
+    if (bytesRead > 0) {
+      this.position++;
+    }
+    return buffer[0].valueOf();
+  }
+  async readWithOffset(dest, offset, length) {
+    const buffer = Buffer.alloc(length);
+    const bytesRead = await this.carrier.readBytesWithOffset(buffer, 0, length);
+    buffer.copy(dest, offset, 0, bytesRead);
+    this.position += bytesRead;
+    return bytesRead;
+  }
+  async skip(n) {
+    const skippedBytes = await this.carrier.skip(n);
+    if (skippedBytes <= 0) {
+      console.debug(`Carrier (${this.carrier.constructor.name})'s skip(${n}) only skipped ${skippedBytes}, position = ${this.position}`);
+    }
+    this.position += skippedBytes;
+    return skippedBytes;
+  }
+  mark(readLimit) {
+    this.carrier.mark(readLimit);
+    this.markedPosition = this.position;
+  }
+  reset() {
+    this.carrier.reset();
+    this.position = this.markedPosition;
+  }
+  markSupported() {
+    return this.carrier.markSupported();
+  }
+  getPosition() {
+    return this.position;
+  }
+}

package/lib/module/Shared/EIDReader/java/splittableInputStream.js

@@ -0,0 +1,54 @@
+"use strict";
+
+import { InputStreamBuffer } from "./inputStreamBuffer.js";
+export class SplittableInputStream {
+  constructor(inputStream, length) {
+    this.inputStreamBuffer = new InputStreamBuffer(inputStream, length);
+    this.carrier = this.inputStreamBuffer.getInputStream();
+  }
+  updateFrom(other) {
+    this.inputStreamBuffer.updateFrom(other.inputStreamBuffer);
+  }
+  async getInputStream(position) {
+    try {
+      const inputStream = this.inputStreamBuffer.getInputStream();
+      let skippedBytes = 0;
+      while (skippedBytes < position) {
+        skippedBytes += await inputStream.skip(position - skippedBytes);
+      }
+      return inputStream;
+    } catch (error) {
+      throw new Error('Error getting input stream');
+    }
+  }
+  getPosition() {
+    return this.carrier.getPosition();
+  }
+  async read() {
+    return this.carrier.read();
+  }
+  async skip(n) {
+    return await this.carrier.skip(n);
+  }
+  available() {
+    return this.carrier.available();
+  }
+  close() {
+    this.carrier.close();
+  }
+  mark(readLimit) {
+    this.carrier.mark(readLimit);
+  }
+  reset() {
+    this.carrier.reset();
+  }
+  markSupported() {
+    return this.carrier.markSupported();
+  }
+  getLength() {
+    return this.inputStreamBuffer.getLength();
+  }
+  getBytesBuffered() {
+    return this.inputStreamBuffer.getBytesBuffered();
+  }
+}