@trustchex/react-native-sdk 1.355.1 → 1.357.0

package/lib/module/Shared/Components/QrCodeScannerCamera.js

@@ -1,118 +1,99 @@
 "use strict";
 
-import React, { useEffect } from 'react';
-import { View, StyleSheet, ActivityIndicator, Text as TextView, Text, Linking, Platform } from 'react-native';
-import { Camera, useCameraDevice, useCameraFormat, useCameraPermission, useFrameProcessor } from 'react-native-vision-camera';
-import { useRunOnJS, useSharedValue } from 'react-native-worklets-core';
+import React, { useEffect, useRef, useCallback, useState } from 'react';
+import { View, StyleSheet, ActivityIndicator, Text as TextView, Text, Linking, Platform, PermissionsAndroid, TouchableOpacity } from 'react-native';
+import { TrustchexCamera } from "./TrustchexCamera.js";
 import { useKeepAwake } from "../Libs/native-keep-awake.utils.js";
 import { useIsFocused } from '@react-navigation/native';
 import { useTranslation } from 'react-i18next';
+import { debugLog, logError } from "../Libs/debug.utils.js";
 import LottieView from 'lottie-react-native';
-import { scanCodes } from "../VisionCameraPlugins/BarcodeScanner/index.js";
 import StyledButton from "./StyledButton.js";
 import { useTheme } from "../Contexts/ThemeContext.js";
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const QrCodeScannerCamera = ({
-  onQrCodeScanned
+  onQrCodeScanned,
+  onClose
 }) => {
   useKeepAwake();
   const theme = useTheme();
-  const cameraPermission = useCameraPermission();
-  const [permissionsRequested, setPermissionsRequested] = React.useState(false);
-  const [isActive, setIsActive] = React.useState(false);
+  const insets = useSafeAreaInsets();
+  const cameraRef = useRef(null);
+  const [hasPermission, setHasPermission] = useState(false);
+  const [permissionsRequested, setPermissionsRequested] = useState(false);
+  const [isActive, setIsActive] = useState(false);
   const isFocused = useIsFocused();
-  const device = useCameraDevice('back', {
-    physicalDevices: ['wide-angle-camera']
-  });
-  const format = useCameraFormat(device, [{
-    videoResolution: {
-      width: 1920,
-      height: 1080
-    },
-    iso: 'max',
-    photoHdr: false,
-    videoHdr: false
-  }]);
-  const isCameraInitialized = useSharedValue(false);
   const {
     t
   } = useTranslation();
-  const isInScanningFrame = (code, width, height, orientation) => {
+  const lastScanTime = useRef(0);
+  const hasScanned = useRef(false);
+  const isInScanningFrame = (boundingBox, width, height) => {
+    // Match UI scanArea: top: '35%', left: '3%', right: '3%', bottom: '35%'
+    // Add 2% margin buffer to ensure code is comfortably inside frame
+    const marginBuffer = 0.02;
     const scanningFrame = {
-      x: 0.35 * width,
-      y: 0.03 * height,
-      width: 0.3 * width,
-      height: 0.94 * height
+      left: width * (0.03 + marginBuffer),
+      top: height * (0.35 + marginBuffer),
+      right: width * (0.97 - marginBuffer),
+      bottom: height * (0.65 - marginBuffer)
     };
-    if (orientation === 'landscape-right' || orientation === 'landscape-left') {
-      // Adjust scanning frame for landscape orientation
-      scanningFrame.x = 0.03 * height;
-      scanningFrame.y = 0.35 * width;
-      scanningFrame.width = 0.94 * height;
-      scanningFrame.height = 0.3 * width;
-    }
+    console.log(`[QR Frame Check] Frame: ${width}x${height}, Scanning: left=${scanningFrame.left}, top=${scanningFrame.top}, right=${scanningFrame.right}, bottom=${scanningFrame.bottom}`);
+    console.log(`[QR Frame Check] Code bbox: left=${boundingBox.left}, top=${boundingBox.top}, right=${boundingBox.right}, bottom=${boundingBox.bottom}`);
 
-    // Assuming Barcode has a boundingBox property: { x, y, width, height }
-    const boundingBox = code.boundingBox;
-    if (!boundingBox) {
-      return false;
-    }
-    const codeX = boundingBox.origin.x;
-    const codeY = boundingBox.origin.y;
-    const codeWidth = boundingBox.size.width;
-    const codeHeight = boundingBox.size.height;
-    const codeRight = codeX + codeWidth;
-    const codeBottom = codeY + codeHeight;
-    const frameRight = scanningFrame.x + scanningFrame.width;
-    const frameBottom = scanningFrame.y + scanningFrame.height;
-
-    // Check if the code is within the scanning frame
-    if (codeX >= scanningFrame.x && codeY >= scanningFrame.y && codeRight <= frameRight && codeBottom <= frameBottom) {
-      return true;
-    }
-    return false;
+    // Check if entire bounding box is within scanning frame (with margin buffer)
+    const isInFrame = boundingBox.left >= scanningFrame.left && boundingBox.top >= scanningFrame.top && boundingBox.right <= scanningFrame.right && boundingBox.bottom <= scanningFrame.bottom;
+    console.log(`[QR Frame Check] Is in frame: ${isInFrame}`);
+    return isInFrame;
   };
-  const handleQrCode = useRunOnJS((code, width, height, orientation) => {
-    // TODO: Fix iOS coordinates - iOS coordinate system conversion may be incorrect
-    // causing frame checking to fail. Need to verify coordinate normalization
-    // between iOS Vision framework and React Native coordinate systems.
+  const handleFrame = useCallback(async event => {
+    if (hasScanned.current) return;
+    const now = Date.now();
+    // Throttle to ~3 FPS for QR scanning
+    if (now - lastScanTime.current < 333) {
+      return;
+    }
+    lastScanTime.current = now;
+    const {
+      frame
+    } = event.nativeEvent;
+    try {
+      // Barcodes are already detected natively — read directly from frame
+      const barcodes = frame.barcodes;
+      if (!barcodes || barcodes.length !== 1) return;
+      const code = barcodes[0];
 
-    // On iOS, skip frame checking and scan any QR code found
-    if (Platform.OS === 'ios') {
-      if (code.value) {
-        onQrCodeScanned(code.value);
-      }
-    } else {
-      // On Android, continue with frame checking
-      if (isInScanningFrame(code, width, height, orientation) && code.value) {
-        onQrCodeScanned(code.value);
+      // Use frame checking on both platforms for consistent behavior
+      if (code.boundingBox && isInScanningFrame(code.boundingBox, frame.width, frame.height) && code.rawValue) {
+        hasScanned.current = true;
+        onQrCodeScanned(code.rawValue);
       }
+    } catch (error) {
+      logError('[QrCodeScannerCamera] Error processing frame:', error);
     }
   }, [onQrCodeScanned]);
-  const frameProcessor = useFrameProcessor(frame => {
-    'worklet';
-
-    if (!isCameraInitialized.value) {
-      return;
-    }
-    const codes = scanCodes(frame, {
-      barcodeTypes: ['qr']
-    });
-    if (codes && codes.length === 1) {
-      handleQrCode(codes[0], frame.width, frame.height, frame.orientation);
-    }
+  const handleCameraReady = useCallback(() => {
+    debugLog('QrCodeScannerCamera', '[QrCodeScannerCamera] Camera ready');
+  }, []);
+  const handleCameraError = useCallback(event => {
+    logError('[QrCodeScannerCamera] Camera error:', event.nativeEvent.error);
   }, []);
   useEffect(() => {
     const requestPermissions = async () => {
-      if (!cameraPermission.hasPermission) {
-        await cameraPermission.requestPermission();
+      if (Platform.OS === 'android') {
+        const granted = await PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.CAMERA);
+        setHasPermission(granted === PermissionsAndroid.RESULTS.GRANTED);
+      } else {
+        // iOS permissions handled by native camera
+        setHasPermission(true);
       }
       setPermissionsRequested(true);
     };
     requestPermissions();
-  }, [cameraPermission]);
+  }, []);
   useEffect(() => {
-    if (!!device && !!format && isFocused) {
+    if (isFocused && hasPermission) {
       setIsActive(true);
     } else {
       setIsActive(false);
@@ -120,7 +101,7 @@ const QrCodeScannerCamera = ({
     return () => {
       setIsActive(false);
     };
-  }, [device, format, isFocused]);
+  }, [isFocused, hasPermission]);
   if (!permissionsRequested) {
     return /*#__PURE__*/_jsx(View, {
       style: styles.permissionContainer,
@@ -130,8 +111,7 @@ const QrCodeScannerCamera = ({
       })
     });
   }
-  if (!cameraPermission.hasPermission) {
-    // Camera permission denied by user - their choice, not actionable
+  if (!hasPermission) {
     return /*#__PURE__*/_jsxs(View, {
       style: styles.permissionContainer,
       children: [/*#__PURE__*/_jsx(Text, {
@@ -146,31 +126,18 @@ const QrCodeScannerCamera = ({
       })]
     });
   }
-  if (device == null) {
-    // No camera device - device limitation, not actionable
-    return /*#__PURE__*/_jsx(View, {
-      style: styles.permissionContainer,
-      children: /*#__PURE__*/_jsx(TextView, {
-        style: styles.permissionText,
-        children: t('general.noCameraDetected')
-      })
-    });
-  }
   return /*#__PURE__*/_jsxs(View, {
     style: StyleSheet.absoluteFill,
-    children: [/*#__PURE__*/_jsx(Camera, {
+    children: [/*#__PURE__*/_jsx(TrustchexCamera, {
+      ref: cameraRef,
       style: StyleSheet.absoluteFill,
-      frameProcessor: frameProcessor,
-      device: device,
-      format: format,
-      isActive: isActive,
-      photo: false,
-      video: false,
-      audio: false,
-      onInitialized: () => {
-        isCameraInitialized.value = true;
-      },
-      fps: 30
+      cameraType: "back",
+      enableFrameProcessing: isActive,
+      enableBarcodeScanning: isActive,
+      targetFps: 30,
+      onFrameAvailable: handleFrame,
+      onCameraReady: handleCameraReady,
+      onCameraError: handleCameraError
     }), /*#__PURE__*/_jsx(View, {
       style: styles.topZone,
       children: /*#__PURE__*/_jsx(TextView, {
@@ -191,6 +158,22 @@ const QrCodeScannerCamera = ({
         loop: true,
         autoPlay: true
       })
+    }), onClose && /*#__PURE__*/_jsx(TouchableOpacity, {
+      onPress: onClose,
+      style: [styles.backButton, {
+        top: Math.max(insets.top + 10, 50)
+      }],
+      hitSlop: {
+        top: 10,
+        bottom: 10,
+        left: 10,
+        right: 10
+      },
+      activeOpacity: 0.7,
+      children: /*#__PURE__*/_jsx(TextView, {
+        style: styles.backButtonText,
+        children: "\xD7"
+      })
     })]
   });
 };
@@ -246,6 +229,25 @@ const styles = StyleSheet.create({
     fontWeight: 'bold',
     padding: 20
   },
+  backButton: {
+    position: 'absolute',
+    top: 20,
+    left: 20,
+    width: 40,
+    height: 40,
+    borderRadius: 20,
+    backgroundColor: 'rgba(255, 255, 255, 0.3)',
+    justifyContent: 'center',
+    alignItems: 'center',
+    zIndex: 999,
+    elevation: 5
+  },
+  backButtonText: {
+    color: 'white',
+    fontSize: 28,
+    fontWeight: 'bold',
+    lineHeight: 28
+  },
   leftZone: {
     position: 'absolute',
     top: '35%',

package/lib/module/Shared/Components/TrustchexCamera.js

@@ -0,0 +1,122 @@
+"use strict";
+
+import React, { useRef, useCallback } from 'react';
+import { requireNativeComponent, StyleSheet } from 'react-native';
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
+import { logError } from "../Libs/debug.utils.js";
+
+// Native component interface
+import { jsx as _jsx } from "react/jsx-runtime";
+const TrustchexCameraViewNative = requireNativeComponent('TrustchexCamera');
+
+// Commands interface for Fabric
+
+const Commands = codegenNativeCommands({
+  supportedCommands: ['setFocusPoint', 'setExposureOffset', 'startRecording', 'stopRecording', 'cancelRecording', 'deleteRecording']
+});
+
+// Frame data structure — ML Kit results come pre-processed from native
+
+export const TrustchexCamera = /*#__PURE__*/React.forwardRef((props, ref) => {
+  const cameraRef = useRef(null);
+  const recordingCallbacksRef = useRef({});
+  const handleRecordingFinished = useCallback(event => {
+    recordingCallbacksRef.current.onRecordingFinished?.({
+      path: event.nativeEvent.path
+    });
+  }, []);
+  const handleRecordingError = useCallback(event => {
+    recordingCallbacksRef.current.onRecordingError?.({
+      error: event.nativeEvent.error
+    });
+  }, []);
+  const setFocusPoint = useCallback((x, y) => {
+    try {
+      if (cameraRef.current) {
+        Commands.setFocusPoint(cameraRef.current, x, y);
+      }
+    } catch (error) {
+      logError('[TrustchexCamera] setFocusPoint error:', error);
+    }
+  }, []);
+  const setExposureOffset = useCallback(offset => {
+    try {
+      if (cameraRef.current) {
+        Commands.setExposureOffset(cameraRef.current, offset);
+      }
+    } catch (error) {
+      logError('[TrustchexCamera] setExposureOffset error:', error);
+    }
+  }, []);
+  const startRecording = useCallback(options => {
+    recordingCallbacksRef.current = {
+      onRecordingFinished: options.onRecordingFinished,
+      onRecordingError: options.onRecordingError
+    };
+    try {
+      if (cameraRef.current) {
+        Commands.startRecording(cameraRef.current);
+      }
+    } catch (error) {
+      logError('[TrustchexCamera] startRecording error:', error);
+      options.onRecordingError?.({
+        error: error.message
+      });
+    }
+  }, []);
+  const stopRecording = useCallback(() => {
+    return new Promise(resolve => {
+      try {
+        if (cameraRef.current) {
+          Commands.stopRecording(cameraRef.current);
+        }
+      } catch (error) {
+        logError('[TrustchexCamera] stopRecording error:', error);
+      }
+      resolve();
+    });
+  }, []);
+  const cancelRecording = useCallback(() => {
+    return new Promise(resolve => {
+      // Clear callbacks to prevent stale onRecordingFinished from firing
+      recordingCallbacksRef.current = {};
+      try {
+        if (cameraRef.current) {
+          Commands.cancelRecording(cameraRef.current);
+        }
+      } catch (error) {
+        logError('[TrustchexCamera] cancelRecording error:', error);
+      }
+      resolve();
+    });
+  }, []);
+  const deleteRecording = useCallback(filePath => {
+    try {
+      if (cameraRef.current) {
+        Commands.deleteRecording(cameraRef.current, filePath);
+      }
+    } catch (error) {
+      logError('[TrustchexCamera] deleteRecording error:', error);
+    }
+  }, []);
+  React.useImperativeHandle(ref, () => ({
+    setFocusPoint,
+    setExposureOffset,
+    startRecording,
+    stopRecording,
+    cancelRecording,
+    deleteRecording
+  }));
+  return /*#__PURE__*/_jsx(TrustchexCameraViewNative, {
+    ref: cameraRef,
+    ...props,
+    onRecordingFinished: handleRecordingFinished,
+    onRecordingError: handleRecordingError,
+    style: [styles.camera, props.style]
+  });
+});
+const styles = StyleSheet.create({
+  camera: {
+    flex: 1
+  }
+});

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

@@ -0,0 +1,91 @@
+"use strict";
+
+import { ASN1Constants } from "./asn1Constants.js";
+export class TLVHelpers extends ASN1Constants {
+  static isPrimitive(tag) {
+    let i = 3;
+    for (; i >= 0; i--) {
+      const mask = 0xff << 8 * i;
+      if ((tag & mask) !== 0x00) {
+        break;
+      }
+    }
+    const msByte = (tag & 0xff << 8 * i) >> 8 * i & 0xff;
+    return (msByte & 0x20) === 0x00;
+  }
+  static getTagLength(tag) {
+    return TLVHelpers.getTagAsBytes(tag).length;
+  }
+  static getLengthLength(length) {
+    return TLVHelpers.getLengthAsBytes(length).length;
+  }
+  static getTagAsBytes(tag) {
+    const out = [];
+    const byteCount = Math.floor(Math.log(tag) / Math.log(256)) + 1;
+    for (let i = 0; i < byteCount; i++) {
+      const pos = 8 * (byteCount - i - 1);
+      out.push((tag & 0xff << pos) >> pos);
+    }
+    const tagBytes = out;
+    switch (TLVHelpers.getTagClass(tag)) {
+      case TLVHelpers.APPLICATION_CLASS:
+        tagBytes[0] |= 0x40;
+        break;
+      case TLVHelpers.CONTEXT_SPECIFIC_CLASS:
+        tagBytes[0] |= 0x80;
+        break;
+      case TLVHelpers.PRIVATE_CLASS:
+        tagBytes[0] |= 0xc0;
+        break;
+      default:
+        break;
+    }
+    if (!TLVHelpers.isPrimitive(tag)) {
+      tagBytes[0] |= 0x20;
+    }
+    return tagBytes;
+  }
+  static getLengthAsBytes(length) {
+    const out = [];
+    if (length < 0x80) {
+      out.push(length);
+    } else {
+      const byteCount = TLVHelpers.log(length, 256);
+      out.push(0x80 | byteCount);
+      for (let i = 0; i < byteCount; i++) {
+        const pos = 8 * (byteCount - i - 1);
+        out.push((length & 0xff << pos) >> pos);
+      }
+    }
+    return out;
+  }
+  static getTagClass(tag) {
+    let i = 3;
+    for (; i >= 0; i--) {
+      const mask = 0xff << 8 * i;
+      if ((tag & mask) !== 0x00) {
+        break;
+      }
+    }
+    const msByte = (tag & 0xff << 8 * i) >> 8 * i & 0xff;
+    switch (msByte & 0xc0) {
+      case 0x00:
+        return TLVHelpers.UNIVERSAL_CLASS;
+      case 0x40:
+        return TLVHelpers.APPLICATION_CLASS;
+      case 0x80:
+        return TLVHelpers.CONTEXT_SPECIFIC_CLASS;
+      case 0xc0:
+      default:
+        return TLVHelpers.PRIVATE_CLASS;
+    }
+  }
+  static log(n, base) {
+    let result = 0;
+    while (n > 0) {
+      n = n / base;
+      result++;
+    }
+    return result;
+  }
+}

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

@@ -2,95 +2,11 @@
 
 import { ByteArrayInputStream } from "../java/byteArrayInputStream.js";
 import { ByteArrayOutputStream } from "../java/byteArrayOutputStream.js";
-import { ASN1Constants } from "./asn1Constants.js";
 import { TLVInputStream } from "./tlvInputStream.js";
 import { TLVOutputStream } from "./tlvOutputStream.js";
 import { Buffer } from 'buffer';
-class TLVUtil extends ASN1Constants {
-  static isPrimitive(tag) {
-    let i = 3;
-    for (; i >= 0; i--) {
-      const mask = 0xff << 8 * i;
-      if ((tag & mask) !== 0x00) {
-        break;
-      }
-    }
-    const msByte = (tag & 0xff << 8 * i) >> 8 * i & 0xff;
-    return (msByte & 0x20) === 0x00;
-  }
-  static getTagLength(tag) {
-    return TLVUtil.getTagAsBytes(tag).length;
-  }
-  static getLengthLength(length) {
-    return TLVUtil.getLengthAsBytes(length).length;
-  }
-
-  /**
-   * The tag bytes of this object.
-   *
-   * @param tag the tag
-   *
-   * @return the tag bytes of this object.
-   */
-  static getTagAsBytes(tag) {
-    const out = [];
-    const byteCount = Math.floor(Math.log(tag) / Math.log(256)) + 1;
-    for (let i = 0; i < byteCount; i++) {
-      const pos = 8 * (byteCount - i - 1);
-      out.push((tag & 0xff << pos) >> pos);
-    }
-    const tagBytes = out;
-    switch (TLVUtil.getTagClass(tag)) {
-      case TLVUtil.APPLICATION_CLASS:
-        tagBytes[0] |= 0x40;
-        break;
-      case TLVUtil.CONTEXT_SPECIFIC_CLASS:
-        tagBytes[0] |= 0x80;
-        break;
-      case TLVUtil.PRIVATE_CLASS:
-        tagBytes[0] |= 0xc0;
-        break;
-      default:
-        /* NOTE: Unsupported tag class. Now what? */
-        break;
-    }
-    if (!TLVUtil.isPrimitive(tag)) {
-      tagBytes[0] |= 0x20;
-    }
-    return tagBytes;
-  }
-
-  /**
-   * The length bytes of this object.
-   *
-   * @param length the length
-   *
-   * @return length of encoded value as bytes
-   */
-  static getLengthAsBytes(length) {
-    const out = [];
-    if (length < 0x80) {
-      /* short form */
-      out.push(length);
-    } else {
-      const byteCount = TLVUtil.log(length, 256);
-      out.push(0x80 | byteCount);
-      for (let i = 0; i < byteCount; i++) {
-        const pos = 8 * (byteCount - i - 1);
-        out.push((length & 0xff << pos) >> pos);
-      }
-    }
-    return out;
-  }
-
-  /**
-   * TLV encodes an encoded data object with a tag.
-   *
-   * @param tag the tag
-   * @param data the data to encode
-   *
-   * @return the TLV encoded data
-   */
+import { TLVHelpers } from "./tlv.helpers.js";
+class TLVUtil extends TLVHelpers {
   static wrapDO(tag, data) {
     if (data == null) {
       throw new Error('Data to wrap is null');
@@ -114,15 +30,6 @@ class TLVUtil extends ASN1Constants {
       }
     }
   }
-
-  /**
-   * TLV decodes tagged TLV data object.
-   *
-   * @param expectedTag the tag to expect, an {@code IllegalArgumentException} will be throws if a different tag is read
-   * @param wrappedData the encoded data
-   *
-   * @return the decoded data
-   */
   static async unwrapDO(expectedTag, wrappedData) {
     if (wrappedData == null || wrappedData.length < 2) {
       throw new Error('Wrapped data is null or length < 2');
@@ -153,34 +60,5 @@ class TLVUtil extends ASN1Constants {
       }
     }
   }
-  static getTagClass(tag) {
-    let i = 3;
-    for (; i >= 0; i--) {
-      const mask = 0xff << 8 * i;
-      if ((tag & mask) !== 0x00) {
-        break;
-      }
-    }
-    const msByte = (tag & 0xff << 8 * i) >> 8 * i & 0xff;
-    switch (msByte & 0xc0) {
-      case 0x00:
-        return TLVUtil.UNIVERSAL_CLASS;
-      case 0x40:
-        return TLVUtil.APPLICATION_CLASS;
-      case 0x80:
-        return TLVUtil.CONTEXT_SPECIFIC_CLASS;
-      case 0xc0:
-      default:
-        return TLVUtil.PRIVATE_CLASS;
-    }
-  }
-  static log(n, base) {
-    let result = 0;
-    while (n > 0) {
-      n = n / base;
-      result++;
-    }
-    return result;
-  }
 }
 export default TLVUtil;

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

@@ -3,7 +3,7 @@
 import { ByteArrayInputStream } from "../java/byteArrayInputStream.js";
 import { DataInputStream } from "../java/dataInputStream.js";
 import { InputStream } from "../java/inputStream.js";
-import TLVUtil from "./tlv.utils.js";
+import { TLVHelpers } from "./tlv.helpers.js";
 import { TLVInputState } from "./tlvInputState.js";
 export class TLVInputStream extends InputStream {
   static MAX_BUFFER_LENGTH = 65535;
@@ -117,11 +117,11 @@ export class TLVInputStream extends InputStream {
       let tag = -1;
       if (this.state.getIsAtStartOfTag()) {} else if (this.state.getIsAtStartOfLength()) {
         await this.readLength();
-        if (TLVUtil.isPrimitive(this.state.getTag())) {
+        if (TLVHelpers.isPrimitive(this.state.getTag())) {
           await this.skipValue();
         }
       } else {
-        if (TLVUtil.isPrimitive(this.state.getTag())) {
+        if (TLVHelpers.isPrimitive(this.state.getTag())) {
           await this.skipValue();
         }
       }
@@ -129,7 +129,7 @@ export class TLVInputStream extends InputStream {
       if (tag === searchTag) {
         return;
       }
-      if (TLVUtil.isPrimitive(tag)) {
+      if (TLVHelpers.isPrimitive(tag)) {
         const length = await this.readLength();
         const skippedBytes = await this.skipValue();
         if (skippedBytes >= length) {