npm-pkg-hook 1.3.9 → 1.4.0

package/src/hooks/statusOpenStores/index.ts

@@ -0,0 +1,221 @@
+import {
+  getCurrentDayAndTime,
+  getOpeningKeyFromDay,
+  getTimeString,
+  sortOpeningsByDay,
+  weekDays,
+  timeToInt,
+  days
+} from './helpers'
+
+/**
+ * Store schedule structure
+ */
+export interface StoreSchedule {
+  schDay: number
+  schHoSta?: string
+  schHoEnd?: string
+}
+
+/**
+ * Openings object structure
+ */
+export type OpeningsMap = Record<string, string>
+
+/**
+ * Store opening status result
+ */
+export interface OpeningStatus {
+  message: string
+  open: boolean
+}
+
+/**
+ * Hook-like utility to calculate store open status
+ *
+ * @param {Object} params
+ * @param {StoreSchedule[]} params.dataSchedules
+ * @returns {OpeningStatus}
+ */
+export const statusOpenStores = (
+  { dataSchedules = [] }: { dataSchedules?: StoreSchedule[] } = {}
+): OpeningStatus => {
+  const handleHourPmAM = (hour?: string): string => {
+    if (!hour) return ''
+    return new Date(`1/1/1999 ${hour}`).toLocaleString('en-US', {
+      hour: 'numeric',
+      minute: 'numeric',
+      hour12: true
+    })
+  }
+
+  const handleState = (message: string, open: boolean): OpeningStatus => {return {
+    message,
+    open
+  }}
+
+  const getNextDaySchedule = (
+    schedules: StoreSchedule[],
+    currentDayOfWeek: number
+  ) => {
+    const today = new Date()
+    const tomorrow = new Date(today)
+    tomorrow.setDate(today.getDate() + 1)
+
+    const dayOfWeekTomorrow = tomorrow.getDay()
+
+    const findNextDay = schedules?.length
+      ? schedules.some(
+        (schedule) => {return schedule?.schDay === dayOfWeekTomorrow}
+      )
+      : false
+
+    const findDataNextDay =
+      schedules?.find(
+        (schedule) => {return schedule?.schDay === dayOfWeekTomorrow}
+      ) ?? { schDay: dayOfWeekTomorrow }
+
+    return { findNextDay, findDataNextDay, dayOfWeekTomorrow }
+  }
+
+  const getOpeningStatus = (
+    openings: OpeningsMap,
+    currentTime: number,
+    currentDayOfWeek: number
+  ): OpeningStatus => {
+    const weekDayLookup = [
+      'Sunday',
+      'Monday',
+      'Tuesday',
+      'Wednesday',
+      'Thursday',
+      'Friday',
+      'Saturday'
+    ]
+
+    const ceroHours = '00:00 - 00:00'
+    let dayOfWeek = currentDayOfWeek
+
+    for (let i = 0; i < 7; i++) {
+      const dayName = weekDayLookup[dayOfWeek % 7]
+      const opening =
+        openings && openings[`opening${dayName.substring(0, 3)}`]
+
+      const timeSpans = opening
+        ?.split(';')
+        .map((item) => {return item.trim()})
+
+      for (const span of timeSpans ?? []) {
+        const hours = span.split('-').map((item) => {return item.trim()})
+        const openTime = timeToInt(hours[0])
+        const closeTime = timeToInt(hours[1])
+
+        if (currentTime >= openTime && currentTime <= closeTime) {
+          return handleState(
+            `Abierto Ahora - Cierra a las: ${handleHourPmAM(hours[1])}`,
+            true
+          )
+        }
+
+        if (
+          currentTime < openTime &&
+          dayOfWeek === currentDayOfWeek
+        ) {
+          return handleState(
+            `Aun temprano - Abre hoy a las: ${handleHourPmAM(hours[0])}`,
+            false
+          )
+        }
+
+        if (
+          currentTime >= closeTime - 30 * 60000 &&
+          currentTime < closeTime &&
+          dayOfWeek === currentDayOfWeek
+        ) {
+          return handleState(
+            `Pronto por cerrar - Cierra hoy a las: ${handleHourPmAM(hours[1])}`,
+            true
+          )
+        }
+
+        const {
+          findNextDay,
+          findDataNextDay,
+          dayOfWeekTomorrow
+        } = getNextDaySchedule(dataSchedules, currentDayOfWeek)
+
+        if (findNextDay && findDataNextDay?.schHoSta) {
+          const nameOfDayTomorrow = weekDays[dayOfWeekTomorrow]
+          return handleState(
+            `Cerrado abre - Mañana ${nameOfDayTomorrow} a las ${
+              findDataNextDay.schHoSta
+            }`,
+            false
+          )
+        }
+
+        const nextDayName =
+          weekDayLookup[(dayOfWeek + 1) % 7]
+
+        const nextOpening =
+          openings &&
+          openings[`opening${nextDayName.substring(0, 3)}`]
+
+        const nextHours = nextOpening
+          ?.split(';')
+          ?.map((item) => {return item.trim()})
+
+        if (nextHours?.[0] !== ceroHours) {
+          return handleState(
+            `Cerrado - Abre el ${days[nextDayName as keyof typeof days]} a las ${nextHours?.[0]}`,
+            false
+          )
+        }
+      }
+
+      dayOfWeek++
+    }
+
+    return handleState('Cerrado', false)
+  }
+
+  const getIsOpening = (openings: OpeningsMap): OpeningStatus => {
+    const { currentTime, currentDayOfWeek } =
+      getCurrentDayAndTime()
+
+    return getOpeningStatus(
+      openings,
+      currentTime ?? 0,
+      currentDayOfWeek ?? 0
+    )
+  }
+
+  const createOpeningsObject = (
+    schedules: StoreSchedule[]
+  ): OpeningsMap => {
+    const openings: OpeningsMap = {}
+    const existStoreSchedule = schedules || []
+
+    existStoreSchedule.forEach((schedule) => {
+      const openingKey = getOpeningKeyFromDay(schedule.schDay)
+      const schHoSta = getTimeString(schedule?.schHoSta)
+      const schHoEnd = getTimeString(schedule?.schHoEnd)
+
+      openings[openingKey] = `${schHoSta} - ${schHoEnd}`
+    })
+
+    for (let i = 0; i < 7; i++) {
+      const openingKey = getOpeningKeyFromDay(i)
+      if (!(openingKey in openings)) {
+        openings[openingKey] = '00:00 - 00:00'
+      }
+    }
+
+    return openings
+  }
+
+  const openings = createOpeningsObject(dataSchedules)
+  const sortedOpenings = sortOpeningsByDay(openings)
+
+  return getIsOpening(sortedOpenings)
+}

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

@@ -1,9 +1,10 @@
-import { useMutation } from '@apollo/client'
+import { useMutation } from '@apollo/client'
+
 import { updateCacheMod } from '../../utils'
 import { GET_EXTRAS_PRODUCT_FOOD_OPTIONAL, UPDATE_EXTRAS_PRODUCT_FOOD_OPTIONAL } from '../useProductsFood/queriesStore'
 
 export const useUpdateExtProductFoodsOptional = () => {
-  const [updateExtProductFoodsOptional] = useMutation(UPDATE_EXTRAS_PRODUCT_FOOD_OPTIONAL)
+  const [updateExtProductOptional] = useMutation(UPDATE_EXTRAS_PRODUCT_FOOD_OPTIONAL)
 
   const handleUpdateExtProduct = async ({
     pId,
@@ -12,8 +13,15 @@ export const useUpdateExtProductFoodsOptional = () => {
     OptionalProName,
     required,
     numbersOptionalOnly
+  }: {
+    pId: string
+    code: string
+    opExPid: string
+    OptionalProName?: string
+    required?: boolean
+    numbersOptionalOnly?: number | string
   }) => {
-    return await updateExtProductFoodsOptional({
+    return await updateExtProductOptional({
       variables: {
         input: {
           pId,
@@ -21,15 +29,16 @@ export const useUpdateExtProductFoodsOptional = () => {
           opExPid,
           OptionalProName,
           required,
-          numbersOptionalOnly
+          numbersOptionalOnly: Number(numbersOptionalOnly)
         }
       },
       update: (cache, { data: { ExtProductFoodsOptionalAll } }) => {
-        return updateCacheMod({
+        updateCacheMod({
           cache,
           query: GET_EXTRAS_PRODUCT_FOOD_OPTIONAL,
           nameFun: 'ExtProductFoodsOptionalAll',
-          dataNew: ExtProductFoodsOptionalAll
+          dataNew: ExtProductFoodsOptionalAll,
+          type: 1
         })
       }
     })

package/src/hooks/useAcumulateDate/index.ts

@@ -0,0 +1,18 @@
+const data = [
+  { x: '2021-10-17T14:38:45.540Z', y: 2 }
+]
+export const getDateParts = (isString: string) => {
+  const [year, month, day, hr, min, sec] = isString.split(/\D/g)
+  return { year, month, day, hr, min, sec }
+}
+/**
+ *
+ * @param arr
+ */
+export function groupDates(arr: Array<{ x: string; y: number }>) {
+  const total = arr.reduce((a: number, b: { x: string; y: number }) => {
+    const { hr } = getDateParts(b.x)
+    return a + Number.parseInt(hr || '0', 10)
+  }, 0)
+  return total
+}

package/src/hooks/useAllStoresPendingToRegister/index.ts

@@ -0,0 +1,37 @@
+import { gql, useQuery } from '@apollo/client'
+import { useEffect, useState } from 'react'
+
+export const GET_ALL_STORES_PENDING_TO_REGISTER = gql`
+  query GetAllStoresPendingToRegister {
+    getAllStoresPendingToRegister {
+        StorePendingToRegisterId
+    UserId
+    UserEmail
+    StoreNumber
+    createAt
+    updateAt
+    }
+  }
+`
+
+/**
+ *
+ */
+export function useAllStoresPendingToRegister () {
+  const { loading, error, data } = useQuery(GET_ALL_STORES_PENDING_TO_REGISTER)
+
+  const [stores, setStores] = useState([])
+  const [fetchError, setFetchError] = useState(null)
+
+  useEffect(() => {
+    if (!loading && data) {
+      setStores(data.getAllStoresPendingToRegister)
+    }
+
+    if (error) {
+      setFetchError(error.message)
+    }
+  }, [loading, data, error])
+
+  return { loading, stores, fetchError }
+}

package/src/hooks/useAmountInput/index.ts

@@ -0,0 +1,127 @@
+import { useState } from 'react'
+
+const formatCurrency = (
+  prefix: string,
+  amountValue: string,
+  number: number,
+  groupSeparator: string,
+  decimalSeparator: string,
+  allowDecimals: boolean = false,
+  decimalsLimit: number = 0
+): string => {
+  if (Number.isNaN(number)) {
+    return prefix + '0'
+  }
+
+  const amountWithoutDecimals = Number.parseInt(number.toString())
+  const decimalIdx = amountValue.indexOf(decimalSeparator)
+  const notAllowedChars = new RegExp(String.raw`[^${decimalSeparator}\d]`, 'g')
+  const decimalsWithSeparator =
+    decimalIdx >= 0
+      ? amountValue
+        .slice(decimalIdx, amountValue.length)
+        .replace(notAllowedChars, '')
+        .slice(0, decimalsLimit + 1)
+      : ''
+
+  return (
+    prefix +
+    amountWithoutDecimals
+      .toString()
+      .replaceAll(/\B(?=(\d{3}){1,5}(?!\d))/g, groupSeparator) +
+    decimalsWithSeparator
+  )
+}
+
+const processInputValue = (input: string, decimalSeparator: string): number => {
+  const decimalRegex = new RegExp('[' + decimalSeparator + ']', 'g')
+  const notAllowedChars = new RegExp(String.raw`[^${decimalSeparator}\d¬]`, 'g')
+
+  return Number.parseFloat(
+    input
+      .replaceAll(decimalRegex, '¬')
+      .replaceAll(notAllowedChars, '')
+      .replaceAll('¬', '.')
+  )
+}
+/**
+ * Truncate excess decimals from a number based on a limit.
+ *
+ * @param number The number to truncate.
+ * @param decimalsLimit The maximum number of decimal places allowed.
+ * @returns The number with truncated decimals.
+ */
+const truncateDecimals = (number: number, decimalsLimit: number): number => {
+  if (Number.isNaN(number)) {
+    return 0
+  }
+
+  const multiplier = Math.pow(10, decimalsLimit)
+  return Math.floor(number * multiplier) / multiplier
+}
+export interface UseAmountInputProps {
+  onChange?: (value: number) => void
+  prefix?: string
+  groupSeparator?: string
+  decimalSeparator?: string
+  allowDecimals?: boolean
+  decimalsLimit?: number
+  defaultValue?: string
+}
+
+export const useAmountInput = (props: UseAmountInputProps) => {
+  const {
+    onChange = () => {},
+    prefix = '$',
+    groupSeparator = '.',
+    decimalSeparator = ',',
+    allowDecimals = false,
+    decimalsLimit = 0,
+    defaultValue
+  } = props
+
+  const inputVal = defaultValue ?? ''
+  const [inputValue, setInputValue] = useState(inputVal)
+
+  const preProcess = (amount: string) => {
+    const amountValue = amount.trim()
+    const oldInputValue = inputValue
+
+    if (oldInputValue !== amountValue) {
+      const amountFloatValue = processInputValue(amount, decimalSeparator)
+      let inputValue = ''
+      // This allows for people to use `.` but still input decimals
+      const isAboutToIntroduceDecimals =
+        oldInputValue + decimalSeparator === amountValue ||
+        oldInputValue + '.' === amountValue
+      if (allowDecimals === true && isAboutToIntroduceDecimals) {
+        inputValue = oldInputValue + decimalSeparator
+      } else if (
+        (allowDecimals === false || allowDecimals === undefined) &&
+        isAboutToIntroduceDecimals
+      ) {
+        inputValue = oldInputValue
+      } else {
+        inputValue = formatCurrency(
+          prefix,
+          amountValue,
+          amountFloatValue,
+          groupSeparator,
+          decimalSeparator,
+          allowDecimals,
+          decimalsLimit
+        )
+      }
+      setInputValue(inputValue)
+
+      const callbackValue = Number.isNaN(amountFloatValue) ? 0 : amountFloatValue
+      if (typeof onChange === 'function') {
+        onChange(truncateDecimals(callbackValue, decimalsLimit))
+      }
+    }
+  }
+  return {
+    inputValue,
+    preProcess
+  }
+}

package/src/hooks/useAnimationText/{index.jsx → index.ts}

@@ -3,7 +3,7 @@ import { useEffect, useRef, useState } from 'react'
 const fullText =
   ' this is full text it\'ll be animated again! Writing a really huge senetence here so that I can see the animation happen. I know it\'s fast but that\'s how it goes.'
 
-export const useAnimatedText = textMessage => {
+export const useAnimatedText = (textMessage: string) => {
   const fullTextRef = useRef(textMessage)
   const [text, setText] = useState('')
   const [index, setIndex] = useState(0)
@@ -11,7 +11,7 @@ export const useAnimatedText = textMessage => {
   useEffect(() => {
     if (index < fullText.length) {
       window.requestAnimationFrame(() => {
-        // eslint-disable-next-line
+         
                 setText(text => text + fullTextRef.current[index]);
         setIndex(() => {return index + 1})
       })

package/src/hooks/useAsideCart/index.ts

@@ -0,0 +1,217 @@
+import { useMutation } from '@apollo/client'
+import {
+  useState,
+  useEffect,
+  useMemo
+} from 'react'
+
+import { statusOpenStores } from '../statusOpenStores'
+import { useCart, useGetCart } from '../useCart'
+import { useManageQueryParams } from '../useManageQueryParams'
+
+import { calculateTotalPrice } from './helpers'
+import { DELETE_ONE_ITEM_SHOPPING_PRODUCT } from './queries'
+
+
+export const useAsideCart = ({
+  openModalProduct = false,
+  location = {
+    pathname: '',
+    push: (props, state, { shallow }) => {
+      return { ...props, state, shallow }
+    },
+    query: {
+      plato: ''
+    }
+  },
+  setCountItemProduct = (number) => { return number },
+  setAlertBox = (args) => { return args },
+  setOpenModalProduct = () => { },
+  handleMenu = (boolean) => { return boolean }
+} = {
+  openModalProduct: false,
+  location: {
+    pathname: '',
+    push: (props, state, { shallow }) => {
+      return { ...props, state, shallow }
+    },
+    query: {
+      plato: ''
+    }
+  },
+  setCountItemProduct: (number) => { return number },
+  setAlertBox: () => { },
+  setOpenModalProduct: () => { },
+  handleMenu: () => { }
+}) => {
+  const { getOneProduct } = useCart({
+    handleMenu,
+    openModalProduct,
+    location,
+    setOpenModalProduct
+  })
+
+  const { handleQuery } = useManageQueryParams({
+    location
+  })
+
+  const [totalProductPrice, setTotalProductPrice] = useState(0)
+
+  const [dataShoppingCard, { loading }] = useGetCart({ setCountItemProduct })
+
+  // Lógica de transformación de los datos
+  const result2 = useMemo(() => {
+    if (!loading && dataShoppingCard) {
+      return dataShoppingCard.reduce((r, a) => {
+        const storeName = a.getStore?.storeName
+        if (storeName) {
+          r[storeName] = r[storeName] || []
+          r[storeName].push(a)
+        }
+        return r
+      }, {})
+    }
+    return {}
+  }, [loading, dataShoppingCard])
+
+  // Obtener dataProduct2 directamente
+  const key = useMemo(() => {
+    return Object.keys(result2)
+  }, [result2])
+
+  useEffect(() => {
+    const totalPrice = calculateTotalPrice(dataShoppingCard)
+    setTotalProductPrice(Math.abs(totalPrice))
+  }, [dataShoppingCard])
+
+  const [deleteOneItem] = useMutation(DELETE_ONE_ITEM_SHOPPING_PRODUCT, {
+    onCompleted: data => {
+      setAlertBox({ message: data?.deleteOneItem?.message })
+
+      if (dataShoppingCard?.length === 1 && data?.deleteOneItem?.success) {
+        setAlertBox({ message: 'Tu carrito está vacío' }) // Ajusta el mensaje en español
+        handleMenu(false) // Oculta el menú del carrito
+      }
+    }
+  })
+
+  const handleEditProduct = async (item) => {
+    const pId = item?.pId || null
+    if (pId) handleQuery('plato', pId)
+    if (pId) {
+      const product = { pId, intoCart: true }
+      getOneProduct(product)
+    }
+  }
+  /**
+   * Handle the deletion of a shopping cart item.
+   * @param {Object} item - The item to be deleted from the shopping cart.
+   */
+  const handleDeleteItemShopping = async (item) => {
+    if (!item) {
+      return setAlertBox({
+        message: 'Error borrando el producto. Por favor intenta nuevamente.',
+        color: 'error'
+      })
+    }
+
+    try {
+      const { cState, ShoppingCard } = item
+      await deleteOneItem({
+        variables: { cState, ShoppingCard },
+        update: (cache) => {
+          cache.modify({
+            fields: {
+              getAllShoppingCard (existingCart, { readField }) {
+                if (!Array.isArray(existingCart)) return []
+
+                const filteredCart = existingCart.filter(product =>
+                {return readField('ShoppingCard', product) !== ShoppingCard}
+                )
+
+                // Actualizar el contador de productos
+                setCountItemProduct(filteredCart.length)
+
+                return filteredCart?.length > 0 ? filteredCart : []
+              }
+            }
+          })
+        }
+      })
+    } catch (error) {
+      setAlertBox({ message: 'Error borrando el producto. Por favor intenta nuevamente.', color: 'error' })
+    }
+  }
+
+  /**
+   * Calculate the total price of a product.
+   * @param {number} ProPrice - The price of the product.
+   * @param {number} ProDelivery - The delivery cost of the product.
+   * @param {number} cant - The quantity of the product.
+   * @returns {number} The calculated total price.
+   */
+  const sumProduct = (ProPrice, ProDelivery, cant) => {
+    // Convertir a números, con manejo de posibles errores
+    const price = ProPrice
+    const delivery = ProDelivery || 0
+    const quantity = cant
+
+    // Verificar si las conversiones fueron exitosas
+    if (isNaN(price) || isNaN(delivery) || isNaN(quantity)) {
+      throw new Error('Los valores proporcionados no son números válidos.')
+    }
+
+    // Calcular el precio final
+    const priceFinal = quantity * price
+
+    // Devolver la suma total, incluyendo el costo de entrega si es aplicable
+    return delivery ? priceFinal + delivery : priceFinal
+  }
+  console.log(dataShoppingCard)
+
+  /**
+   * Verifica el estado de apertura de la tienda.
+   *
+   * @returns {Object|null} Objeto con el estado de apertura de la tienda o null en caso de error.
+   * @throws {Error} Si ocurre un error durante la verificación del estado de la tienda.
+   */
+  const handleVerifyStoreOpenStatus = () => {
+  /**
+   * @type {Array} dataShoppingCard - El array de la tarjeta de compras.
+   */
+    if (!Array.isArray(dataShoppingCard)) {
+      return { open: false } // Retorna un objeto indicando que la tienda no está abierta
+    }
+
+    /**
+     * @type {Object} store - La primera tienda en el array de la tarjeta de compras.
+     */
+    const store = dataShoppingCard[0] || {}
+    /**
+     * @type {Object} getStore - El objeto que contiene información de la tienda.
+     */
+    const { getStore } = store
+
+    /**
+     * @type {Array} storeSchedules - El array de horarios de la tienda.
+     */
+    const storeSchedules = Array.isArray(getStore?.getStoreSchedules) ? getStore?.getStoreSchedules : []
+    try {
+      const status = getStore?.scheduleOpenAll ? { open: true } : statusOpenStores({ dataSchedules: storeSchedules })
+      return status
+    } catch (error) {
+      return null
+    }
+  }
+
+  return {
+    key,
+    totalProductPrice,
+    result2,
+    dataShoppingCard,
+    handleDeleteItemShopping,
+    handleEditProduct,
+    handleVerifyStoreOpenStatus,
+    sumProduct
+  }
+}

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

@@ -1,4 +1,5 @@
-import { useQuery } from '@apollo/client'
+import { useQuery } from '@apollo/client'
+
 import { GET_ONE_BANNER_STORE } from '../useProductsFood/queriesStore'
 import { useStore } from '../useStore'