npm-pkg-hook 1.12.4 → 1.12.8

package/src/hooks/useGetMinPrice/{index.js → index.ts}

@@ -1,4 +1,5 @@
-import { useQuery } from '@apollo/client'
+import { useQuery } from '@apollo/client'
+
 import { GET_MIN_PEDIDO } from './queries'
 
 export const useGetMinPrice = ({ idStore = '' } = {}) => {

package/src/hooks/useGetOneStoreRating/{index.js → index.ts}

@@ -1,5 +1,6 @@
-import { useState } from 'react'
 import { useLazyQuery } from '@apollo/client'
+import { useState } from 'react'
+
 import { GET_ONE_RATING_STORE } from './queries'
 
 export const useGetOneStoreRating = () => {

package/src/hooks/useGetStoreCookie/{index.js → index.ts}

@@ -1,5 +1,5 @@
-import { useState, useEffect } from 'react'
 import Cookies from 'js-cookie'
+import { useState, useEffect } from 'react'
 
 export const useGetStoreCookie = () => {
   const [vpStoreCookie, setVpStoreCookie] = useState(null)

package/src/hooks/useGoogleLogin/{index.js → index.ts}

@@ -1,4 +1,5 @@
-import { useState, useEffect } from 'react'
+import { useState, useEffect } from 'react'
+
 import loadScript from './loadScript'
 import removeScript from './removeScript'
 
@@ -26,6 +27,10 @@ export const useGoogleLogin = ({
 }) => {
   const [loaded, setLoaded] = useState(false)
 
+  /**
+   *
+   * @param res
+   */
   function handleSigninSuccess (res) {
     /*
       offer renamed response keys to names that match use
@@ -47,6 +52,10 @@ export const useGoogleLogin = ({
     onSuccess(res)
   }
 
+  /**
+   *
+   * @param e
+   */
   function signIn (e) {
     if (e) {
       e.preventDefault() // to prevent submit if used within form
@@ -59,13 +68,13 @@ export const useGoogleLogin = ({
       onRequest()
       if (responseType === 'code') {
         GoogleAuth.grantOfflineAccess(options).then(
-          res => onSuccess(res),
-          err => onFailure(err)
+          res => {return onSuccess(res)},
+          err => {return onFailure(err)}
         )
       } else {
         GoogleAuth.signIn(options).then(
-          res => handleSigninSuccess(res),
-          err => onFailure(err)
+          res => {return handleSigninSuccess(res)},
+          err => {return onFailure(err)}
         )
       }
     }

package/src/hooks/useHover/{index.js → index.ts}

@@ -1,5 +1,8 @@
 import { useRef, useState, useEffect } from 'react'
 
+/**
+ *
+ */
 export function useHover () {
   const [value, setValue] = useState(false)
 

package/src/hooks/useImageOptimization/{index.js → index.ts}

@@ -3,6 +3,10 @@ import { useEffect, useState } from 'react'
 // const imageUrl = 'https://example.com/image.jpg';
 // const optimizedUrl = useImageOptimization(imageUrl);
 
+/**
+ *
+ * @param imageUrl
+ */
 export function useImageOptimization (imageUrl) {
   const [optimizedUrl, setOptimizedUrl] = useState(null)
 

package/src/hooks/useImageUploaderProduct/helper/canvasUtils.ts

@@ -1,18 +1,25 @@
 export const createImage = (url) =>
-  new Promise((resolve, reject) => {
-    const image = new Image()
-    image.addEventListener('load', () => resolve(image))
-    image.addEventListener('error', (error) => reject(error))
-    image.setAttribute('crossOrigin', 'anonymous') // needed to avoid cross-origin issues on CodeSandbox
-    image.src = url
-  })
-
+{return new Promise((resolve, reject) => {
+  const image = new Image()
+  image.addEventListener('load', () => {return resolve(image)})
+  image.addEventListener('error', (error) => {return reject(error)})
+  image.setAttribute('crossOrigin', 'anonymous') // needed to avoid cross-origin issues on CodeSandbox
+  image.src = url
+})}
+
+/**
+ *
+ * @param degreeValue
+ */
 export function getRadianAngle(degreeValue) {
   return (degreeValue * Math.PI) / 180
 }
 
 /**
  * Returns the new bounding area of a rotated rectangle.
+ * @param width
+ * @param height
+ * @param rotation
  */
 export function rotateSize(width, height, rotation) {
   const rotRad = getRadianAngle(rotation)
@@ -21,7 +28,7 @@ export function rotateSize(width, height, rotation) {
     width:
       Math.abs(Math.cos(rotRad) * width) + Math.abs(Math.sin(rotRad) * height),
     height:
-      Math.abs(Math.sin(rotRad) * width) + Math.abs(Math.cos(rotRad) * height),
+      Math.abs(Math.sin(rotRad) * width) + Math.abs(Math.cos(rotRad) * height)
   }
 }
 
@@ -30,6 +37,10 @@ export function rotateSize(width, height, rotation) {
  */
 /**
  * This function was adapted from the one in the ReadMe of https://github.com/DominicTobias/react-image-crop
+ * @param imageSrc
+ * @param pixelCrop
+ * @param rotation
+ * @param flip
  */
 export async function getCroppedImg(
   imageSrc,
@@ -103,6 +114,11 @@ export async function getCroppedImg(
   })
 }
 
+/**
+ *
+ * @param imageSrc
+ * @param rotation
+ */
 export async function getRotatedImage(imageSrc, rotation = 0) {
   const image = await createImage(imageSrc)
   const canvas = document.createElement('canvas')

package/src/hooks/useImageUploaderProduct/helper/getOrientation.ts

@@ -1,6 +1,7 @@
 /**
  * Reads EXIF orientation from a JPEG file (native, no dependencies)
  * @param {File} file
+ * @param validTypes
  * @returns {Promise<number>} Orientation value from 1 to 8
  */
 export const getOrientation = (file: File, validTypes: string[]): Promise<number> => {
@@ -9,9 +10,9 @@ export const getOrientation = (file: File, validTypes: string[]): Promise<number
     reader.onload = (event) => {
       const view = new DataView(event.target?.result as ArrayBuffer)
 
-    if (!validTypes.includes(file.type)) {
-      return reject(new Error(`Archivo no soportado: ${file.type}`))
-    }
+      if (!validTypes.includes(file.type)) {
+        return reject(new Error(`Archivo no soportado: ${file.type}`))
+      }
 
       let offset = 2
       const length = view.byteLength
@@ -47,7 +48,7 @@ export const getOrientation = (file: File, validTypes: string[]): Promise<number
       resolve(1) // por defecto
     }
 
-    reader.onerror = () => reject(new Error('Error leyendo archivo'))
+    reader.onerror = () => {return reject(new Error('Error leyendo archivo'))}
     reader.readAsArrayBuffer(file)
   })
 }

package/src/hooks/useImageUploaderProduct/index.ts

@@ -1,14 +1,19 @@
-import { useRef, useState } from 'react'
+import { useRef, useState } from 'react'
+
 import { ORIENTATION_TO_ANGLE } from './helper'
 import { getCroppedImg, getRotatedImage } from './helper/canvasUtils'
 import { getOrientation } from './helper/getOrientation'
 
+/**
+ *
+ * @param file
+ */
 function readFile(file: File): Promise<string> {
-    return new Promise((resolve) => {
-        const reader = new FileReader()
-        reader.addEventListener('load', () => resolve(reader.result as string), false)
-        reader.readAsDataURL(file)
-    })
+  return new Promise((resolve) => {
+    const reader = new FileReader()
+    reader.addEventListener('load', () => {return resolve(reader.result as string)}, false)
+    reader.readAsDataURL(file)
+  })
 }
 
 export type SendNotificationFn = (params: {
@@ -56,237 +61,235 @@ interface UseImageUploaderResult {
  * @returns {UseImageUploaderResult}
  */
 export const useImageUploaderProduct = (
-    options?: UseImageUploaderOptions
+  options?: UseImageUploaderOptions
 ): UseImageUploaderResult => {
-    const {
-        validTypes = ['image/jpeg', 'image/jpg', 'image/png'],
-        maxSizeMB = 20,
-        minWidth = 300,
-        minHeight = 275,
-        sendNotification
-    } = options ?? {
-
+  const {
+    validTypes = ['image/jpeg', 'image/jpg', 'image/png'],
+    maxSizeMB = 20,
+    minWidth = 300,
+    minHeight = 275,
+    sendNotification
+  } = options ?? {
+
+  }
+  const readableFormats = validTypes
+    .map((type) => {return type.split('/')[1].toUpperCase()})
+
+  const formatter = new Intl.ListFormat('es', {
+    style: 'long',
+    type: 'conjunction'
+  })
+
+  const formattedList = formatter.format(readableFormats)
+
+  const [loading, setLoading] = useState(false)
+  const inputRef = useRef<HTMLInputElement>(null)
+  const [open, setOpen] = useState(false)
+  const [preview, setPreview] = useState<string | null>(null)
+  const [imageSrc, setImageSrc] = useState<string | null>(null)
+  const [croppedImage, setCroppedImage] = useState<string | null>(null)
+  const [crop, setCrop] = useState({ x: 0, y: 0 })
+  const [zoom, setZoom] = useState(1)
+  const [rotation, setRotation] = useState(0)
+  const [croppedAreaPixels, setCroppedAreaPixels] = useState(null)
+  const [error, setError] = useState('')
+  const [image, setImage] = useState<File | null>(null)
+
+
+  const onCropComplete = (_: any, croppedPixels: any) => {
+    setCroppedAreaPixels(croppedPixels)
+  }
+
+  const showCroppedImage = async () => {
+    if (!imageSrc || !croppedAreaPixels) return
+    try {
+      setLoading(true)
+      const base64Image = await getCroppedImg(imageSrc, croppedAreaPixels, rotation) as string
+
+      setCroppedImage(base64Image)
+      setPreview(base64Image)
+
+      // ✅ Convert base64 to blob and file
+      const blob = await (await fetch(base64Image)).blob()
+      const file = new File([blob], image?.name ?? 'cropped.jpeg', { type: blob.type })
+      setImage(file)
+      setLoading(false)
+    } catch (e) {
+      setLoading(false)
+      return sendNotification({
+        description: e ?? 'Ocurrió un error',
+        title: 'Error',
+        backgroundColor: 'error'
+      })
     }
-    const readableFormats = validTypes
-        .map((type) => type.split('/')[1].toUpperCase())
-
-    const formatter = new Intl.ListFormat('es', {
-        style: 'long',
-        type: 'conjunction'
-    })
-
-    const formattedList = formatter.format(readableFormats)
-
-    const [loading, setLoading] = useState(false)
-    const inputRef = useRef<HTMLInputElement>(null)
-    const [open, setOpen] = useState(false)
-    const [preview, setPreview] = useState<string | null>(null)
-    const [imageSrc, setImageSrc] = useState<string | null>(null)
-    const [croppedImage, setCroppedImage] = useState<string | null>(null)
-    const [crop, setCrop] = useState({ x: 0, y: 0 })
-    const [zoom, setZoom] = useState(1)
-    const [rotation, setRotation] = useState(0)
-    const [croppedAreaPixels, setCroppedAreaPixels] = useState(null)
-    const [error, setError] = useState('')
-    const [image, setImage] = useState<File | null>(null)
-
-
-    const onCropComplete = (_: any, croppedPixels: any) => {
-        setCroppedAreaPixels(croppedPixels)
+  }
+
+  /**
+   * Removes the selected image and resets relevant states
+   */
+  const handleRemoveImage = () => {
+    setImage(null)
+    setPreview(null)
+    setImageSrc(null)
+    setCroppedImage(null)
+    setZoom(1)
+    setCrop({ x: 0, y: 0 })
+    setRotation(0)
+    setError('')
+    if (inputRef.current) inputRef.current.value = ''
+  }
+
+  const onFileChange = async (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0]
+    handleRemoveImage()
+    if (!file) return
+
+    if (!validTypes.includes(file.type)) {
+
+
+      const error = `Formato inválido. Solo se permiten: ${formattedList}.`
+      sendNotification({
+        description: error,
+        title: 'Error',
+        backgroundColor: 'error'
+      })
+      return setError(error)
     }
 
-    const showCroppedImage = async () => {
-        if (!imageSrc || !croppedAreaPixels) return
-        try {
-            setLoading(true)
-            const base64Image = await getCroppedImg(imageSrc, croppedAreaPixels, rotation) as string
-
-            setCroppedImage(base64Image)
-            setPreview(base64Image)
-
-            // ✅ Convert base64 to blob and file
-            const blob = await (await fetch(base64Image)).blob()
-            const file = new File([blob], image?.name ?? 'cropped.jpeg', { type: blob.type })
-            setImage(file)
-            setLoading(false)
-        } catch (e) {
-            setLoading(false)
-            return sendNotification({
-                description: e ?? 'Ocurrió un error',
-                title: 'Error',
-                backgroundColor: 'error'
-            })
-        }
+    if (file.size > maxSizeMB * 1024 * 1024) {
+      const error = `El archivo supera los ${maxSizeMB} MB.`
+      sendNotification({
+        description: error,
+        title: 'Error',
+        backgroundColor: 'error'
+      })
+      return setError(`El archivo supera los ${maxSizeMB} MB.`)
     }
 
-    /**
-* Removes the selected image and resets relevant states
-*/
-    const handleRemoveImage = () => {
-        setImage(null)
-        setPreview(null)
-        setImageSrc(null)
-        setCroppedImage(null)
-        setZoom(1)
-        setCrop({ x: 0, y: 0 })
-        setRotation(0)
-        setError('')
-        if (inputRef.current) inputRef.current.value = ''
+    let imageDataUrl = await readFile(file)
+
+    try {
+      const orientation = await getOrientation(file, validTypes)
+      const rotation = ORIENTATION_TO_ANGLE[orientation]
+      if (rotation) {
+        imageDataUrl = await getRotatedImage(imageDataUrl, rotation) as string
+        setRotation(rotation)
+      }
+    } catch (e) {
+      return sendNotification({
+        description: 'Error desconocido',
+        title: 'Error',
+        backgroundColor: 'error'
+      })
     }
 
-    const onFileChange = async (e: React.ChangeEvent<HTMLInputElement>) => {
-        const file = e.target.files?.[0]
-        handleRemoveImage()
-        if (!file) return
-
-        if (!validTypes.includes(file.type)) {
-
-
-            const error = `Formato inválido. Solo se permiten: ${formattedList}.`
-            sendNotification({
-                description: error,
-                title: 'Error',
-                backgroundColor: 'error'
-            })
-            return setError(error)
-        }
-
-        if (file.size > maxSizeMB * 1024 * 1024) {
-            const error = `El archivo supera los ${maxSizeMB} MB.`
-            sendNotification({
-                description: error,
-                title: 'Error',
-                backgroundColor: 'error'
-            })
-            return setError(`El archivo supera los ${maxSizeMB} MB.`)
-        }
-
-        let imageDataUrl = await readFile(file)
-
-        try {
-            const orientation = await getOrientation(file, validTypes)
-            const rotation = ORIENTATION_TO_ANGLE[orientation]
-            if (rotation) {
-                imageDataUrl = await getRotatedImage(imageDataUrl, rotation) as string
-                setRotation(rotation)
-            }
-        } catch (e) {
-            return sendNotification({
-                description: 'Error desconocido',
-                title: 'Error',
-                backgroundColor: 'error'
-            })
-        }
-
-        const image = new Image()
-        image.src = imageDataUrl
-        image.onload = () => {
-            if (image.width < minWidth || image.height < minHeight) {
-                const error = `Resolución mínima: ${minWidth}x${minHeight}px.`
-                sendNotification({
-                    description: error,
-                    title: 'Error',
-                    backgroundColor: 'error'
-                })
-                setError(error)
-                return
-            }
-            setImageSrc(imageDataUrl)
-            setOpen(true)
-        }
+    const image = new Image()
+    image.src = imageDataUrl
+    image.onload = () => {
+      if (image.width < minWidth || image.height < minHeight) {
+        const error = `Resolución mínima: ${minWidth}x${minHeight}px.`
+        sendNotification({
+          description: error,
+          title: 'Error',
+          backgroundColor: 'error'
+        })
+        setError(error)
+        return
+      }
+      setImageSrc(imageDataUrl)
+      setOpen(true)
     }
-
-    const handleClose = () => {
-        setOpen(!open)
+  }
+
+  const handleClose = () => {
+    setOpen(!open)
+  }
+
+  const handleDrop = async (event: React.DragEvent<HTMLDivElement>): Promise<void> => {
+    event.preventDefault()
+    handleRemoveImage()
+    const file = event.dataTransfer.files?.[0]
+    if (!file) return
+
+    if (!validTypes.includes(file.type)) {
+      const error = `Formato inválido. Solo se permiten: ${formattedList}.`
+      sendNotification({
+        description: error,
+        title: 'Error',
+        backgroundColor: 'error'
+      })
+      return setError(error)
     }
 
-    const handleDrop = async (event: React.DragEvent<HTMLDivElement>): Promise<void> => {
-        event.preventDefault()
-        handleRemoveImage()
-        const file = event.dataTransfer.files?.[0]
-        if (!file) return
-
-        if (!validTypes.includes(file.type)) {
-            const error = `Formato inválido. Solo se permiten: ${formattedList}.`
-            sendNotification({
-                description: error,
-                title: 'Error',
-                backgroundColor: 'error'
-            })
-            return setError(error)
-        }
-
-        if (file.size > maxSizeMB * 1024 * 1024) {
-            const error = `El archivo supera los ${maxSizeMB} MB.`
-            sendNotification({
-                description: error,
-                title: 'Error',
-                backgroundColor: 'error'
-            })
-            return setError(error)
-        }
-
-        let imageDataUrl = await readFile(file)
-
-        try {
-            const orientation = await getOrientation(file, validTypes)
-            const rotation = ORIENTATION_TO_ANGLE[orientation]
-            if (rotation) {
-                imageDataUrl = await getRotatedImage(imageDataUrl, rotation) as string
-                setRotation(rotation)
-            }
-        } catch (e) {
-            return sendNotification({
-                description: 'Error al procesar la orientación de la imagen',
-                title: 'Error',
-                backgroundColor: 'error'
-            })
-        }
-
-        const image = new Image()
-        image.src = imageDataUrl
-        image.onload = () => {
-            if (image.width < minWidth || image.height < minHeight) {
-                const error = `Resolución mínima: ${minWidth}x${minHeight}px.`
-                sendNotification({
-                    description: error,
-                    title: 'Error',
-                    backgroundColor: 'error'
-                })
-                setError(error)
-                return
-            }
-            setImageSrc(imageDataUrl)
-            setImage(file)
-            setOpen(true)
-        }
+    if (file.size > maxSizeMB * 1024 * 1024) {
+      const error = `El archivo supera los ${maxSizeMB} MB.`
+      sendNotification({
+        description: error,
+        title: 'Error',
+        backgroundColor: 'error'
+      })
+      return setError(error)
     }
 
+    let imageDataUrl = await readFile(file)
+
+    try {
+      const orientation = await getOrientation(file, validTypes)
+      const rotation = ORIENTATION_TO_ANGLE[orientation]
+      if (rotation) {
+        imageDataUrl = await getRotatedImage(imageDataUrl, rotation) as string
+        setRotation(rotation)
+      }
+    } catch (e) {
+      return sendNotification({
+        description: 'Error al procesar la orientación de la imagen',
+        title: 'Error',
+        backgroundColor: 'error'
+      })
+    }
 
-
-
-    return {
-        inputRef,
-        open,
-        imageSrc,
-        preview,
-        croppedImage,
-        crop,
-        zoom,
-        image,
-        rotation,
-        error,
-        formattedList,
-        loading,
-        validTypes,
-        onCropComplete,
-        showCroppedImage,
-        handleRemoveImage,
-        handleDrop,
-        onFileChange,
-        handleClose,
-        setCrop,
-        setZoom,
-        setRotation,
+    const image = new Image()
+    image.src = imageDataUrl
+    image.onload = () => {
+      if (image.width < minWidth || image.height < minHeight) {
+        const error = `Resolución mínima: ${minWidth}x${minHeight}px.`
+        sendNotification({
+          description: error,
+          title: 'Error',
+          backgroundColor: 'error'
+        })
+        setError(error)
+        return
+      }
+      setImageSrc(imageDataUrl)
+      setImage(file)
+      setOpen(true)
     }
+  }
+
+
+  return {
+    inputRef,
+    open,
+    imageSrc,
+    preview,
+    croppedImage,
+    crop,
+    zoom,
+    image,
+    rotation,
+    error,
+    formattedList,
+    loading,
+    validTypes,
+    onCropComplete,
+    showCroppedImage,
+    handleRemoveImage,
+    handleDrop,
+    onFileChange,
+    handleClose,
+    setCrop,
+    setZoom,
+    setRotation
+  }
 }

package/src/hooks/useImageWeight/{index.js → index.ts}

@@ -1,5 +1,9 @@
 import { useEffect, useState } from 'react'
 
+/**
+ *
+ * @param imageUrl
+ */
 export function useImageWeight (imageUrl) {
   const [weight, setWeight] = useState(null)