npm-pkg-hook 1.0.9 → 1.1.2

package/src/hooks/useDropzone/index.js

@@ -0,0 +1,79 @@
+export const useDropzone = (
+    onDrop,
+    draggingStyle = { border: 'dashed grey 3px' },
+    dragOverStyle = {
+      border: 'dashed grey 3px'
+    }
+  ) => {
+    const ref = useRef(null)
+    const [cleanup, setCleanup] = useState(false)
+    const [isDragging, setDragging] = useState(false)
+    const [dragOver, setDragOver] = useState(false)
+    const handle = useMemo(dragHandler, [])
+  
+    const eventListeners = {
+      dragenter: e => {return handle.dragEnter(e, () => {
+        if (!dragOver) setDragOver(true)
+      })},
+      dragleave: e => {return handle.dragLeave(e, () => {
+        setDragOver(false)
+      })},
+      dragover: handle.dragBegin,
+      drop: e => {return handle.drop(e, files => {
+        if (typeof onDrop === 'function') onDrop(files, e)
+        setDragOver(false)
+        setDragging(false)
+      })}
+    }
+  
+    const windowListeners = {
+      dragenter: e => {return handle.body.dragEnter(e, () => {
+        if (!isDragging) setDragging(true)
+      })},
+      dragleave: e => {return handle.body.dragLeave(e, () => {
+        // eslint-disable-next-line
+              if (isDragging) setDragging(false)
+      })},
+      dragend: () => {
+        // eslint-disable-next-line
+          },
+      drop: e => {return handle.body.drop(e, () => {
+        setDragging(false)
+        setDragOver(false)
+      })}
+    }
+  
+    useEffect(() => {
+      if (ref.current) {
+        const { current } = ref
+        Object.keys(eventListeners).forEach(key => {return current.addEventListener(key, eventListeners[key])}
+        )
+        Object.keys(windowListeners).forEach(key => {return window.addEventListener(key, windowListeners[key])}
+        )
+        setCleanup(true)
+      }
+  
+      return () => {
+        if (cleanup) {
+          const { current } = ref
+          if (current) {
+            Object.keys(eventListeners).forEach(key => {return current.removeEventListener(key, eventListeners[key])}
+            )
+          }
+          Object.keys(windowListeners).forEach(key => {return window.removeEventListener(key, windowListeners[key])}
+          )
+        }
+      }
+    }, [ref, windowListeners, cleanup, eventListeners, isDragging, dragOver])
+  
+    const dropProps = {
+      ref,
+      style:
+        isDragging || dragOver
+          ? dragOver
+            ? dragOverStyle
+            : draggingStyle
+          : undefined
+    }
+    return { isDragging, dragOver, dropProps }
+  }

package/src/hooks/useDynamicAuth/index.js

@@ -0,0 +1,13 @@
+import { useQuery } from '@apollo/client'
+import { useState } from 'react'
+import { GET_ONE_DYNAMIC_PASS } from './queries'
+
+export const useDynamicAuth = () => {
+  const [dynamicPass, setDynamicPass] = useState({})
+  const { loading, error } = useQuery(GET_ONE_DYNAMIC_PASS, {
+    onCompleted: (res) => {
+      setDynamicPass(res.getAOneDynamicPassword)
+    }
+  })
+  return [dynamicPass, { loading, error }]
+}

package/src/hooks/useDynamicAuth/queries.js

@@ -0,0 +1,24 @@
+import { gql } from '@apollo/client'
+
+export const CREATE_ONE_DYNAMIC_PASS = gql`
+mutation registerDynamicPassword($input: IDynamicPassword) {
+  registerDynamicPassword(input: $input) {
+    success
+    message
+  }
+}
+`
+export const GET_ONE_DYNAMIC_PASS = gql`
+query getAOneDynamicPassword {
+  getAOneDynamicPassword {
+    dPassId
+    id
+    idStore
+    keyPassDynamic
+    deviceName
+    dState
+    DatCre
+    DatMod
+  }
+}
+`

package/src/hooks/useEmployee/index.js

@@ -1,13 +1,16 @@
 import { useQuery } from '@apollo/client'
-import { useEffect, useState } from 'react'
 import { GET_EMPLOYEES } from './queries'
 
 export const useEmployee = () => {
-  const [clientes, setClients] = useState([])
-  const [more, setMore] = useState(100)
-  const { data, loading, error, fetchMore } = useQuery(GET_EMPLOYEES)
-  useEffect(() => {
-    setClients(data)
-  }, [clientes, data])
-  return [clientes?.employees, { loading, error, fetchMore, setMore, more }]
+  const { data, loading, error, fetchMore } = useQuery(GET_EMPLOYEES, {
+    onError: (error) => {
+      console.error(error)
+    }
+  })
+  const employees = data?.employees || []
+  return [employees, { 
+    loading, 
+    error,
+    fetchMore
+  }]
 }

package/src/hooks/useFingerprintjs/index.js

@@ -0,0 +1,176 @@
+import md5 from 'md5'
+
+async function getCPUInfo() {
+    if (navigator.hardwareConcurrency) {
+        try {
+            const logicalCores = navigator.hardwareConcurrency;
+            const agent = window.navigator.userAgent;
+            const hyperThreaded = /Intel|Apple/.test(agent) && /Win64|Linux x86_64|MacIntel/.test(agent);
+
+            // Ajustar el número de núcleos lógicos si se sospecha hiperprocesamiento
+            const physicalCores = hyperThreaded ? logicalCores / 2 : logicalCores;
+
+            const cpuInfo = {
+                logicalCores: logicalCores,
+                physicalCores: physicalCores,
+                hyperThreaded: hyperThreaded
+            };
+            return JSON.stringify(cpuInfo);
+        } catch (error) {
+            console.error('Error al obtener información de la CPU:', error);
+            return 'cpu-info-error';
+        }
+    } else {
+        return 'cpu-info-not-available';
+    }
+}
+
+async function generateFingerprint() {
+    const canvas = document.createElement('canvas');
+    const context = canvas.getContext('2d');
+    const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+
+    const userAgent = navigator.userAgent;
+    const language = navigator.language;
+    const colorDepth = window.screen.colorDepth;
+    const availableScreenHeight = window.screen.availHeight;
+    const platform = navigator.platform;
+    const cpuClass = navigator.cpuClass || 'unknown';
+
+    const canvasFingerprint = await generateCanvasFingerprint(canvas);
+    const audioFingerprint = await generateAudioFingerprint(audioContext);
+
+    const cpuInfo = await getCPUInfo();
+    const webGLInfo = await getWebGLInfo();
+    const fonts = getInstalledFonts();
+    const touchscreenInfo = getTouchscreenInfo();
+
+    const fingerprintData = {
+        browser: {
+            userAgent,
+            language,
+            colorDepth,
+            availableScreenHeight,
+            plugins: Array.from(navigator.plugins).map(plugin => plugin.name).join(','),
+            timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            hardwareConcurrency: cpuInfo.logicalCores || 'unknown',
+            platformVersion: navigator.platformVersion || 'unknown',
+        },
+        device: {
+            platform,
+            cpuClass,
+        },
+        canvas: canvasFingerprint,
+        audio: audioFingerprint,
+        cpu: cpuInfo,
+        webgl: webGLInfo,
+        fonts,
+        touchscreen: touchscreenInfo,
+    };
+
+    const fingerprint = JSON.stringify(fingerprintData);
+    const uniqueID = md5(fingerprint);
+
+    return uniqueID;
+}
+
+// Función para generar huella digital del audio
+async function generateAudioFingerprint(audioContext) {
+    if (audioContext) {
+        try {
+            await audioContext.resume();
+
+            // Obtén propiedades del audio que puedas obtener en modo incógnito
+            const audioProperties = {
+                isAudioContextAvailable: true,
+                // Agrega más propiedades relevantes aquí
+            };
+
+            return audioProperties;
+        } catch (error) {
+            console.error('Error al generar huella digital de audio:', error);
+        }
+    }
+
+    return { isAudioContextAvailable: false };
+}
+
+// Función para generar huella digital del canvas
+async function generateCanvasFingerprint(canvas) {
+    if (canvas) {
+        try {
+            canvas.width = 200;
+            canvas.height = 200;
+            const context = canvas.getContext('2d');
+            context.clearRect(0, 0, canvas.width, canvas.height);
+            context.fillStyle = '#f60';
+            context.fillRect(125, 1, 62, 20);
+            context.fillStyle = '#069';
+            context.font = '16pt Arial';
+            context.fillText('Cwm fjordbank glyphs vext quiz', 125, 20);
+
+            // Obtén más propiedades del canvas que puedas obtener en modo incógnito
+            const canvasProperties = {
+                width: canvas.width,
+                height: canvas.height,
+                // Agrega más propiedades relevantes aquí
+            };
+
+            return canvasProperties;
+        } catch (error) {
+            console.error('Error al generar huella digital del canvas:', error);
+        }
+    }
+
+    return { width: 0, height: 0 };
+}
+
+
+
+async function getWebGLInfo() {
+    if ('WebGLRenderingContext' in window) {
+        const canvas = document.createElement('canvas');
+        const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
+
+        if (gl) {
+            const renderer = gl.getParameter(gl.RENDERER);
+            const version = gl.getParameter(gl.VERSION);
+
+            // Obtener más información sobre las capacidades WebGL si es necesario
+
+            return `${renderer}-${version}`;
+        }
+    }
+
+    return 'webgl-info-not-supported';
+}
+
+function getInstalledFonts() {
+    const fonts = [];
+
+    if ('fonts' in document) {
+        document.fonts.forEach(font => {
+            fonts.push(font.family);
+        });
+    }
+
+    return fonts.join(',');
+}
+
+function getTouchscreenInfo() {
+    if ('maxTouchPoints' in navigator) {
+        const maxTouchPoints = navigator.maxTouchPoints;
+        const touchEvent = 'ontouchstart' in window ? 'true' : 'false';
+
+        return `${maxTouchPoints}-${touchEvent}`;
+    }
+
+    return 'touchscreen-info-not-supported';
+}
+
+
+export async function fingerprintJs() {
+    const fingerprint = await generateFingerprint();
+    const uniqueID = md5(fingerprint)
+    return uniqueID;
+}

package/src/hooks/useFormTools/index.js

@@ -75,7 +75,7 @@ export const useFormTools = ({ sendNotification = () => { } } = {}) => {
 
     // Ejecuta la accion si es válido
     if (!errSub && action) {
-      action().then(res => {
+      action()?.then(res => {
         if (res) {
           sendNotification({
             message: msgSuccess || 'Operación exitosa',

package/src/hooks/useFullScreenMode/index.js

@@ -1,7 +1,10 @@
-import React, { useState, useRef, useEffect } from 'react'
-import styled from 'styled-components'
+import React, { 
+  useState, 
+  useRef, 
+  useEffect
+} from 'react'
 
-const useFullscreenMode = () => {
+export const useFullScreenMode = () => {
   const [isFullscreen, setFullscreen] = useState(false)
   const elementRef = useRef()
 
@@ -56,11 +59,7 @@ const useFullscreenMode = () => {
   }
 
   const ToggleIcon = (
-    <Button onDoubleClick={() => {return (!isFullscreen ? goFullscreen() : exitFullScreen())}}>{!isFullscreen ? 'FullScreen' : 'Normal'}</Button>
+    <button onDoubleClick={() => {return (!isFullscreen ? goFullscreen() : exitFullScreen())}}>{!isFullscreen ? 'FullScreen' : 'Normal'}</button>
   )
   return [elementRef, ToggleIcon] //Icon, ref
-}
-const Button = styled.button`
-
-`
-export default useFullscreenMode
+}

package/src/hooks/useGenerateNumberArray/index.js

@@ -0,0 +1,17 @@
+const addButtonValues = (values, max) => {
+    const value1 = values.splice(Math.floor(Math.random() * (max - 0)) + 0, 1)
+    return { max: max - 2, values: [value1] }
+}
+
+export const useGenerateNumberArray = () => {
+    const values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    let max = 9
+    const buttons = Array.from(Array(10)).map(() => {
+        return Array.from(Array(1)).map(() => {
+            const buttonValues = addButtonValues(values, max)
+            max = buttonValues.max
+            return buttonValues.values
+        })
+    })
+    return buttons
+}