@ha_tecno/live-id-sdk 2.5.1 → 2.7.0

package/src/screens/MultiFingerRegister/MultiFingerRegister.tsx

@@ -0,0 +1,207 @@
+import React, { useCallback, useEffect, useRef, useState } from "react";
+import { View, Modal, TouchableOpacity } from "react-native";
+import { Camera, Point, useCameraDevice, useCameraFormat, useCameraPermission } from "react-native-vision-camera";
+import Orientation from "react-native-orientation-locker";
+import { Gesture, GestureDetector, GestureHandlerRootView } from "react-native-gesture-handler";
+import { runOnJS } from "react-native-reanimated";
+import Picker, { PickerStyle } from "react-native-picker-select";
+
+import { CameraConfigInfo, CaptureButton, DeviceNotFound, Gabarito, ModalMessage } from "../../components";
+import { styles } from "./styles";
+import { useDispatch, useSelector } from "../../store/modules/fingerRegister";
+import Icon from "../../components/icon/icon";
+import { useIsForeground } from "../../utils";
+
+enum Finger {
+  LEFT_THUMB = "LT",
+  LEFT_INDEX = "LI",
+  LEFT_MIDDLE = "LM",
+  LEFT_RING = "LR",
+  LEFT_PINKY = "LP",
+  RIGHT_THUMB = "RT",
+  RIGHT_INDEX = "RI",
+  RIGHT_MIDDLE = "RM",
+  RIGHT_RING = "RR",
+  RIGHT_PINKY = "RP"
+}
+
+type Props = {
+  UID: string;
+  onSuccess: (code: number) => void;
+  isFocused?: boolean;
+  mock?: boolean;
+};
+
+const MultiFingerRegister = ({ UID, onSuccess, isFocused, mock }: Props) => {
+  const [showModal, setShowModal] = useState(false);
+  const cameraRef = useRef<Camera>(null);
+  const isForeground = useIsForeground();
+  const isActive = isFocused !== undefined ? isForeground && isFocused : isForeground;
+  const { hasPermission, requestPermission } = useCameraPermission();
+  const device = useCameraDevice("back");
+  const state = useSelector();
+  const dispatch = useDispatch();
+
+  const containerCaptureStyled = [styles.containerCapture, { bottom: state.showButtonInfo ? 75 : 20 }];
+  const pickerStyled: PickerStyle = {
+    chevronDown: { display: "none" },
+    chevronUp: { display: "none" },
+    inputIOS: {
+      fontSize: 16,
+      color: "#000",
+      textAlign: "center"
+    },
+    inputAndroid: {
+      fontSize: 14,
+      color: "#000",
+      textAlign: "center"
+    }
+  };
+
+  const itemsPicker = [
+    { label: "Indicador Direito", value: Finger.RIGHT_INDEX },
+    { label: "Médio Direito", value: Finger.RIGHT_MIDDLE },
+    { label: "Anelar Direito", value: Finger.RIGHT_RING },
+    { label: "Mínimo Direito", value: Finger.RIGHT_PINKY },
+    { label: "Polegar Direito", value: Finger.RIGHT_THUMB },
+    { label: "Indicador Esquerdo", value: Finger.LEFT_INDEX },
+    { label: "Médio Esquerdo", value: Finger.LEFT_MIDDLE },
+    { label: "Anelar Esquerdo", value: Finger.LEFT_RING },
+    { label: "Mínimo Esquerdo", value: Finger.LEFT_PINKY },
+    { label: "Polegar Esquerdo", value: Finger.LEFT_THUMB }
+  ];
+
+  useEffect(() => {
+    Orientation.lockToPortrait();
+    return () => {
+      Orientation.unlockAllOrientations();
+    };
+  });
+
+  const cameraPermission = useCallback(async () => {
+    if (!hasPermission) {
+      await requestPermission();
+    }
+  }, [hasPermission, requestPermission]);
+
+  useEffect(() => {
+    cameraPermission();
+    dispatch.getConfig("finger");
+  }, [cameraPermission, dispatch.getConfig]);
+
+  const cameraFormat = useCameraFormat(device, [
+    {
+      photoResolution: {
+        width: 1280,
+        height: 720
+      }
+    }
+  ]);
+
+  useEffect(() => {
+    if (state.base64Images !== undefined && state.base64Images.length === 3) {
+      if (!UID) {
+        dispatch.setModal("Ocorreu um erro!", "Erro: UID não encontrado!");
+      }
+      dispatch.handleLoading();
+      dispatch.sendImages(state.base64Images, UID, mock, state.currentFinger);
+    }
+  }, [dispatch.sendImages, dispatch.handleLoading, state.base64Images, state.base64Images.length, mock]);
+
+  useEffect(() => {
+    if (state.code === 0) {
+      dispatch.setModal("Sucesso!", "Cadastro de digital realizado com sucesso!");
+      onSuccess && onSuccess?.(state.code);
+      mock === true ? setTimeout(() => dispatch.handleLoading(), 2000) : dispatch.handleLoading();
+      dispatch.handleFinger();
+    }
+    if (state.code !== 0 && state.code !== null) {
+      dispatch.setModal("Ocorreu um erro!", `Erro: ${state.message}`);
+      dispatch.handleLoading();
+    }
+    dispatch.resetState();
+  }, [state.code, state.message, dispatch.handleLoading, dispatch.resetState, dispatch.setModal, onSuccess, mock]);
+
+  const takePhoto = async () => {
+    const photo = await cameraRef.current?.takePhoto({
+      qualityPrioritization: "balanced"
+    });
+    if (photo != null) {
+      dispatch.setImagePath(photo.path);
+    }
+  };
+
+  const focus = useCallback((point: Point) => {
+    const camera = cameraRef.current;
+    if (camera != null) {
+      camera.focus(point);
+    }
+  }, []);
+
+  const gesture = Gesture.Tap().onBegin(({ x, y }) => {
+    runOnJS(focus)({ x, y });
+  });
+
+  const openModal = () => {
+    setShowModal(true);
+  };
+
+  const closeModel = () => {
+    setShowModal(false);
+  };
+
+  const handleCurrentFinger = (value: string) => {
+    dispatch.setCurrentFinger(value as Finger);
+  };
+
+  if (device == null || hasPermission === false)
+    return <DeviceNotFound hasPermission={hasPermission} cameraPermission={cameraPermission} />;
+
+  return (
+    <GestureHandlerRootView style={styles.root}>
+      <GestureDetector gesture={gesture}>
+        <View style={styles.cameraContainer}>
+          <Camera
+            ref={cameraRef}
+            style={styles.camera}
+            device={device}
+            format={cameraFormat}
+            isActive={isActive}
+            torch={isActive ? "on" : "off"}
+            exposure={state.exposure}
+            zoom={state.zoom}
+            photo
+          />
+          <Gabarito />
+        </View>
+      </GestureDetector>
+      <View style={styles.containerModalIcon}>
+        <TouchableOpacity onPress={openModal}>
+          <Icon name="cog" size={35} color="#fff" />
+        </TouchableOpacity>
+      </View>
+      <View style={containerCaptureStyled}>
+        <CaptureButton onPress={takePhoto} imagesCount={state.base64Images.length} />
+      </View>
+      {state.showButtonInfo && <CameraConfigInfo exposure={state.exposure} zoom={state.zoom} />}
+      <ModalMessage isLoading={state.loading} modal={state.modal} />
+      <Modal animationType="slide" transparent={true} visible={showModal} onRequestClose={closeModel}>
+        <View style={styles.containerModal}>
+          <View style={styles.modal}>
+            <Picker
+              style={pickerStyled}
+              useNativeAndroidPickerStyle={false}
+              placeholder={{}}
+              onDonePress={closeModel}
+              items={itemsPicker}
+              value={state.currentFinger}
+              onValueChange={handleCurrentFinger}
+            />
+          </View>
+        </View>
+      </Modal>
+    </GestureHandlerRootView>
+  );
+};
+
+export default MultiFingerRegister;

package/src/screens/MultiFingerRegister/styles.ts

@@ -0,0 +1,49 @@
+import { StyleSheet, Dimensions, Platform } from "react-native";
+
+const { height } = Dimensions.get("window");
+
+export const styles = StyleSheet.create({
+  container: {
+    flex: 1
+  },
+  root: {
+    flex: 1
+  },
+  cameraContainer: {
+    flex: 1,
+    justifyContent: "center"
+  },
+  camera: {
+    flex: 1,
+    paddingBottom: height * 0.2
+  },
+  containerCapture: {
+    position: "absolute",
+    width: "100%",
+    alignItems: "center"
+  },
+  cameraConfigs: {
+    alignItems: "center"
+  },
+  containerModalIcon: {
+    position: "absolute",
+    top: 10,
+    right: 10,
+    zIndex: 9999
+  },
+  containerModal: { flex: 1, justifyContent: "flex-end", marginBottom: "15%" },
+  modal: {
+    margin: 20,
+    backgroundColor: "white",
+    borderRadius: 20,
+    padding: Platform.OS === "ios" ? 35 : 20,
+    shadowColor: "#000",
+    shadowOffset: {
+      width: 0,
+      height: 2
+    },
+    shadowOpacity: 0.25,
+    shadowRadius: 4,
+    elevation: 5
+  }
+});

package/src/screens/index.ts

@@ -1,5 +1,6 @@
 import FingerRegister from "./FingerRegister/FingerRegister";
 import LifeCertificate from "./LifeCertificate/LifeCertificate";
 import FingerAuth from "./FingerAuth/FingerAuth";
+import MultiFingerRegister from "./MultiFingerRegister/MultiFingerRegister";
 
-export { FingerRegister, LifeCertificate, FingerAuth };
+export { FingerRegister, LifeCertificate, FingerAuth, MultiFingerRegister };

package/src/services/services.ts

@@ -32,10 +32,10 @@ export const getConfigsApi = async (): Promise<GetConfigApiResponse> => {
 
 export const registerFingerImages = async ({
   UID,
-  images
+  images,
+  finger
 }: RegisterFingerImagesType): Promise<RegisterFingerResponse> => {
   try {
-    const finger = "DI";
     const { data } = await axiosInstance.post(
       "/enroll-images",
       { UID, finger, images },

package/src/services/types.ts

@@ -9,9 +9,23 @@ export type GetConfigApiResponse = {
   showButtonInfo: boolean;
 }[];
 
+export enum Finger {
+  LEFT_THUMB = "LT",
+  LEFT_INDEX = "LI",
+  LEFT_MIDDLE = "LM",
+  LEFT_RING = "LR",
+  LEFT_PINKY = "LP",
+  RIGHT_THUMB = "RT",
+  RIGHT_INDEX = "RI",
+  RIGHT_MIDDLE = "RM",
+  RIGHT_RING = "RR",
+  RIGHT_PINKY = "RP"
+}
+
 export type RegisterFingerImagesType = {
   UID: string;
   images: string[];
+  finger: Finger | undefined;
 };
 
 export type RegisterFingerResponse = {

package/src/store/modules/fingerAuth/slice.ts

@@ -50,9 +50,17 @@ const handleLoading = () => {
   }));
 };
 
-const sendImage = async (imagePath: string, UID: string) => {
+const sendImage = async (imagePath: string, UID: string, mock?: boolean) => {
   try {
     handleLoading();
+    if (mock === true) {
+      return slice.setState((state) => ({
+        state: {
+          ...state.state,
+          code: 0
+        }
+      }));
+    }
     const convertedImage = await readFile(imagePath, "base64");
     const response = await authFinger({ UID, image: convertedImage });
     slice.setState((state) => ({

package/src/store/modules/fingerAuth/type.ts

@@ -14,7 +14,7 @@ type State = {
 type Dispatch = {
   getConfig: (serviceType: "finger" | "liveness") => void;
   handleLoading: () => void;
-  sendImage: (imagePath: string, UID: string) => void;
+  sendImage: (imagePath: string, UID: string, mock?: boolean) => void;
   resetState: () => void;
   setModal: (title: string, message: string) => void;
 };

package/src/store/modules/fingerRegister/slice.ts

@@ -1,9 +1,22 @@
 import { create } from "zustand";
 import { readFile } from "react-native-fs";
 import { registerFingerImages } from "../../../services/services";
-import { FingerRegisterState, InitialState } from "./types";
+import { Finger, FingerRegisterState, InitialState } from "./types";
 import { getConfigCamera } from "../../../utils";
 
+const fingerOrder = [
+  Finger.RIGHT_INDEX,
+  Finger.RIGHT_MIDDLE,
+  Finger.RIGHT_RING,
+  Finger.RIGHT_PINKY,
+  Finger.RIGHT_THUMB,
+  Finger.LEFT_INDEX,
+  Finger.LEFT_MIDDLE,
+  Finger.LEFT_RING,
+  Finger.LEFT_PINKY,
+  Finger.LEFT_THUMB
+];
+
 const initialState: InitialState = {
   state: {
     exposure: 0,
@@ -16,7 +29,9 @@ const initialState: InitialState = {
     modal: {
       title: "",
       message: ""
-    }
+    },
+    currentFinger: fingerOrder[0] as Finger,
+    currentFingerIndex: 0
   }
 };
 
@@ -34,8 +49,21 @@ const setImagePath = async (imagePath: string) => {
   }
 };
 
-const sendImages = async (images: string[], UID: string) => {
-  const response = await registerFingerImages({ images, UID });
+const sendImages = async (images: string[], UID: string, mock?: boolean, finger?: Finger) => {
+  if (mock === true) {
+    return slice.setState((state) => ({
+      state: {
+        ...state.state,
+        code: 0
+      }
+    }));
+  }
+
+  const response = await registerFingerImages({
+    images,
+    UID,
+    finger: finger === undefined ? Finger.RIGHT_INDEX : finger
+  });
   slice.setState((state) => ({
     state: {
       ...state.state,
@@ -44,6 +72,27 @@ const sendImages = async (images: string[], UID: string) => {
   }));
 };
 
+const setCurrentFinger = (finger: Finger) => {
+  slice.setState((state) => ({
+    state: {
+      ...state.state,
+      currentFingerIndex: fingerOrder.indexOf(finger),
+      currentFinger: finger
+    }
+  }));
+};
+
+const handleFinger = () => {
+  const nextIndex = (slice.getState().state.currentFingerIndex + 1) % fingerOrder.length;
+  slice.setState((state) => ({
+    state: {
+      ...state.state,
+      currentFingerIndex: nextIndex,
+      currentFinger: fingerOrder[nextIndex] as Finger
+    }
+  }));
+};
+
 const handleLoading = () => {
   slice.setState((state) => ({
     state: {
@@ -94,7 +143,9 @@ const slice = create<FingerRegisterState>(() => ({
     setImagePath,
     sendImages,
     setModal,
-    resetState
+    resetState,
+    handleFinger,
+    setCurrentFinger
   }
 }));
 

package/src/store/modules/fingerRegister/types.ts

@@ -1,3 +1,16 @@
+export enum Finger {
+  LEFT_THUMB = "LT",
+  LEFT_INDEX = "LI",
+  LEFT_MIDDLE = "LM",
+  LEFT_RING = "LR",
+  LEFT_PINKY = "LP",
+  RIGHT_THUMB = "RT",
+  RIGHT_INDEX = "RI",
+  RIGHT_MIDDLE = "RM",
+  RIGHT_RING = "RR",
+  RIGHT_PINKY = "RP"
+}
+
 type State = {
   exposure: number;
   zoom: number;
@@ -10,14 +23,18 @@ type State = {
     title: string;
     message: string;
   };
+  currentFingerIndex: number;
+  currentFinger: Finger;
 };
 type Dispatch = {
   getConfig: (serviceType: "finger" | "liveness") => void;
   handleLoading: () => void;
   setImagePath: (imagePath: string) => void;
-  sendImages: (images: string[], UID: string) => void;
+  sendImages: (images: string[], UID: string, mock?: boolean, finger?: Finger) => void;
   setModal: (title: string, message: string) => void;
   resetState: () => void;
+  handleFinger: () => void;
+  setCurrentFinger: (finger: Finger) => void;
 };
 
 export type InitialState = {

package/src/store/modules/lifeCertificate/slice.ts

@@ -1,7 +1,7 @@
 import { create } from "zustand";
 import { InitialState, LifeCertificateState, SendLifeCertificateType } from "./types";
 import { lifeCertificate } from "../../../services";
-import { getConfigCamera } from "../../../utils";
+import { getConfigCamera, randomHeartRate } from "../../../utils";
 
 const initialState: InitialState = {
   state: {
@@ -38,7 +38,16 @@ const setIsRecording = (recoding: boolean) => {
   }));
 };
 
-const sendLifeCertificate = async ({ videoFile, UID, exposure }: SendLifeCertificateType) => {
+const sendLifeCertificate = async ({ videoFile, UID, exposure, mock }: SendLifeCertificateType) => {
+  if (mock === true) {
+    return slice.setState((state) => ({
+      state: {
+        ...state.state,
+        bpm: randomHeartRate(),
+        code: 0
+      }
+    }));
+  }
   const videoPath = videoFile.path;
   const response = await lifeCertificate({
     videoPath,

package/src/store/modules/lifeCertificate/types.ts

@@ -37,4 +37,5 @@ export type SendLifeCertificateType = {
   videoFile: VideoFile;
   UID: string;
   exposure: number;
+  mock?: boolean;
 };

package/src/utils/index.ts

@@ -1,4 +1,5 @@
 import getConfigCamera from "./getConfigCamera";
+import randomHeartRate from "./utils";
 import { useIsForeground } from "./hooks/useIsForeground";
 
-export { getConfigCamera, useIsForeground };
+export { getConfigCamera, useIsForeground, randomHeartRate };

package/src/utils/utils.ts

@@ -0,0 +1,5 @@
+const randomHeartRate = (): number => {
+  return Math.floor(Math.random() * (90 - 75 + 1) + 75);
+};
+
+export default randomHeartRate;

package/lib/commonjs/utils/file.js

@@ -1,38 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.validarBase64 = exports.encodeImageToBase64 = void 0;
-var _reactNativeFs = _interopRequireDefault(require("react-native-fs"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const encodeImageToBase64 = async imagePath => {
-  try {
-    const imageData = await _reactNativeFs.default.readFile(imagePath, "base64");
-    return imageData;
-  } catch (error) {
-    return null;
-  }
-};
-exports.encodeImageToBase64 = encodeImageToBase64;
-const validarBase64 = array => {
-  // Verifica se o argumento é um array e tem exatamente 3 elementos
-  if (!Array.isArray(array) || array.length !== 3) {
-    return false;
-  }
-
-  // Regex para validar base64
-  const base64Regex = /^[a-zA-Z0-9+/]*={0,2}$/;
-
-  // Verifica se cada elemento do array é uma string válida em base64
-  for (let i = 0; i < array.length; i++) {
-    if (typeof array[i] !== "string" || !base64Regex.test(array[i])) {
-      return false;
-    }
-  }
-
-  // Se chegou até aqui, o array é válido
-  return true;
-};
-exports.validarBase64 = validarBase64;
-//# sourceMappingURL=file.js.map

package/lib/commonjs/utils/file.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_reactNativeFs","_interopRequireDefault","require","obj","__esModule","default","encodeImageToBase64","imagePath","imageData","RNFS","readFile","error","exports","validarBase64","array","Array","isArray","length","base64Regex","i","test"],"sourceRoot":"../../../src","sources":["utils/file.ts"],"mappings":";;;;;;AAAA,IAAAA,cAAA,GAAAC,sBAAA,CAAAC,OAAA;AAAmC,SAAAD,uBAAAE,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAE5B,MAAMG,mBAAmB,GAAG,MAAOC,SAAiB,IAAK;EAC9D,IAAI;IACF,MAAMC,SAAS,GAAG,MAAMC,sBAAI,CAACC,QAAQ,CAACH,SAAS,EAAE,QAAQ,CAAC;IAC1D,OAAOC,SAAS;EAClB,CAAC,CAAC,OAAOG,KAAK,EAAE;IACd,OAAO,IAAI;EACb;AACF,CAAC;AAACC,OAAA,CAAAN,mBAAA,GAAAA,mBAAA;AAEK,MAAMO,aAAa,GAAIC,KAAqB,IAAK;EACtD;EACA,IAAI,CAACC,KAAK,CAACC,OAAO,CAACF,KAAK,CAAC,IAAIA,KAAK,CAACG,MAAM,KAAK,CAAC,EAAE;IAC/C,OAAO,KAAK;EACd;;EAEA;EACA,MAAMC,WAAW,GAAG,wBAAwB;;EAE5C;EACA,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGL,KAAK,CAACG,MAAM,EAAEE,CAAC,EAAE,EAAE;IACrC,IAAI,OAAOL,KAAK,CAACK,CAAC,CAAC,KAAK,QAAQ,IAAI,CAACD,WAAW,CAACE,IAAI,CAACN,KAAK,CAACK,CAAC,CAAC,CAAC,EAAE;MAC/D,OAAO,KAAK;IACd;EACF;;EAEA;EACA,OAAO,IAAI;AACb,CAAC;AAACP,OAAA,CAAAC,aAAA,GAAAA,aAAA"}

package/lib/module/utils/file.js

@@ -1,29 +0,0 @@
-import RNFS from "react-native-fs";
-export const encodeImageToBase64 = async imagePath => {
-  try {
-    const imageData = await RNFS.readFile(imagePath, "base64");
-    return imageData;
-  } catch (error) {
-    return null;
-  }
-};
-export const validarBase64 = array => {
-  // Verifica se o argumento é um array e tem exatamente 3 elementos
-  if (!Array.isArray(array) || array.length !== 3) {
-    return false;
-  }
-
-  // Regex para validar base64
-  const base64Regex = /^[a-zA-Z0-9+/]*={0,2}$/;
-
-  // Verifica se cada elemento do array é uma string válida em base64
-  for (let i = 0; i < array.length; i++) {
-    if (typeof array[i] !== "string" || !base64Regex.test(array[i])) {
-      return false;
-    }
-  }
-
-  // Se chegou até aqui, o array é válido
-  return true;
-};
-//# sourceMappingURL=file.js.map

package/lib/module/utils/file.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["RNFS","encodeImageToBase64","imagePath","imageData","readFile","error","validarBase64","array","Array","isArray","length","base64Regex","i","test"],"sourceRoot":"../../../src","sources":["utils/file.ts"],"mappings":"AAAA,OAAOA,IAAI,MAAM,iBAAiB;AAElC,OAAO,MAAMC,mBAAmB,GAAG,MAAOC,SAAiB,IAAK;EAC9D,IAAI;IACF,MAAMC,SAAS,GAAG,MAAMH,IAAI,CAACI,QAAQ,CAACF,SAAS,EAAE,QAAQ,CAAC;IAC1D,OAAOC,SAAS;EAClB,CAAC,CAAC,OAAOE,KAAK,EAAE;IACd,OAAO,IAAI;EACb;AACF,CAAC;AAED,OAAO,MAAMC,aAAa,GAAIC,KAAqB,IAAK;EACtD;EACA,IAAI,CAACC,KAAK,CAACC,OAAO,CAACF,KAAK,CAAC,IAAIA,KAAK,CAACG,MAAM,KAAK,CAAC,EAAE;IAC/C,OAAO,KAAK;EACd;;EAEA;EACA,MAAMC,WAAW,GAAG,wBAAwB;;EAE5C;EACA,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGL,KAAK,CAACG,MAAM,EAAEE,CAAC,EAAE,EAAE;IACrC,IAAI,OAAOL,KAAK,CAACK,CAAC,CAAC,KAAK,QAAQ,IAAI,CAACD,WAAW,CAACE,IAAI,CAACN,KAAK,CAACK,CAAC,CAAC,CAAC,EAAE;MAC/D,OAAO,KAAK;IACd;EACF;;EAEA;EACA,OAAO,IAAI;AACb,CAAC"}

package/lib/typescript/src/utils/file.d.ts

@@ -1,3 +0,0 @@
-export declare const encodeImageToBase64: (imagePath: string) => Promise<string | null>;
-export declare const validarBase64: (array: string | any[]) => boolean;
-//# sourceMappingURL=file.d.ts.map

package/lib/typescript/src/utils/file.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../../../src/utils/file.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB,cAAqB,MAAM,2BAO1D,CAAC;AAEF,eAAO,MAAM,aAAa,UAAW,MAAM,GAAG,GAAG,EAAE,YAkBlD,CAAC"}

package/src/utils/file.ts

@@ -1,30 +0,0 @@
-import RNFS from "react-native-fs";
-
-export const encodeImageToBase64 = async (imagePath: string) => {
-  try {
-    const imageData = await RNFS.readFile(imagePath, "base64");
-    return imageData;
-  } catch (error) {
-    return null;
-  }
-};
-
-export const validarBase64 = (array: string | any[]) => {
-  // Verifica se o argumento é um array e tem exatamente 3 elementos
-  if (!Array.isArray(array) || array.length !== 3) {
-    return false;
-  }
-
-  // Regex para validar base64
-  const base64Regex = /^[a-zA-Z0-9+/]*={0,2}$/;
-
-  // Verifica se cada elemento do array é uma string válida em base64
-  for (let i = 0; i < array.length; i++) {
-    if (typeof array[i] !== "string" || !base64Regex.test(array[i])) {
-      return false;
-    }
-  }
-
-  // Se chegou até aqui, o array é válido
-  return true;
-};