npm-pkg-hook 1.12.7 → 1.12.8

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.ts

@@ -0,0 +1,49 @@
+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 [updateExtProductOptional] = useMutation(UPDATE_EXTRAS_PRODUCT_FOOD_OPTIONAL)
+
+  const handleUpdateExtProduct = async ({
+    pId,
+    code,
+    opExPid,
+    OptionalProName,
+    required,
+    numbersOptionalOnly
+  }: {
+    pId: string
+    code: string
+    opExPid: string
+    OptionalProName?: string
+    required?: boolean
+    numbersOptionalOnly?: number | string
+  }) => {
+    return await updateExtProductOptional({
+      variables: {
+        input: {
+          pId,
+          code,
+          opExPid,
+          OptionalProName,
+          required,
+          numbersOptionalOnly: Number(numbersOptionalOnly)
+        }
+      },
+      update: (cache, { data: { ExtProductFoodsOptionalAll } }) => {
+        updateCacheMod({
+          cache,
+          query: GET_EXTRAS_PRODUCT_FOOD_OPTIONAL,
+          nameFun: 'ExtProductFoodsOptionalAll',
+          dataNew: ExtProductFoodsOptionalAll,
+          type: 1
+        })
+      }
+    })
+  }
+  return {
+    handleUpdateExtProduct
+  }
+}

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/useAnimationFrame/index.ts

@@ -0,0 +1,45 @@
+import { useEffect, useRef } from 'react'
+
+export const useAnimationFrame = (callback, start, end, duration = 1000) => {
+  const functionRef = useRef()
+  const delta = Math.abs(start - end)
+  const frameCount = Math.ceil(60 * (duration / 1000))
+  const iteration = useRef(frameCount)
+  useEffect(() => {
+    const animate = (rafId) => {
+      if (iteration.current <= 0) {
+        cancelAnimationFrame(rafId)
+        iteration.current = frameCount
+      }
+
+      callback(Math.max(delta / iteration.current, 1))
+      iteration.current--
+    }
+
+    if (delta > 0) functionRef.current = requestAnimationFrame(animate)
+
+    return () => { return cancelAnimationFrame(functionRef.current) }
+  }, [callback, delta, frameCount, iteration])
+}
+
+// const Counter = ({ numeral = 0 }) => {
+//   const [currentValue, setCurrentValue] = useState(0)
+//   const fxOperator = currentValue > numeral ? 'subtraction' : 'addition'
+
+//   useAnimationFrame(
+//     (diffValue) => {
+//       // Pass on a function to the setter of the state
+//       // to make sure we always have the latest state
+//       setCurrentValue((prevCount) => {
+//         return fxOperator === 'addition'
+//           ? prevCount + diffValue
+//           : prevCount - diffValue
+//       }
+//       )
+//     },
+//     currentValue,
+//     numeral,
+//     300
+//   )
+//   return <>{new Intl.NumberFormat().format(Math.round(currentValue))}</>
+// }

package/src/hooks/useAnimationText/index.ts

@@ -0,0 +1,31 @@
+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: string) => {
+  const fullTextRef = useRef(textMessage)
+  const [text, setText] = useState('')
+  const [index, setIndex] = useState(0)
+
+  useEffect(() => {
+    if (index < fullText.length) {
+      window.requestAnimationFrame(() => {
+         
+                setText(text => text + fullTextRef.current[index]);
+        setIndex(() => {return index + 1})
+      })
+    }
+  }, [index])
+  useEffect(() => {
+    fullText.current = textMessage
+  }, [textMessage])
+
+  return text
+}
+
+// export default function TextHook() {
+//   const text = useAnimatedText(fullText)
+
+//   return <span>{text} </span>
+// }

package/src/hooks/useAsideCart/helpers/index.ts

@@ -0,0 +1,22 @@
+export const calculateTotalPrice = (shoppingCardData) => {
+  if (Array.isArray(shoppingCardData) && shoppingCardData.length) {
+    return shoppingCardData.reduce((accumulator, currentItem) => {
+      const { productFood = {}, cantProducts } = currentItem || {}
+      const { ProPrice = 0, ValueDelivery = 0 } = productFood || {}
+
+      const pricePerProduct = ProPrice * cantProducts
+      const deliveryCost = ValueDelivery || 0
+      const ExtProductFoodsAll = currentItem.ExtProductFoodsAll || []
+
+      const extraPriceSum = ExtProductFoodsAll.reduce((extraAccumulator, extraFood) => {
+        if (Number.isInteger(extraFood.newExtraPrice)) {
+          return extraAccumulator + extraFood.newExtraPrice
+        }
+        return extraAccumulator
+      }, 0)
+
+      return accumulator + pricePerProduct + deliveryCost + extraPriceSum
+    }, 0)
+  }
+  return 0
+}