npm-pkg-hook 1.12.7 → 1.12.8

package/src/hooks/useFormTools/index.ts

@@ -0,0 +1,143 @@
+import {
+  useCallback,
+  useEffect,
+  useState
+} from 'react'
+
+import { validationSubmitHooks } from '../../utils'
+
+
+interface UseFormToolsProps {
+  initialValues?: Record<string, any>;
+  sendNotification?: ({
+    title,
+    description,
+    backgroundColor
+  }: {
+    title?: string;
+    description?: string;
+    backgroundColor?: string;
+  }) => void;
+}
+
+/**
+ * @param root0
+ * @param root0.initialValues
+ * @param root0.sendNotification
+ * @version 0.0.1
+ * @description Hook con herramientas de validación y eventos de cambio
+ * @return {Array} devuelve la función onChange a ejecutar y el estado de error de cada input
+ */
+export const useFormTools = ({
+  initialValues = {},
+  sendNotification = ({
+    title = '',
+    description = '',
+    backgroundColor = ''
+  }) => {
+    console.log({ title, description, backgroundColor })
+  }
+}: UseFormToolsProps = {}) => {
+  const [dataForm, setDataForm] = useState<Record<string, any>>({ ...initialValues })
+  const [errorForm, setErrorForm] = useState<Record<string, boolean>>({})
+  const [errorSubmit, setErrorSubmit] = useState(false)
+  const [calledSubmit, setCalledSubmit] = useState(false)
+  // Handle Change
+  const handleChange = useCallback((e: React.ChangeEvent<HTMLInputElement>, error: boolean) => {
+    setDataForm({ ...dataForm, [e.target.name]: e.target.value })
+    setErrorForm({ ...errorForm, [e.target.name]: error })
+  }, [setDataForm, dataForm, errorForm, setErrorForm])
+
+  // Forzar datos desde una ventana externa
+  const handleForcedData = useCallback((data: Record<string, any>) => {
+    setDataForm(data)
+  }, [setDataForm])
+
+  // Forzar datos de error desde una ventana externa
+  const setForcedError = useCallback((errors: Record<string, boolean>) => {
+    setErrorForm(errors)
+  }, [setErrorForm])
+
+  // Handle submit, al enviar formulario
+  const listErrors = Object.values(errorForm)
+  const errors = listErrors.find((error) => {
+    return error === true
+  })
+
+  const handleSubmit = ({
+    event,
+    msgError = '',
+    msgSuccess,
+    action = () => { return Promise.resolve() },
+    actionAfterSuccess = () => { }
+  }: {
+    event: React.FormEvent<HTMLFormElement>,
+    msgError?: string,
+    msgSuccess?: string,
+    action?: () => Promise<any>,
+    actionAfterSuccess?: () => void
+  }) => {
+    event.preventDefault()
+    setCalledSubmit(true)
+    let errSub = false
+
+    // Valida los errores locales
+    for (const x in errorForm) {
+      if (errorForm[x]) errSub = true
+    }
+    if (errSub) {
+      sendNotification({
+        description: 'Completa los campos requeridos',
+        title: 'Error',
+        backgroundColor: 'error'
+      })
+    }
+    if (errors) {
+      setErrorSubmit(true)
+      return setForcedError({ ...errorForm })
+    }
+
+    if (errSub) return setErrorSubmit(errSub)
+
+    // Valida los errores desde el evento
+    const errores = validationSubmitHooks(event.currentTarget.elements)
+    setErrorForm(errores)
+    for (const x in errores) {
+      // @ts-ignore
+      if (errores[x]) errSub = true
+    }
+    if (errSub) return setErrorSubmit(errSub)
+
+    // Ejecuta la accion si es válido
+    if (!errSub && typeof action === 'function') {
+      const result = action()
+      if (result && typeof result.then === 'function') {
+        result.then((res) => {
+          if (res) {
+            sendNotification({
+              title: msgSuccess ?? 'Operación exitosa',
+              description: 'Operación exitosa',
+              backgroundColor: 'success'
+            })
+            if (actionAfterSuccess) actionAfterSuccess()
+          }
+        }).catch((e) => {
+          sendNotification({
+            title: msgError || e?.message || 'Ha ocurrido un error',
+            backgroundColor: 'error'
+          })
+        })
+      }
+    }
+
+    setErrorSubmit(errSub)
+  }
+
+  useEffect(() => { return setCalledSubmit(false) }, [calledSubmit])
+  useEffect(() => {
+    return setCalledSubmit(false)
+  },
+  [])
+
+  return [handleChange, handleSubmit, handleForcedData, { dataForm, errorForm, errorSubmit, calledSubmit, setForcedError }]
+}

package/src/hooks/useFormatDate/index.ts

@@ -0,0 +1,91 @@
+interface UseFormatDateProps {
+  date?: string | number | Date;
+  local?: string;
+}
+
+export const useFormatDate = ({
+  date,
+  local = 'ES-CO'
+}: UseFormatDateProps = {}) => {
+  const dateToFormat = new Date(date ?? Date.now())
+  const fullDate = dateToFormat.toLocaleDateString(local, { year: 'numeric', month: '2-digit', day: '2-digit' })
+  const day = fullDate.split('/')[0]
+  const month = fullDate.split('/')[1]
+  const year = fullDate.split('/')[2]
+  const yearMonthDay = dateToFormat.toLocaleDateString('ES-CO')
+  const numberDay = dateToFormat.getDay()
+  const shortDayName = dateToFormat.toLocaleDateString(local, { weekday: 'short' })
+  const longDayName = dateToFormat.toLocaleDateString(local, { weekday: 'long' })
+  const hourMinutes12 = dateToFormat.toLocaleTimeString('ES-CO', { hour: '2-digit', minute: '2-digit' })
+  const hourMinutes24 = dateToFormat.toLocaleTimeString('ES-CO', { hour: '2-digit', minute: '2-digit', hour12: false })
+  const handleHourPmAM = (hour: string) => {
+    const hourPmAm = new Date(`1/1/1999 ${hour}`).toLocaleString('en-US', { hour: 'numeric', minute: 'numeric', hour12: true })
+    return hour ? hourPmAm : ''
+  }
+  /**
+   * Formats a date into Colombian time zone and Spanish locale for POS display.
+   * Example output: "15 de mayo de 2025 a las 14:23"
+   *
+   * @param {string | number | Date} dateInput - Date to format (ISO string, timestamp or Date object)
+   * @returns {string} - Formatted date string in Colombian time
+   */
+  function formatDateInTimeZone (dateInput : string | number | Date): string {
+    const timeZone = 'America/Bogota'
+    const locale = 'es-CO'
+    const options: Intl.DateTimeFormatOptions = {
+      timeZone,
+      year: 'numeric',
+      month: 'long',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      hour12: false
+    }
+
+    const date = new Date(dateInput)
+    const formatted = new Intl.DateTimeFormat(locale, options).format(date)
+
+    // Cambiar coma por "a las" para mejor legibilidad
+    return formatted.replace(',', ' a las')
+  }
+  /**
+   * Formats a date into YYYY-MM-DD using a given IANA timezone.
+   *
+   * @param {string | number | Date} inputDate - The date to format.
+   * @param {string} timeZone - IANA timezone string (default is "America/Bogota").
+   * @returns {string} Formatted date string in YYYY-MM-DD.
+   * @throws {Error} If the input date is invalid.
+   */
+  const formatToLocalDateYMD = (inputDate: string | number | Date, timeZone = 'America/Bogota') => {
+    const date = new Date(inputDate)
+
+    if (isNaN(date.getTime())) {
+      throw new Error('Invalid date input provided to formatToLocalDateYMD')
+    }
+
+    const localDateStr = date.toLocaleString('en-US', { timeZone })
+    const localDate = new Date(localDateStr)
+
+    const year = localDate.getFullYear()
+    const month = String(localDate.getMonth() + 1).padStart(2, '0')
+    const day = String(localDate.getDate()).padStart(2, '0')
+
+    return `${year}-${month}-${day}`
+  }
+
+  return {
+    day,
+    fullDate,
+    formatToLocalDateYMD,
+    hourMinutes12,
+    numberDay,
+    yearMonthDay,
+    hourMinutes24,
+    longDayName,
+    shortDayName,
+    month,
+    year,
+    handleHourPmAM,
+    formatDateInTimeZone
+  }
+}

package/src/hooks/useFormatNumberPhone/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Description
+ * @param {any} phoneNumber type number or string
+ * @returns {any}
+ */
+export const formatPhoneNumber = (phoneNumber) => {
+  const cleaned = ('' + phoneNumber).replace(/\D/g, '')
+  const match = cleaned.match(/^(\d{3})(\d{3})(\d{4})$/)
+  if (match) {
+    return `(${match[1]}) ${match[2]}-${match[3]}`
+  }
+  return phoneNumber
+}
+
+/**
+ * Description
+ * @param {any} phoneNumber type number or string
+ * @returns {any}
+ */
+export const validatePhoneNumber = (phoneNumber) => {
+  const regex = /^\(\d{3}\) \d{3}-\d{4}$/
+  return regex.test(phoneNumber)
+}

package/src/hooks/useFullScreenMode/index.ts

@@ -0,0 +1,61 @@
+import React, { useState, useRef, useEffect } from 'react'
+
+export const useFullscreenMode = () => {
+  const [isFullscreen, setFullscreen] = useState(false)
+  const elementRef = useRef()
+
+  useEffect(() => {
+    const changeHandler = () => { return setFullscreen(mode => { return !mode }) }
+
+    document.addEventListener('fullscreenchange', changeHandler, false)
+    document.addEventListener('mozfullscreenchange', changeHandler, false)
+    document.addEventListener('MSFullScreenChange', changeHandler, false)
+    document.addEventListener(
+      'webkitfullscreenchange',
+      changeHandler,
+      false
+    )
+
+    return () => {
+      document.removeEventListener('fullscreenchange', changeHandler)
+      document.removeEventListener('mozfullscreenchange', changeHandler)
+      document.removeEventListener('MSFullScreenChange', changeHandler)
+      document.removeEventListener(
+        'webkitfullscreenchange',
+        changeHandler
+      )
+    }
+  }, [])
+
+  const goFullscreen = () => {
+    if (elementRef.current.requestFullscreen) {
+      elementRef.current.requestFullscreen()
+    } else if (elementRef.current.mozRequestFullscreen) {
+      // Firefox
+      elementRef.current.mozRequestFullscreen()
+    } else if (elementRef.current.webkitRequestFullscreen) {
+      // Chrome, safari, opera
+      elementRef.current.webkitRequestFullscreen()
+    } else if (elementRef.current.msRequestFullscreen) {
+      // IE, edge
+      elementRef.current.msRequestFullscreen()
+    }
+  }
+
+  const exitFullScreen = () => {
+    if (document.exitFullscreen) {
+      document.exitFullscreen()
+    } else if (document.mozCancelFullScreen) {
+      document.mozCancelFullScreen()
+    } else if (document.webkitExitFullscreen) {
+      document.webkitExitFullscreen()
+    } else if (document.msExitFullscreen) {
+      document.msExitFullscreen()
+    }
+  }
+
+  const ToggleIcon = (
+    <button onDoubleClick={() => { return (!isFullscreen ? goFullscreen() : exitFullScreen()) }}>{!isFullscreen ? 'FullScreen' : 'Normal'}</button>
+  )
+  return [elementRef, ToggleIcon] // Icon, ref
+}

package/src/hooks/useGenerateNumberArray/index.ts

@@ -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
+}

package/src/hooks/useGetAllLocationUser/index.ts

@@ -0,0 +1,13 @@
+import { useQuery } from '@apollo/client'
+
+import { GET_ALL_LOCATIONS } from './queries'
+
+/**
+ * useGetAllLocationUser
+ * @returns {any}
+ */
+export const useGetAllLocationUser = () => {
+  const { data, loading } = useQuery(GET_ALL_LOCATIONS)
+
+  return [data, { loading }]
+}

package/src/hooks/useGetAllLocationUser/queries.ts

@@ -0,0 +1,44 @@
+import { gql } from '@apollo/client'
+
+export const GET_ALL_LOCATIONS = gql`
+
+query getUserLocations {
+  getUserLocations {
+    locationId
+    # id
+    cId
+    dId
+    ctId
+    uLatitud
+    uLongitude
+    uLocationKnow
+    uPiso
+    DatCre
+    DatMod
+       pais {
+        cId
+        cName
+        cCalCod
+        cState
+        cDatCre
+        cDatMod
+      }
+      city {
+        ctId
+        dId
+        cName
+        cState
+        cDatCre
+        cDatMod
+      } 
+      department {
+        dId
+        cId
+        dName
+        dState
+        dDatCre
+        dDatMod
+      }
+  }
+}
+`

package/src/hooks/useGetAllSales/index.ts

@@ -0,0 +1,26 @@
+import { useQuery } from '@apollo/client'
+
+import { GET_ALL_SALES_STATISTICS } from '../useSales/queries'
+
+export const useGetAllSales = ({
+  fromDate = '',
+  toDate = ''
+} = {}) => {
+  const {
+    data,
+    loading,
+    error
+  } = useQuery(GET_ALL_SALES_STATISTICS, {
+    fetchPolicy: 'cache-first',
+    variables: {
+      fromDate,
+      toDate
+    }
+  })
+
+  return {
+    data: data?.getAllSalesStoreStatistic || [],
+    error,
+    loading
+  }
+}

package/src/hooks/useGetCookies/index.ts

@@ -0,0 +1,43 @@
+import Cookies from 'js-cookie'
+
+export const useGetCookies = () => {
+  const getCookies = (cookieNames) => {
+    try {
+      if (!Array.isArray(cookieNames)) {
+        throw new Error('Input cookie names should be an array.')
+      }
+
+      const cookiesData = []
+
+      for (const cookieName of cookieNames) {
+        const cookieValue = Cookies.get(cookieName)
+        if (cookieValue) {
+          cookiesData.push({ name: cookieName, value: cookieValue })
+        }
+      }
+      return cookiesData
+    } catch (error) {
+      console.error('Error al traer las cookies:', error)
+      return []
+    }
+  }
+
+  const getCookie = (cookieName) => {
+    try {
+      if (typeof cookieName !== 'string') {
+        throw new Error('Input cookie name should be a string.')
+      }
+
+      const cookieValue = Cookies.get(cookieName)
+      if (cookieValue) {
+        return { name: cookieName, value: cookieValue }
+      }
+      return null
+    } catch (error) {
+      console.error('Error al traer la cookie:', error)
+      return null
+    }
+  }
+
+  return { getCookies, getCookie }
+}

package/src/hooks/useGetExtProductFoodsSubOptionalAll/index.ts

@@ -0,0 +1,15 @@
+import { useLazyQuery } from '@apollo/client'
+
+import { GET_EXTRAS_PRODUCT_FOOD_OPTIONAL } from '../useProductsFood/queriesStore'
+
+export const useGetExtProductFoodsSubOptionalAll = ({ setDataOptional = () => { } } = {}) => {
+  const [ExtProductFoodsSubOptionalAll] = useLazyQuery(
+    GET_EXTRAS_PRODUCT_FOOD_OPTIONAL,
+    {
+      onError: () => {
+        setDataOptional([])
+      }
+    }
+  )
+  return [ExtProductFoodsSubOptionalAll]
+}

package/src/hooks/useGetFoodRecomended/index.ts

@@ -0,0 +1,33 @@
+import { useQuery } from '@apollo/client'
+
+import { GET_ALL_PRODUCT_STORE_RECOMENDED } from './queries'
+
+export const useGetFoodRecomended = ({
+  name = ''
+}) => {
+  const {
+    data,
+    called,
+    fetchMore,
+    loading,
+    error
+  } = useQuery(GET_ALL_PRODUCT_STORE_RECOMENDED, {
+    fetchPolicy: 'cache-and-network',
+    skip: !name,
+    notifyOnNetworkStatusChange: true,
+    nextFetchPolicy: 'cache-first',
+    refetchWritePolicy: 'merge',
+    variables:
+        {
+          max: 6,
+          search: name
+        }
+  })
+
+  return [data?.productFoodsAllRecommended, {
+    called,
+    fetchMore,
+    loading,
+    error
+  }]
+}

package/src/hooks/useGetFoodRecomended/queries.ts

@@ -0,0 +1,47 @@
+import { gql } from '@apollo/client'
+
+export const GET_ALL_PRODUCT_STORE_RECOMENDED = gql`
+query productFoodsAllRecommended($search: String, $min: Int, $max: Int, $gender: [String], $desc: [String], $categories: [ID], ) {
+  productFoodsAllRecommended(search: $search, min: $min, max: $max, gender: $gender, desc: $desc, categories: $categories,) {
+    pId
+    sizeId #Talla
+    colorId #Color
+    cId  #Country
+    dId  #Department
+    ctId  #Cuidad
+    fId  #Características
+    pName
+    ProPrice
+    ProDescuento
+  ProUniDisponibles
+  ProDescription
+  ProProtegido
+  ProAssurance
+  ProStar
+    sTateLogistic
+  ProImage
+  ProWidth
+  ProHeight
+  ProLength
+  ProWeight
+  ProQuantity
+  ProOutstanding
+  pDatCre
+    pDatMod
+  ProDelivery
+  ProVoltaje
+    pState
+    feat {
+      fId
+      thpId
+      hpqrQuestion
+    }
+    area {
+      aId
+      aName
+    }
+    
+  }
+}
+
+`

package/src/hooks/useGetMessagesToRoom/index.ts

@@ -0,0 +1,23 @@
+import { useQuery, gql } from '@apollo/client'
+
+// Define la consulta GraphQL
+const GET_MESSAGES = gql`
+  query getMessages($codeRoom: String!, $id: String!) {
+    getMessages(codeRoom: $codeRoom, id: $id) {
+      uuid
+      content
+      from
+      to
+      aDatCre
+    }
+  }
+`
+
+export const useGetMessagesToRoom = (codeRoom, id) => {
+  const { loading, error, data } = useQuery(GET_MESSAGES, {
+    context: { clientName: 'web-socket-chat' },
+    variables: { codeRoom, id }
+  })
+
+  return [data?.getMessages ?? [], { loading, error }]
+}

package/src/hooks/useGetMinPrice/index.ts

@@ -0,0 +1,13 @@
+import { useQuery } from '@apollo/client'
+
+import { GET_MIN_PEDIDO } from './queries'
+
+export const useGetMinPrice = ({ idStore = '' } = {}) => {
+  const { data, loading, error } = useQuery(GET_MIN_PEDIDO, {
+    variables: {
+      idStore
+    }
+  })
+
+  return [data, { loading, error }]
+}

package/src/hooks/useGetMinPrice/queries.ts

@@ -0,0 +1,7 @@
+import { gql } from '@apollo/client'
+
+export const GET_MIN_PEDIDO = gql`
+query getMinPrice($idStore: ID){
+getMinPrice(idStore: $idStore)
+}
+`

package/src/hooks/useGetOneStoreRating/index.ts

@@ -0,0 +1,41 @@
+import { useLazyQuery } from '@apollo/client'
+import { useState } from 'react'
+
+import { GET_ONE_RATING_STORE } from './queries'
+
+export const useGetOneStoreRating = () => {
+  const [ratings, setRatings] = useState({
+    rGoodTemperature: 0,
+    rGoodCondition: 0,
+    rTasty: 0,
+    appearance: 0
+  })
+
+  const [getOneRating] = useLazyQuery(GET_ONE_RATING_STORE, {
+    onCompleted: res => {
+      if (res) {
+        setRatings((prevState) => {
+          const {
+            rGoodTemperature,
+            rGoodCondition,
+            rTasty,
+            rAppearance
+          } = res.getOneRating || {}
+          return {
+            ...prevState,
+            rGoodTemperature: rGoodTemperature || 0,
+            rGoodCondition: rGoodCondition || 0,
+            rTasty: rTasty || 0,
+            appearance: rAppearance || 0
+          }
+        })
+      }
+    }
+  })
+
+  return {
+    ratings,
+    setRatings,
+    getOneRating
+  }
+}

package/src/hooks/useGetOneStoreRating/queries.ts

@@ -0,0 +1,18 @@
+import { gql } from '@apollo/client'
+
+export const GET_ONE_RATING_STORE = gql`
+query getOneRating($idStore: ID){
+getOneRating(idStore: $idStore){
+  idStore
+  rId
+  id
+  rAppearance
+  rTasty
+  rGoodTemperature
+  rGoodCondition
+  rState
+  createAt
+  updateAt
+  }
+}
+`