npm-pkg-hook 1.12.4 → 1.12.8

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

@@ -1,7 +1,7 @@
 /**
-     * Get the start timestamp for the current day.
-     * @returns {string} The start timestamp for the current day.
-     */
+ * Get the start timestamp for the current day.
+ * @returns {string} The start timestamp for the current day.
+ */
 export const getStartOfDayTimestamp = () => {
   const start = new Date()
   start.setHours(0, 0, 0, 0)
@@ -9,9 +9,9 @@ export const getStartOfDayTimestamp = () => {
 }
 
 /**
-     * Get the end timestamp for the current day.
-     * @returns {string} The end timestamp for the current day.
-     */
+ * Get the end timestamp for the current day.
+ * @returns {string} The end timestamp for the current day.
+ */
 export const getEndOfDayTimestamp = () => {
   const end = new Date()
   end.setHours(23, 59, 59, 999)
@@ -46,6 +46,12 @@ export const getStartTimestampDaysAgo = (daysAgo) => {
   return start.toISOString()
 }
 
+/**
+ *
+ * @param root0
+ * @param root0.dateString
+ * @param root0.start
+ */
 export function convertDateFormat ({ dateString, start }) {
   const parsedDate = dateString ? new Date(dateString) : new Date()
   const year = parsedDate.getFullYear()
@@ -55,10 +61,10 @@ export function convertDateFormat ({ dateString, start }) {
   if (start) {
     // Inicio del día (00:00:00)
     return `${year}-${month}-${day}T00:00:00.000Z`
-  } else {
-    // Final del día (23:59:59.999)
-    const endOfDay = new Date(parsedDate)
-    endOfDay.setHours(23, 59, 59, 999)
-    return endOfDay.toISOString()
-  }
+  } 
+  // Final del día (23:59:59.999)
+  const endOfDay = new Date(parsedDate)
+  endOfDay.setHours(23, 59, 59, 999)
+  return endOfDay.toISOString()
+  
 }

package/src/hooks/getTotalHours/index.ts

@@ -0,0 +1,76 @@
+/**
+ * Schedule day structure
+ */
+export interface ScheduleDay {
+  schHoSta?: string
+  schHoEnd?: string
+}
+
+/**
+ * Calculate total worked hours from a list of days.
+ * Keeps original behavior and edge cases intact.
+ *
+ * @param {ScheduleDay[]} days - Array of days with start and end times
+ * @returns {string} Total time formatted as HH:MM
+ */
+export const getTotalHours = (days: ScheduleDay[] = []): string => {
+  const totalMinutesArray: number[] = days.map((day) => {
+    const { schHoSta, schHoEnd } = day
+
+    // Handle potential invalid time strings
+    if (!isValidTimeString(schHoSta) || !isValidTimeString(schHoEnd)) {
+      return 0
+    }
+
+    const [startHours, startMinutes] = schHoSta.split(':')
+    const [endHours, endMinutes] = schHoEnd.split(':')
+
+    // Convert hours and minutes to integers for calculations
+    let totalHoursInt =
+      parseInt(endHours, 10) - parseInt(startHours, 10)
+
+    const totalMinutesInt =
+      parseInt(endMinutes, 10) - parseInt(startMinutes, 10)
+
+    // Handle negative total minutes
+    let totalMinutes = totalMinutesInt
+    if (totalMinutes < 0) {
+      totalHoursInt--
+      totalMinutes += 60
+    }
+
+    // Calculate total time in minutes
+    return totalHoursInt * 60 + totalMinutes
+  })
+
+  // Sum all minutes
+  const totalMinutes: number = totalMinutesArray.reduce(
+    (acc, curr) => {return acc + curr},
+    0
+  )
+
+  // Convert to hours and minutes
+  const totalHours: number = Math.floor(totalMinutes / 60)
+  const remainingMinutes: number = totalMinutes % 60
+
+  // Format HH:MM
+  const formattedHours = totalHours.toString().padStart(2, '0')
+  const formattedMinutes = remainingMinutes.toString().padStart(2, '0')
+
+  return `${formattedHours}:${formattedMinutes}`
+}
+
+/**
+ * Validate time string format (HH:MM)
+ *
+ * @param {string | undefined} timeString
+ * @returns {boolean}
+ */
+export const isValidTimeString = (
+  timeString?: string
+): timeString is string => {
+  if (!timeString) return false
+
+  const timeRegex = /^([0-1][0-9]|2[0-3]):([0-5][0-9])$/
+  return timeRegex.test(timeString)
+}

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

@@ -1,3 +1,7 @@
+/**
+ *
+ * @param body
+ */
 export async function handleLogin (body) {
   const response = await fetch(`${process.env.URL_BASE}/api/auth/login`, {
     method: 'POST',

package/src/hooks/index.ts

@@ -97,13 +97,13 @@ export * from './useMobile'
 export * from './useMutateHeight'
 export * from './useProductsFood'
 export * from './useProductsFood/usetagsProducts'
-export * from './useReactToPrint'
+// export * from './useReactToPrint'
 export * from './useReport'
 export * from './useSales/useTotalSales'
 export * from './useOrderClient'
 export * from './useStoreContacts'
 export * from './useRestaurant'
-export * from './useSales'
+export * from './useSales/index'
 export * from './useSales/useGetSale'
 export * from './useGetMinPrice'
 export * from './useCatWithProductClient'
@@ -145,3 +145,9 @@ export * from './useOrderStatusTypes'
 export * from './useCreateOrderStatusType'
 export * from './useDevWS'
 export * from './usePrintSaleTicket'
+export * from './usePaymentMethod'
+export * from './useGetAllSales'
+export * from './useTheme'
+export * from './useFilterConfigs'
+export * from './useStock'
+export * from './getSession'

package/src/hooks/statusOpenStores/helpers/{index.js → index.ts}

@@ -12,10 +12,17 @@ export const getDayFromOpeningKey = (key) => {
 }
 
 // Función para convertir el objeto de tiempo en una cadena de tiempo
+/**
+ *
+ * @param timeStr
+ */
 export function getTimeString (timeStr) {
   return timeStr || '00:00' // Return '00:00' for empty time strings
 }
 
+/**
+ *
+ */
 export function getCurrentDayAndTime () {
   try {
     const date = new Date()
@@ -29,18 +36,26 @@ export function getCurrentDayAndTime () {
   }
 }
 
+/**
+ *
+ * @param timeStr
+ */
 export function getTimeObject (timeStr) {
   try {
     if (!timeStr || !/\d{2}:\d{2}/.test(timeStr)) {
       return { hours: 0, minutes: 0 } // Return default values for invalid input
     }
-    const [hours, minutes] = timeStr.split(':').map(str => parseInt(str))
+    const [hours, minutes] = timeStr.split(':').map(str => {return parseInt(str)})
     return { hours, minutes }
   } catch (e) {
     return { hours: 0, minutes: 0 } // Return default values on error
   }
 }
 
+/**
+ *
+ * @param openings
+ */
 export function sortOpeningsByDay (openings) {
   const days = [
     'openingSun',
@@ -61,6 +76,10 @@ export function sortOpeningsByDay (openings) {
 }
 
 // Función para obtener la clave de openings a partir del día de la semana
+/**
+ *
+ * @param day
+ */
 export function getOpeningKeyFromDay (day) {
   const days = {
     0: 'openingSun',
@@ -84,6 +103,10 @@ export const weekDays = [
   'Sábado'
 ]
 
+/**
+ *
+ * @param text
+ */
 export function timeToInt (text) {
   const hour = parseInt(text.substring(0, 2))
   const minute = parseInt(text.substring(3))

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,4 +1,5 @@
-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'
 
@@ -12,6 +13,13 @@ export const useUpdateExtProductFoodsOptional = () => {
     OptionalProName,
     required,
     numbersOptionalOnly
+  }: {
+    pId: string
+    code: string
+    opExPid: string
+    OptionalProName?: string
+    required?: boolean
+    numbersOptionalOnly?: number | string
   }) => {
     return await updateExtProductOptional({
       variables: {
@@ -25,11 +33,12 @@ export const useUpdateExtProductFoodsOptional = () => {
         }
       },
       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.js → index.ts}

@@ -14,6 +14,9 @@ export const GET_ALL_STORES_PENDING_TO_REGISTER = gql`
   }
 `
 
+/**
+ *
+ */
 export function useAllStoresPendingToRegister () {
   const { loading, error, data } = useQuery(GET_ALL_STORES_PENDING_TO_REGISTER)
 

package/src/hooks/useAmountInput/index.ts

@@ -1,21 +1,21 @@
 import { useState } from 'react'
 
 const formatCurrency = (
-  prefix,
-  amountValue,
-  number,
-  groupSeparator,
-  decimalSeparator,
-  allowDecimals = false,
-  decimalsLimit = 0
-) => {
-  if (isNaN(number)) {
+  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 = parseInt(number.toString())
+  const amountWithoutDecimals = Number.parseInt(number.toString())
   const decimalIdx = amountValue.indexOf(decimalSeparator)
-  const notAllowedChars = new RegExp('[^' + decimalSeparator + '\\d]', 'g')
+  const notAllowedChars = new RegExp(String.raw`[^${decimalSeparator}\d]`, 'g')
   const decimalsWithSeparator =
     decimalIdx >= 0
       ? amountValue
@@ -28,52 +28,62 @@ const formatCurrency = (
     prefix +
     amountWithoutDecimals
       .toString()
-      .replace(/\B(?=(\d{3}){1,5}(?!\d))/g, groupSeparator) +
+      .replaceAll(/\B(?=(\d{3}){1,5}(?!\d))/g, groupSeparator) +
     decimalsWithSeparator
   )
 }
 
-const processInputValue = (input, decimalSeparator) => {
+const processInputValue = (input: string, decimalSeparator: string): number => {
   const decimalRegex = new RegExp('[' + decimalSeparator + ']', 'g')
-  const notAllowedChars = new RegExp('[^' + decimalSeparator + '\\d¬]', 'g')
+  const notAllowedChars = new RegExp(String.raw`[^${decimalSeparator}\d¬]`, 'g')
 
-  return parseFloat(
+  return Number.parseFloat(
     input
-      .replace(decimalRegex, '¬')
-      .replace(notAllowedChars, '')
-      .replace('¬', '.')
+      .replaceAll(decimalRegex, '¬')
+      .replaceAll(notAllowedChars, '')
+      .replaceAll('¬', '.')
   )
 }
 /**
  * Truncate excess decimals from a number based on a limit.
  *
- * @param {number} number The number to truncate.
- * @param {number} decimalsLimit The maximum number of decimal places allowed.
- * @returns {number} The number with truncated decimals.
+ * @param number The number to truncate.
+ * @param decimalsLimit The maximum number of decimal places allowed.
+ * @returns The number with truncated decimals.
  */
-const truncateDecimals = (number, decimalsLimit) => {
-  if (isNaN(number)) {
-    return 0;
+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 const useAmountInput = props => {
+  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,
-    decimalsLimit,
+    allowDecimals = false,
+    decimalsLimit = 0,
     defaultValue
   } = props
 
   const inputVal = defaultValue ?? ''
   const [inputValue, setInputValue] = useState(inputVal)
 
-  const preProcess = amount => {
+  const preProcess = (amount: string) => {
     const amountValue = amount.trim()
     const oldInputValue = inputValue
 
@@ -104,7 +114,7 @@ export const useAmountInput = props => {
       }
       setInputValue(inputValue)
 
-      const callbackValue = isNaN(amountFloatValue) ? 0 : amountFloatValue
+      const callbackValue = Number.isNaN(amountFloatValue) ? 0 : amountFloatValue
       if (typeof onChange === 'function') {
         onChange(truncateDecimals(callbackValue, decimalsLimit))
       }

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})
       })