npm-pkg-hook 1.12.4 → 1.12.8

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

@@ -9,105 +9,108 @@ import {
   useReducer,
   useMemo,
   useState
-} from 'react'
+} from 'react'
+
 import { Cookies } from '../../cookies'
 import { RandomCode, getCurrentDomain } from '../../utils'
+import { generateTicket } from '../../utils/generateCode'
+import { useCatWithProduct } from '../useCatWithProduct'
+import { CatProductWithProduct, GetCatProductsWithProductResponse } from '../useCatWithProduct/types'
 import { useFormatDate } from '../useFormatDate'
-import { useProductsFood } from '../useProductsFood'
+import { useLogout } from '../useLogout'
+import { useGetOneProductsFood, useProductsFood } from '../useProductsFood'
 import {
   GET_ALL_EXTRA_PRODUCT,
   GET_EXTRAS_PRODUCT_FOOD_OPTIONAL,
   GET_ONE_PRODUCTS_FOOD
 } from '../useProductsFood/queriesStore'
-import { useStore } from '../useStore'
+import { useStore } from '../useStore'
+
+// import { updateExistingOrders } from '../useUpdateExistingOrders'
+
+import { addToCartFunc } from './helpers/add-product.utils'
+import { applyDiscountToCart } from './helpers/apply-discount-to-cart.utils'
+import { initialStateSales, SalesActionTypes } from './helpers/constants'
+import { decrementExtra } from './helpers/extras.utils'
+import { filterProductsByCarProId } from './helpers/filterProductsByCarProId.utils'
+import { handleRemoveProduct } from './helpers/remove-product.utils'
+import { incrementProductQuantity } from './helpers/increment-product-quantity.utils'
 import {
   CREATE_SHOPPING_CARD_TO_USER_STORE,
   GET_ALL_COUNT_SALES
 } from './queries'
-import { updateExistingOrders } from '../useUpdateExistingOrders'
+import { SalesReducerAction, SalesState, ValuesState } from './types'
+import { UseSalesProps } from './types/use-sales.types'
+import { initializer } from './helpers/initializer.utils'
 import { useGetSale } from './useGetSale'
-import { useCatWithProduct } from './../useCatWithProduct/index'
-import { useLogout } from '../useLogout'
-import { filterProductsByCarProId, removeFunc } from './helpers'
-export * from './useGetAllSales'
-
-export { GET_ALL_COUNT_SALES } from './queries'
-
-export const initialState = {
-  PRODUCT: [],
-  totalPrice: 0,
-  sortBy: null,
-  itemsInCart: 0,
-  animateType: '',
-  startAnimateUp: '',
-  priceRange: 0,
-  counter: 0,
-  totalAmount: 0,
-  payMethodPState: 0
-}
 
-export const initializer = (initialValue = initialState) => {
-  return (
-    JSON.parse(
-      // @ts-ignore
-      Cookies.get(process.env.LOCAL_SALES_STORE) || JSON.stringify(initialState)
-    ) || initialValue
-  )
-}
 
 export const useSales = ({
   disabled = false,
   router,
   sendNotification = (args) => { return args },
   setAlertBox = (args) => { return args }
-}) => {
+}: UseSalesProps) => {
+  const keyToSaveData = String(process.env.NEXT_LOCAL_SALES_STORE)
+  const saveDataState = JSON.parse(Cookies.get(keyToSaveData) ?? '[]')
   const domain = getCurrentDomain()
   const [loadingSale, setLoadingSale] = useState(false)
   const [errorSale, setErrorSale] = useState(false)
   const [onClickLogout] = useLogout({})
-
   const [modalItem, setModalItem] = useState(false)
   const [openCommentModal, setOpenCommentModal] = useState(false)
-  const keyToSaveData = process.env.LOCAL_SALES_STORE
-  // @ts-ignore
-  const saveDataState = JSON.parse(Cookies.get(keyToSaveData) || '[]')
   const [search, setSearch] = useState('')
-  const [datCat] = useCatWithProduct({})
-  const [categories, setCategories] = useState([])
-  const [currentPage, setCurrentPage] = useState(1)
-  useEffect(() => {
-    setCategories(datCat)
-  }, [datCat])
-  const [totalProductPrice, setTotalProductPrice] = useState(0)
-  const [showMore, setShowMore] = useState(100)
-  const [inputValue, setInputValue] = useState('')
-  // eslint-disable-next-line no-unused-vars
+  const [categories, setCategories] = useState<CatProductWithProduct[]>([])
+
+  useCatWithProduct({
+    max: Infinity,
+    callback: (data: GetCatProductsWithProductResponse) => {
+      return setCategories(data.getCatProductsWithProduct?.catProductsWithProduct || [])
+    }
+  })
+  const [currentPage, setCurrentPage] = useState<number>(1)
+  const [totalProductPrice, setTotalProductPrice] = useState<number>(0)
+  const [showMore, setShowMore] = useState<number>(100)
+  const [inputValue, setInputValue] = useState<string>('')
+   
   const [_, setFilteredList] = useState([])
-  const [delivery, setDelivery] = useState(false)
-  const [print, setPrint] = useState(false)
+  const [delivery, setDelivery] = useState<boolean>(false)
+  const [print, setPrint] = useState<boolean>(false)
   const [errors, setErrors] = useState({})
-  const [values, setValues] = useState({
-    comment: '',
+
+  const initialValuesState: ValuesState = {
     change: '',
     cliId: '',
+    comment: '',
+    tableId: '',
     valueDelivery: ''
-  })
+  }
+  const [values, setValues] = useState<ValuesState>(initialValuesState)
+
   const [dataStore] = useStore()
-  const { createdAt } = dataStore || {}
+  const { createdAt, idStore } = dataStore ?? {
+    createdAt: null,
+    idStore: null
+  }
   const [code, setCode] = useState(null)
   const [openCurrentSale, setOpenCurrentSale] = useState(null)
   const [oneProductToComment, setOneProductToComment] = useState({})
   const [sumExtraProducts, setSumExtraProducts] = useState(0)
   const { yearMonthDay } = useFormatDate({ date: createdAt })
+  const [handleGetOneProduct] = useGetOneProductsFood()
   const [valuesDates, setValuesDates] = useState(() => {
     return { fromDate: yearMonthDay, toDate: '' }
   })
+
   const [product, setProduct] = useState({
-    PRODUCT: {}
+    PRODUCT: {
+      pId: null
+    }
   })
+
   const [loadingExtraProduct, setLoadingExtraProduct] = useState(false)
-  const [dataOptional, setDataOptional] = useState([])
-  const [dataExtra, setDataExtra] = useState([])
+  const [dataOptional, setDataOptional] = useState<any[]>([])
+  const [dataExtra, setDataExtra] = useState<any[]>([])
   const [registerSalesStore, { loading: loadingRegisterSale }] = useMutation(
     CREATE_SHOPPING_CARD_TO_USER_STORE,
     {
@@ -131,7 +134,7 @@ export const useSales = ({
       onError: (error) => {
         sendNotification({
           backgroundColor: 'error',
-          title: error ?? 'Lo sentimos',
+          title: typeof error === 'string' ? error : 'Lo sentimos',
           description: 'ha ocurrido un error'
         })
       }
@@ -170,42 +173,42 @@ export const useSales = ({
     max: showMore,
     min: 0,
     isShopppingCard: true,
+    idStore: idStore ?? '',
     dataSale: (Array.isArray(saveDataState?.PRODUCT) && saveDataState?.PRODUCT) ?? [],
-    callback: () => { return null }
+    callback: () => { return }
   })
 
-  const handlePageChange = (pageNumber) => {
+  const handlePageChange = (pageNumber: number) => {
     setCurrentPage(pageNumber)
     refetch({ page: pageNumber })
   }
 
-  const handleChangeCheck = (caId) => {
-    // @ts-ignore
+  /**
+   * Toggles the `checked` field of a category with maximum performance.
+   * @param {string} caId - Category ID to toggle.
+   */
+  const handleChangeCheck = (caId: string) => {
     setCategories((prev) => {
-      return prev.map((item) => {
-        // @ts-ignore
-        return item.carProId === caId
-          // @ts-ignore
-          ? { ...item, checked: !item?.checked }
-          : item
-      })
+      if (!prev || prev.length === 0) return prev
+
+      const index = prev.findIndex((item) => {return item.carProId === caId})
+      if (index === -1) return prev // nothing to update → no rerender
+
+      const target = prev[index]
+
+      const updatedItem = {
+        ...target,
+        checked: !target.checked
+      }
+
+      const newList = [...prev] // clone array ONCE
+      newList[index] = updatedItem
+
+      return newList
     })
   }
-  const max = productsFood?.reduce(function (a, b) {
-    return Math.max(a, b?.ProPrice || 0)
-  }, 0)
-  const initialStateSales = {
-    PRODUCT: [],
-    totalPrice: 0,
-    sortBy: null,
-    itemsInCart: 0,
-    animateType: '',
-    startAnimateUp: '',
-    priceRange: max || 0,
-    counter: 0,
-    totalAmount: 0,
-    payMethodPState: 0
-  }
+
+
   // HANDLESS
   // FILTER PRODUCT DATA_DB
   // @ts-ignore
@@ -219,40 +222,64 @@ export const useSales = ({
     }
     setPrint(!print)
   }
-  const handleChangeFilter = (e) => {
-    return setSearch(e.target.value)
+
+  const handleChangeFilter = (value: string): void => {
+    return setSearch(value)
   }
-  const handleChange = (e, error) => {
-    const { name, value } = e.target
-    setErrors({ ...errors, [e.target.name]: error })
-    setValues((prevValues) => ({
+
+  const handleChange = (
+    e: React.ChangeEvent<HTMLInputElement> | { target: { name: string; value: any } },
+    error: boolean
+  ) => {
+    const target: any = (e as any).target
+    const { name, value } = target
+    setErrors({ ...errors, [name]: error })
+    setValues((prevValues) => {return {
       ...prevValues,
       [name]: value
-    }))
+    }})
   }
-  const onChangeInput = (e) => {
+
+  const onChangeInput = (e: React.ChangeEvent<HTMLInputElement>) => {
     return setValuesDates({ ...valuesDates, [e.target.name]: e.target.value })
   }
-  const handleToggleEditingStatus = (state, action) => {
-    const { PRODUCT } = state ?? {
-      PRODUCT: []
+
+  /**
+   * Toggles editing state of a product with maximum performance.
+   * @param {any} state - Current reducer state.
+   * @param {any} action - Payload with product ID.
+   * @returns {any} New updated state.
+   */
+  const handleToggleEditingStatus = (state: any, action: any) => {
+    const pId = action?.payload?.pId
+    if (!pId) return state
+
+    const list = state.PRODUCT
+    const index = list.findIndex((item: any) => {return item.pId === pId})
+
+    // If no match, nothing changes → no re-render
+    if (index === -1) return state
+
+    const target = list[index]
+
+    const updatedItem = {
+      ...target,
+      editing: !target.editing,
+      oldQuantity: target.ProQuantity ?? 0
     }
+
+    // Clone the array only once
+    const newList = [...list]
+    newList[index] = updatedItem
+
     return {
       ...state,
-      PRODUCT: PRODUCT.map((item) => {
-        if (item.pId === action.payload.pId) {
-          return {
-            ...item,
-            editing: !item.editing,
-            oldQuantity: item.ProQuantity
-          }
-        }
-        return item
-      })
+      PRODUCT: newList
     }
   }
 
-  const handleChangeFilterProduct = (e) => {
+
+  const handleChangeFilterProduct = (e: React.ChangeEvent<HTMLInputElement>) => {
     const text = searchedInput(e.target.value)
     if (text === undefined || text === '') {
       return
@@ -260,7 +287,8 @@ export const useSales = ({
     const filteredData = handleList(text)
     setFilteredList(filteredData)
   }
-  const handleComment = (product) => {
+
+  const handleComment = (product: any) => {
     if (product) {
       setOneProductToComment(product)
       setValues({
@@ -270,31 +298,52 @@ export const useSales = ({
     }
     setOpenCommentModal(!openCommentModal)
   }
-  const handleSuccessUpdateQuantity = (state, payload) => {
-    const { pId } = payload.payload || {
-      pId: null
+
+  /**
+   * Updates a single product inside the PRODUCT array with maximum performance.
+   * @param {any} state - Current state.
+   * @param {any} payload - Action payload.
+   * @returns {any} New updated state.
+   */
+  const handleSuccessUpdateQuantity = (state: any, payload: any) => {
+    const pId = payload?.payload?.pId
+    if (!pId) return state
+
+    const list = state.PRODUCT
+    const index = list.findIndex((item: any) => {return item.pId === pId})
+
+    // If no match → no state changes → no rerender
+    if (index === -1) return state
+
+    const target = list[index]
+    const updatedItem = {
+      ...target,
+      editing: false,
+      oldQuantity: target.ProQuantity ?? 0
     }
+
+    // Clone array ONCE
+    const newList = [...list]
+    newList[index] = updatedItem
+    sendNotification({
+      title: 'Cantidad actualizada',
+      backgroundColor: 'success',
+      description: `La cantidad de ${target.pName} ha sido actualizada a ${updatedItem.ProQuantity}.`
+    })
     return {
       ...state,
-      PRODUCT: state?.PRODUCT?.map((items) => {
-        return items.pId === pId
-          ? {
-              ...items,
-              editing: false,
-              oldQuantity: items.ProQuantity
-            }
-          : items
-      })
+      PRODUCT: newList
     }
   }
 
+
   /**
- * Cancels the update of a product's quantity, resetting it to the previous value.
- * @param {Object} state - The current state.
- * @param {Object} payload - The payload containing the product ID.
- * @returns {Object} - The new state with the updated product quantity and editing status.
- */
-  const handleCancelUpdateQuantity = (state, payload) => {
+   * Cancels the update of a product's quantity, resetting it to the previous value.
+   * @param {Object} state - The current state.
+   * @param {Object} payload - The payload containing the product ID.
+   * @returns {Object} - The new state with the updated product quantity and editing status.
+   */
+  const handleCancelUpdateQuantity = (state: any, payload: any) => {
     // Validación de `state`
     if (!state || typeof state !== 'object') {
       sendNotification({
@@ -312,7 +361,7 @@ export const useSales = ({
         backgroundColor: 'error',
         description: 'Ha ocurrido un error al actualizar la cantidad del producto.'
       })
-      return state // Retorna el estado sin cambios si `PRODUCT` no es un array.
+      return state
     }
 
     // Validación de `payload`
@@ -328,7 +377,7 @@ export const useSales = ({
 
     return {
       ...state,
-      PRODUCT: state.PRODUCT.map((item) => {
+      PRODUCT: state.PRODUCT.map((item: any) => {
         // Validación de propiedades en cada item
         if (item.pId === pId) {
           if (typeof item.oldQuantity !== 'number' || typeof item.unitPrice !== 'number') {
@@ -353,97 +402,77 @@ export const useSales = ({
     }
   }
 
-  const handleChangeNumber = useCallback(
-    (state, action) => {
-      const event = action.payload
-      const { value, index, id } = event || {}
-
-      const productExist = productsFood?.find((items) => items.pId === id)
-      const OneProduct = state?.PRODUCT.find((items) => items.pId === id)
-
-      if (!productExist) return state // Validar si el producto existe
-
-      // Validar si el stock es 0
-      if (productExist.stock === 0) {
-        sendNotification({
-          title: 'Sin stock',
-          backgroundColor: 'warning',
-          description: `El producto ${OneProduct?.pName} está agotado y no puede ser modificado.`
-        })
-        return state
-      }
-
-      // Si el valor ingresado es menor o igual a 0, eliminar el producto del carrito
-      if (value <= 0) {
-        dispatch({ type: 'REMOVE_PRODUCT_TO_CART', payload: OneProduct })
-        return state
-      }
-
-      // Validar si se intenta superar el stock disponible
-      const finalQuantity = Math.min(value, productExist.stock)
-      if ((value > productExist.stock) && productExist.manageStock) {
-        sendNotification({
-          title: 'Stock insuficiente',
-          backgroundColor: 'warning',
-          description: `No puedes agregar más unidades de ${OneProduct?.pName}, stock disponible: ${productExist.stock}`
-        })
-      }
-
-      const ARR_PRODUCT = state?.PRODUCT?.map((items, i) =>
-        i === index
-          ? {
-              ...items,
-              ProQuantity: finalQuantity,
-              ProPrice: finalQuantity * productExist?.ProPrice
-            }
-          : items
-      )
-
-      return {
-        ...state,
-        PRODUCT: ARR_PRODUCT,
-        counter: state.counter + 1
-      }
-    },
-    [productsFood]
-  )
-
-  const paymentMethod = (state, action) => {
+  const paymentMethod = (state: any, action: any) => {
     return {
       ...state,
-      payMethodPState: action.payload
+      payId: action.payload
+    }
+  }
+
+
+  const handleAddProduct = async (product: any) => {
+    const pId = String(product?.pId)
+    const memo = productsFood.find((item: any) => {return String(item.pId) === pId})
+    if (!memo) {
+      const response = await handleGetOneProduct({ pId })
+      if (response.data?.productFoodsOne == null) {return sendNotification({
+        title: 'Error',
+        backgroundColor: 'error',
+        description: 'No se pudo obtener el producto'
+      })}
+      const productData = response.data?.productFoodsOne ?? { pId: null }
+      return dispatch({
+        type: SalesActionTypes.ADD_TO_CART,
+        payload: productData
+      })
     }
+    return dispatch({
+      type: SalesActionTypes.ADD_TO_CART,
+      payload: memo
+    })
   }
-  const PRODUCT = (state, action) => {
+
+  const PRODUCT = (state: any, action: any) => {
     switch (action.type) {
-      case 'ADD_TO_CART':
-        return addToCartFunc(state, action) // https://www.npmjs.com/package/@sourcetoad/vision-camera-plugin-barcode-scanner
-      case 'ADD_PRODUCT':
+      case SalesActionTypes.ADD_TO_CART:
+        return addToCartFunc({
+          state,
+          action,
+          product: action.payload,
+          sendAlertStock,
+          sendNotification
+        })
+      case SalesActionTypes.ADD_PRODUCT:
         return {
           ...state,
           // eslint-disable-next-line
           PRODUCT: [...state?.PRODUCT, action?.payload],
         }
-      case 'REMOVE_PRODUCT':
-        return removeFunc(state, action, productsFood)
-      case 'REMOVE_PRODUCT_TO_CART':
+      case SalesActionTypes.REMOVE_PRODUCT:
+        return handleRemoveProduct(state, action, productsFood)
+      case SalesActionTypes.REMOVE_PRODUCT_TO_CART:
         return {
           ...state,
-          PRODUCT: state?.PRODUCT?.filter((t) => {
+          PRODUCT: state?.PRODUCT?.filter((t: any) => {
             return t.pId !== action?.payload.pId
           }),
           counter: state.counter - action.payload.ProQuantity
         }
-      case 'ON_CHANGE': {
-        return handleChangeNumber(state, action)
+      case SalesActionTypes.ON_CHANGE: {
+        return handleChangeNumber(
+          state,
+          action,
+          productsFood,
+          sendNotification
+        )
       }
-      case 'UPDATE_SUCCESS_QUANTITY_EDITING_PRODUCT': {
+      case SalesActionTypes.UPDATE_SUCCESS_QUANTITY_EDITING_PRODUCT: {
         return handleSuccessUpdateQuantity(state, action)
       }
-      case 'CANCEL_UPDATE_QUANTITY_EDITING_PRODUCT': {
+      case SalesActionTypes.CANCEL_UPDATE_QUANTITY_EDITING_PRODUCT: {
         return handleCancelUpdateQuantity(state, action)
       }
-      case 'REMOVE_ALL_PRODUCTS':
+      case SalesActionTypes.REMOVE_ALL_PRODUCTS:
         // @ts-ignore
         setValues({
           ...values,
@@ -458,104 +487,75 @@ export const useSales = ({
           counter: 0
         }
 
-      case 'TOGGLE_FREE_PRODUCT':
+      case SalesActionTypes.TOGGLE_FREE_PRODUCT:
         return toggleFreeProducts(state, action)
-      case 'TOGGLE_EDITING_PRODUCT': {
+      case SalesActionTypes.TOGGLE_EDITING_PRODUCT: {
         return handleToggleEditingStatus(state, action)
       }
-      case 'INCREMENT': {
-        return {
-          ...state,
-          counter: state.counter + 1,
-          PRODUCT: state?.PRODUCT?.map((items) => {
-            if (items.pId === action.id) {
-              const OurProduct = productsFood?.find((item) => item.pId === action.id)
-              const isFree = items.free
-              const newQuantity = items.ProQuantity + 1
-              // Validar si el stock es 0
-              if (OurProduct?.stock === 0) {
-                sendNotification({
-                  title: 'Sin stock',
-                  backgroundColor: 'warning',
-                  description: `El producto ${items.pName} está agotado y no puede ser añadido al carrito.`
-                })
-                return items // Retornar sin modificar
-              }
-
-              // Validar si se supera el stock
-              console.log(OurProduct)
-              if (newQuantity >= OurProduct?.stock && OurProduct?.manageStock) {
-                sendNotification({
-                  title: 'Stock insuficiente',
-                  backgroundColor: 'warning',
-                  description: `No puedes agregar más unidades de ${items.pName}, stock disponible: ${OurProduct?.stock}`
-                })
-                return items // Retornar el producto sin modificar
-              }
-              return {
-                ...items,
-                ProQuantity: newQuantity,
-                ProPrice: isFree ? 0 : newQuantity * OurProduct?.ProPrice
-              }
-            }
-            return items
-          })
-        }
+      case SalesActionTypes.INCREMENT: {
+        return incrementProductQuantity({
+          state,
+          productId: action.id,
+          productsFood,
+          sendNotification
+        })
       }
 
-      case 'PUT_COMMENT':
+      case SalesActionTypes.PUT_COMMENT:
         return commentProducts(state, action)
-      case 'PUT_EXTRA_PRODUCTS_AND_OPTIONAL_PRODUCT':
+      case SalesActionTypes.PUT_EXTRA_PRODUCTS_AND_OPTIONAL_PRODUCT:
         return handleUpdateAllExtraAndOptional(state, action)
-      case 'PRICE_RANGE':
+      case SalesActionTypes.PRICE_RANGE:
         return {
           ...state,
           priceRange: action.payload
         }
-      case 'SORT':
+      case SalesActionTypes.SORT:
         return { ...state, sortBy: action.payload }
-      case 'DECREMENT':
+      case SalesActionTypes.DECREMENT:
         return {
           ...state
         }
-      case 'PAYMENT_METHOD': return paymentMethod(state, action)
+      case SalesActionTypes.PAYMENT_METHOD: return paymentMethod(state, action)
 
+      case SalesActionTypes.APPLY_DISCOUNT: {
+        return applyDiscountToCart(
+          state,
+          action.payload,
+          sendNotification
+        )
+      }
       default:
         return state
     }
   }
-  const [data, dispatch] = useReducer(PRODUCT, initialStateSales, initializer)
 
-  const handleRemoveValue = useCallback(({ name, value, pId }) => {
+  const [data, dispatch] = useReducer<React.Reducer<SalesState, SalesReducerAction>, SalesState>(PRODUCT, initialStateSales, initializer)
+
+  const handleRemoveValue = useCallback(({ name, value, pId }: { name: string; value: string | null; pId: string }) => {
     setValues({
       ...values,
       [name]: value ?? ''
     })
     sendNotification({
-      backgroundColor: 'sucess',
+      backgroundColor: 'success',
       title: 'Comentario eliminado',
       description: 'Has eliminado el comentario!'
     })
     // @ts-ignore
     return dispatch({
-      type: 'PUT_COMMENT',
+      type: SalesActionTypes.PUT_COMMENT,
       payload: pId,
       value: ''
     })
   }, [])
-  useEffect(() => {
-    // @ts-ignore
-    Cookies.set(keyToSaveData, JSON.stringify(data), { domain, path: '/' })
-  }, [data, domain])
 
   const handleAddOptional = ({ exOptional = null, codeCategory = null }) => {
     if (!exOptional || !codeCategory) return
-    // @ts-ignore
-    const item = dataOptional.find((item) => item.code === codeCategory)
+    const item = dataOptional.find((item) => {return item.code === codeCategory})
     if (!item) return
-    // @ts-ignore
     const idx = item.ExtProductFoodsSubOptionalAll.findIndex(
-      (el) => el.opSubExPid === exOptional
+      (el: any) => {return el.opSubExPid === exOptional}
     )
     if (item && idx !== -1) {
       const updatedItem = {
@@ -575,24 +575,29 @@ export const useSales = ({
         ]
       }
       const newData = dataOptional.map((el) =>
-        // @ts-ignore
-        el.code === codeCategory ? updatedItem : el
+      // @ts-ignore
+      {return el.code === codeCategory ? updatedItem : el}
       )
       // @ts-ignore
-      setDataOptional(() => [...newData])
+      setDataOptional(() => {return [...newData]})
     }
   }
 
-  function handleUpdateAllExtraAndOptional (state, action) {
+  /**
+   *
+   * @param state
+   * @param action
+   */
+  function handleUpdateAllExtraAndOptional(state: any, action: any) {
     return {
       ...state,
-      PRODUCT: state?.PRODUCT?.map((items) => {
+      PRODUCT: state?.PRODUCT?.map((items: any) => {
         return items.pId === action.payload
           ? {
-              ...items,
-              dataOptional: action.dataOptional || [],
-              dataExtra: action.dataExtra || []
-            }
+            ...items,
+            dataOptional: action.dataOptional || [],
+            dataExtra: action.dataExtra || []
+          }
           : items
       })
     }
@@ -610,13 +615,16 @@ export const useSales = ({
           return p.quantity !== 0
         })
         : []
-    const val = arr.findIndex((item) => item.quantity !== 0)
+    const val = arr.findIndex((item: any) => {return item.quantity !== 0})
     if (val === -1) {
       setSumExtraProducts(0)
     }
-    function sumNewExtraPrice () {
+    /**
+     *
+     */
+    function sumNewExtraPrice() {
       let sum = 0
-      arr.forEach((obj) => {
+      arr.forEach((obj: any) => {
         sum += obj.newExtraPrice ?? 0
       })
       if (arr.length === 0) {
@@ -630,7 +638,10 @@ export const useSales = ({
     }
   }, [dataExtra])
 
-  function handleUpdateAllExtra () {
+  /**
+   *
+   */
+  function handleUpdateAllExtra() {
     try {
       if (!product?.PRODUCT?.pId) {
         return sendNotification({
@@ -643,7 +654,7 @@ export const useSales = ({
         .map((obj) => {
           // @ts-ignore
           const filteredSubOptions = obj?.ExtProductFoodsSubOptionalAll?.filter(
-            (subObj) => subObj?.check === true
+            (subObj: any) => {return subObj?.check === true}
           )
           // Excluya todo el objeto padre si filteredSubOptions está vacío
           if (filteredSubOptions?.length === 0) {
@@ -652,13 +663,13 @@ export const useSales = ({
           // @ts-ignore
           return { ...obj, ExtProductFoodsSubOptionalAll: filteredSubOptions }
         })
-        .filter((obj) => obj !== null) // Elimine todos los objetos nulos del arreglo
+        .filter((obj) => {return obj !== null}) // Elimine todos los objetos nulos del arreglo
       // @ts-ignore
-      const filteredDataExtra = dataExtra?.filter((p) => p?.quantity !== undefined && p?.quantity !== 0)
+      const filteredDataExtra = dataExtra?.filter((p) => {return p?.quantity !== undefined && p?.quantity !== 0})
       if (product?.PRODUCT?.pId) {
         // @ts-ignore
         dispatch({
-          type: 'PUT_EXTRA_PRODUCTS_AND_OPTIONAL_PRODUCT',
+          type: SalesActionTypes.PUT_EXTRA_PRODUCTS_AND_OPTIONAL_PRODUCT,
           payload: product.PRODUCT.pId,
           dataOptional: filteredDataOptional,
           dataExtra: filteredDataExtra
@@ -684,7 +695,13 @@ export const useSales = ({
   }
 
   // @ts-ignore
-  function handleIncrementExtra ({ Adicionales, index }) {
+  /**
+   *
+   * @param root0
+   * @param root0.Adicionales
+   * @param root0.index
+   */
+  function handleIncrementExtra({ Adicionales, index }) {
     const { pId } = product?.PRODUCT || {}
     const exPid = Adicionales?.exPid || null
 
@@ -712,54 +729,18 @@ export const useSales = ({
       setDataExtra(newExtra)
     }
   }
-
-  // @ts-ignore
-  function handleDecrementExtra ({ Adicionales, index }) {
-    const { pId } = product?.PRODUCT || {}
-    const exPid = Adicionales?.exPid || null
-
-    // Comprobar que el objeto Adicionales existe en dataExtra
-    // @ts-ignore
-    const extraIndex = dataExtra.findIndex((extra) => extra.exPid === exPid)
-    if (extraIndex === -1) {
-      return
-    }
-
-    if (pId && exPid && extraIndex !== -1) {
-      // @ts-ignore
-      const newExtra = dataExtra.map((producto, i) => {
-        // @ts-ignore
-        if (exPid === producto.exPid) {
-          // Desestructura la cantidad y el precio extra del producto o establece valores predeterminados
-          const { quantity = 0, extraPrice = 0 } = producto
-
-          // Calcula la nueva cantidad, evitando que sea negativa
-          const newQuantity = Math.max(quantity - 1, 0)
-
-          // Calcula el nuevo precio extra
-          const newExtraPrice = newQuantity === 0 ? extraPrice : extraPrice * newQuantity
-
-          return {
-            // @ts-ignore
-            ...producto,
-            quantity: newQuantity,
-            newExtraPrice
-          }
-        }
-        return producto
-      })
-
-      // Actualiza el estado de dataExtra con el nuevo array
-      // @ts-ignore
-      setDataExtra(newExtra)
-    }
+  const handleDecrementExtra = ({ Adicionales }: { Adicionales: any }) => {
+    const exPid = Adicionales?.exPid
+    if (!exPid) return
+    setDataExtra((prev) => {return decrementExtra(prev as any, exPid)})
   }
 
-  function isStockInsufficient (currentQuantity, stock) {
-    return currentQuantity >= stock
-  }
 
-  function sendAlertStock (stock) {
+  /**
+   *
+   * @param stock
+   */
+  function sendAlertStock(stock: number) {
     return sendNotification({
       title: 'Stock insuficiente',
       backgroundColor: 'warning',
@@ -767,103 +748,58 @@ export const useSales = ({
     })
   }
 
-  function addToCartFunc (state, action) {
-    const {
-      pId,
-      pName,
-      getOneTags,
-      stock,
-      ProDescription,
-      ProImage,
-      ProPrice
-    } = action.payload ?? {}
-    if (stock === 0) {
-      sendNotification({
-        title: 'Sin stock',
-        backgroundColor: 'warning',
-        description: 'Producto sin stock disponible  en tu inventario'
-      })
-      return state
+  /**
+   * Toggles free mode for a product and recalculates its price
+   * with maximum performance.
+   * @param {any} state - Current reducer state.
+   * @param {any} action - Payload containing pId.
+   * @returns {any} Updated state.
+   */
+  function toggleFreeProducts(state: any, action: any) {
+    const pId = action?.payload?.pId
+    if (!pId) return state
+
+    // Find the reference product price only once
+    const referenceProduct = productsFood.find((item: any) => {return item.pId === pId})
+    if (!referenceProduct) return state
+
+    const list = state.PRODUCT
+    const index = list.findIndex((item: any) => {return item.pId === pId})
+
+    // If no match, skip re-render
+    if (index === -1) return state
+
+    const target = list[index]
+
+    const newFreeState = !target.free
+
+    const updatedItem = {
+      ...target,
+      free: newFreeState,
+      ProPrice: newFreeState
+        ? 0
+        : (target.ProQuantity ?? 1) * (referenceProduct.ProPrice ?? 0)
     }
 
-    const productExist = state?.PRODUCT.find((item) => item.pId === pId)
-    const OurProduct = productsFood?.find((item) => item.pId === pId)
-    const isFree = productExist?.free
-    const currentQuantity = productExist?.ProQuantity || 0
-
-    if (OurProduct?.manageStock && isStockInsufficient(currentQuantity, OurProduct?.stock)) {
-      sendAlertStock(stock)
-      return state
-    }
-    const updatedProduct = {
-      pId,
-      pName,
-      editing: false,
-      getOneTags,
-      unitPrice: OurProduct?.ProPrice,
-      manageStock: OurProduct?.manageStock ?? false,
-      ProDescription,
-      ProImage,
-      ProPrice,
-      stock,
-      ProQuantity: 1
-    }
+    // Clone array ONCE
+    const newList = [...list]
+    newList[index] = updatedItem
 
-    if (!productExist) {
-      return {
-        ...state,
-        counter: state.counter + 1,
-        totalAmount: state.totalAmount + ProPrice,
-        startAnimateUp: 'start-animate-up',
-        PRODUCT: [...state.PRODUCT, updatedProduct]
-      }
-    }
     return {
       ...state,
-      counter: state.counter + 1,
-      totalAmount: state.totalAmount + ProPrice,
-      startAnimateUp: 'start-animate-up',
-      PRODUCT: state.PRODUCT.map((item) => {
-        if (item.pId === pId) {
-          return {
-            ...item,
-            getOneTags: OurProduct?.genderTags,
-            unitPrice: OurProduct?.ProPrice,
-            editing: false,
-            oldQuantity: productExist.ProQuantity + +1,
-            ProPrice: isFree ? 0 : (productExist.ProQuantity + 1) * OurProduct?.ProPrice,
-            ProQuantity: productExist.ProQuantity + +1,
-            free: !!isFree
-          }
-        }
-        return item
-      })
+      PRODUCT: newList
     }
   }
 
-  // TOGGLE_FREE_PRODUCT
-  function toggleFreeProducts (state, action) {
-    const productExist = productsFood.find((items) => {
-      return items.pId === action.payload.pId
-    })
-    return {
-      ...state,
-      PRODUCT: state?.PRODUCT?.map((items) => {
-        return items.pId === action.payload.pId
-          ? {
-              ...items,
-              free: !items.free,
-              ProPrice: items.ProPrice
-                ? 0
-                : items.ProQuantity * productExist?.ProPrice
-            }
-          : items
-      })
-    }
-  }
 
   // COMMENT_FREE_PRODUCT
-  function commentProducts (state, action, deleteValue) {
+  /**
+   *
+   * @param state
+   * @param action
+   * @param deleteValue
+   */
+  function commentProducts(state: any, action: any, deleteValue = false) {
     if (values.comment) {
       sendNotification({
         backgroundColor: 'success',
@@ -874,18 +810,18 @@ export const useSales = ({
     setOpenCommentModal(!openCommentModal)
     return {
       ...state,
-      PRODUCT: state?.PRODUCT?.map((items) => {
+      PRODUCT: state?.PRODUCT?.map((items: any) => {
         return items.pId === action.payload
           ? {
-              ...items,
-              comment: deleteValue ? '' : values.comment
-            }
+            ...items,
+            comment: deleteValue ? '' : values.comment
+          }
           : items
       })
     }
   }
 
-  const getSortedProduct = useCallback((data, sort) => {
+  const getSortedProduct = useCallback((data: any[], sort: string | null) => {
     if (sort && sort === 'PRICE_HIGH_TO_LOW') {
       return data.sort((a, b) => {
         return b.ProPrice - a.ProPrice
@@ -899,7 +835,7 @@ export const useSales = ({
     return data
   }, [])
 
-  const PriceRangeFunc = (products, price) => {
+  const PriceRangeFunc = (products: any[], price: number) => {
     return (
       products?.length > 0 &&
       products?.filter((items) => {
@@ -914,7 +850,7 @@ export const useSales = ({
 
   const finalFilter = PriceRangeFunc(sortedProduct, data.priceRange)
 
-  const handleList = (text) => {
+  const handleList = (text: string) => {
     const inputText = text.toLowerCase()
     let dataList = []
     dataList = finalFilter.filter((item) => {
@@ -922,7 +858,8 @@ export const useSales = ({
     })
     return dataList
   }
-  const searchedInput = (words) => {
+
+  const searchedInput = (words: string) => {
     setInputValue(words)
     const n = words.split(' ')
     if (n.length !== 0) {
@@ -933,51 +870,42 @@ export const useSales = ({
     }
     return ''
   }
-  const arrayProduct = data?.PRODUCT?.length > 0
-    ? data?.PRODUCT?.map((product) => {
-      const filteredDataExtra =
-        product?.dataExtra?.map(({ __typename, ...rest }) => rest) ?? []
-      const dataOptional = product?.dataOptional?.map(
-        ({ __typename, ...product }) => {
-          const { ExtProductFoodsSubOptionalAll, ...rest } = product
-          const adjustedSubOptionalAll = ExtProductFoodsSubOptionalAll?.map(
-            (subOption) => {
-              const { __typename, ...subOptionRest } = subOption
-              return subOptionRest
-            }
-          )
-          return {
-            ...rest,
-            ExtProductFoodsSubOptionalAll: adjustedSubOptionalAll
-          }
-        }
-      )
-      const refCodePid = RandomCode(20)
-      const shoppingCartRefCode = RandomCode(36)
+
+  const arrayProduct = useMemo(() => {
+    if (!Array.isArray(data.PRODUCT) || data.PRODUCT.length === 0) return []
+    return data.PRODUCT.map((product: any) => {
+      const filteredDataExtra = (product?.dataExtra ?? []).map(({ __typename, ...rest }) => {return rest})
+      const dataOptional = (product?.dataOptional ?? []).map(({ __typename, ...rest }) => {
+        const { ExtProductFoodsSubOptionalAll, ...r } = rest
+        const adjusted = (ExtProductFoodsSubOptionalAll ?? []).map(({ __typename, ...s }) => {return s})
+        return { ...r, ExtProductFoodsSubOptionalAll: adjusted }
+      })
       return {
-        pId: product?.pId,
-        refCodePid,
+        pId: product.pId,
+        refCodePid: RandomCode(20),
         id: values?.cliId,
-        cantProducts: parseInt(
-          product?.ProQuantity ? product?.ProQuantity : 0
-        ),
+        cantProducts: parseInt(String(product?.ProQuantity ?? 0)),
         comments: product?.comment ?? '',
         dataOptional: dataOptional ?? [],
-        dataExtra: filteredDataExtra || [],
+        dataExtra: filteredDataExtra,
         ProPrice: product.ProPrice
       }
     })
-    : []
-  const finalArrayProduct = arrayProduct.map((item) => {
-    const totalExtra = item.dataExtra.reduce(
-      (accumulator, extra) => accumulator + extra.newExtraPrice,
-      0
-    )
-    return { ...item, totalExtra }
-  })
+  }, [data.PRODUCT, values?.cliId])
+
+  const finalArrayProduct = useMemo(() => {
+    return arrayProduct.map((item: any) => {
+      const totalExtra = (item.dataExtra ?? []).reduce((acc: number, ex: any) => {return acc + (Number(ex.newExtraPrice) || 0)}, 0)
+      return { ...item, totalExtra }
+    })
+  }, [arrayProduct])
 
   let totalSale = 0
-  function sumProPriceAndTotalExtra (data) {
+  /**
+   *
+   * @param data
+   */
+  function sumProPriceAndTotalExtra(data) {
     return data.map((item) => {
       const totalExtra = item.dataExtra.reduce((acc, curr) => {
         const newExtraPrice = parseFloat(curr.newExtraPrice)
@@ -1002,33 +930,9 @@ export const useSales = ({
     }
   }, [totalProductPrice, totalSale, data, finalArrayProduct])
 
-  const [discount, setDiscount] = useState({
-    price: totalProductPrice || 0,
-    discount: 0
-  })
-
-  function applyDiscount (percentage) {
-    const validateCondition =
-      isNaN(percentage) || percentage < 0 || percentage > 100
-
-    if (validateCondition) {
-      return sendNotification({
-        title: 'Error',
-        backgroundColor: 'error',
-        description: 'el descuento debe ser un número entre 0 y 100%'
-      })
-    }
-    const decimal = parseFloat(percentage) / 100
-    // @ts-ignore
-    const result = decimal * parseFloat(totalProductPrice)
-    setDiscount({ price: result, discount: percentage })
-
-    return { price: result, discount: percentage }
-  }
-  const totalProductsPrice = totalProductPrice
   const client = useApolloClient()
   const { getOneSalesStore } = useGetSale()
-
+  console.log(data)
   const handleSubmit = () => {
     // @ts-ignore
     if (errors?.change || errors?.valueDelivery) {
@@ -1039,10 +943,39 @@ export const useSales = ({
       })
     }
     setLoadingSale(true)
-    const code = RandomCode(10)
+    const {
+      code,
+      success,
+      error
+    } = generateTicket({
+      length: 8,
+      strategy: 'numeric',
+      prefix: 'T-',
+      timestamp: true
+    })
+    if (error) {
+      setLoadingSale(false)
+      return sendNotification({
+        title: 'error',
+        backgroundColor: 'error',
+        description: 'Lo sentimos, ocurrió un error'
+      })
+    }
+    if (!success) {
+      setLoadingSale(false)
+      return sendNotification({
+        title: 'error',
+        backgroundColor: 'error',
+        description: 'Lo sentimos, ocurrió un error'
+      })
+    }
     // @ts-ignore
     setCode(code)
-    function convertInteger (cadena) {
+    /**
+     *
+     * @param cadena
+     */
+    function convertInteger(cadena: string | number) {
       if (typeof cadena === 'string') {
         const numeroEntero = parseInt(cadena?.replace('.', ''))
         return numeroEntero
@@ -1062,7 +995,7 @@ export const useSales = ({
 
     const shoppingCartRefCode = `REF-${RandomCode(36)}`
 
-    const input = finalArrayProduct.map((item) => {
+    const input = finalArrayProduct.map((item: any) => {
       return {
         ...item,
         shoppingCartRefCode
@@ -1076,16 +1009,19 @@ export const useSales = ({
         tableId,
         change: convertInteger(change),
         valueDelivery: convertInteger(valueDelivery),
-        payMethodPState: data.payMethodPState,
+        payId: data.payId,
         pickUp: 1,
         shoppingCartRefCode,
-        discount: discount.discount ?? 0,
+        discount: {
+          type: String(data.discountType),
+          value: 2
+        },
         totalProductsPrice: convertInteger(totalProductsPrice) || 0
       },
-      update (cache) {
+      update(cache) {
         cache.modify({
           fields: {
-            productFoodsAll (existingProductFoodsAll = []) {
+            productFoodsAll(existingProductFoodsAll = []) {
               return existingProductFoodsAll
             }
           }
@@ -1107,17 +1043,17 @@ export const useSales = ({
                 client.writeQuery({ query: GET_ALL_COUNT_SALES, data: { getTodaySales: data.countSales.todaySales } })
               }
             })
-            setValues({})
-            handleChange({ target: { name: 'tableId', value: '' } })
+            setValues(initialValuesState)
+            handleChange({ target: { name: 'tableId', value: '' } }, false)
             getOneSalesStore({
               variables: {
                 pCodeRef: code || ''
               }
-            }).then((responseSale) => {
+            }).then((responseSale: any) => {
               if (responseSale?.data?.getOneSalesStore) {
                 const currentSale = responseSale?.data?.getOneSalesStore || {}
                 const inComingCodeRef = currentSale?.pCodeRef || null
-                if (!inComingCodeRef) return
+                if (!inComingCodeRef) return null
                 // client.cache.modify({
                 //   fields: {
                 //     getAllOrdersFromStore (existingOrders = []) {
@@ -1162,11 +1098,11 @@ export const useSales = ({
       })
   }
 
-  const handleProduct = async (PRODUCT) => {
+  const handleProduct = async (PRODUCT: any) => {
     setLoadingExtraProduct(true)
     const { pId } = PRODUCT || {}
     try {
-      const originalArray = data.PRODUCT.find((item) => {
+      const originalArray = data.PRODUCT.find((item: any) => {
         return item.pId === pId
       })
       // OPTIONAL
@@ -1179,10 +1115,10 @@ export const useSales = ({
       const existOptionalCookies = originalArray?.dataOptional
       const filteredDataOptional = existOptionalCookies?.length
         ? existOptionalCookies
-          ?.map((obj) => {
+          ?.map((obj: any) => {
             const filteredSubOptions =
               obj.ExtProductFoodsSubOptionalAll.filter(
-                (subObj) => subObj.check === true
+                (subObj: any) => {return subObj.check === true}
               )
             // Excluya todo el objeto padre si filteredSubOptions está vacío
             if (filteredSubOptions.length === 0) {
@@ -1193,15 +1129,15 @@ export const useSales = ({
               ExtProductFoodsSubOptionalAll: filteredSubOptions
             }
           })
-          .filter((obj) => obj !== null)
+          .filter((obj: any) => {return obj !== null})
         : []
 
       // Actualizar optionalAll.data.ExtProductFoodsSubOptionalAll con los valores actualizados de originalArray2.ExtProductFoodsSubOptionalAll
       if (optionalFetch && filteredDataOptional) {
         const updateOption = optionalFetch
-          .map((obj) => {
+          .map((obj: any) => {
             const matchingArray = filteredDataOptional.find(
-              (o) => o && o.opExPid === obj.opExPid
+              (o: any) => {return o && o.opExPid === obj.opExPid}
             )
             if (!matchingArray) {
               return obj
@@ -1209,11 +1145,11 @@ export const useSales = ({
             const extProductFoodsSubOptionalAll =
               obj.ExtProductFoodsSubOptionalAll || []
             const updateExtProductSubOptionalAll =
-              extProductFoodsSubOptionalAll.map((subObj) => {
+              extProductFoodsSubOptionalAll.map((subObj: any) => {
                 const newItem =
                   matchingArray.ExtProductFoodsSubOptionalAll.find(
-                    (newItem) =>
-                      newItem && newItem.opSubExPid === subObj.opSubExPid
+                    (newItem: any) =>
+                    {return newItem && newItem.opSubExPid === subObj.opSubExPid}
                   )
                 if (newItem) {
                   return {
@@ -1229,7 +1165,7 @@ export const useSales = ({
                 updateExtProductSubOptionalAll
             }
           })
-          .filter((obj) => obj)
+          .filter((obj: any) => {return obj})
         if (existOptionalCookies) {
           setDataOptional(updateOption || [])
         } else {
@@ -1242,17 +1178,17 @@ export const useSales = ({
       if (!originalArray?.dataExtra) {
         finalData = extProduct?.data?.ExtProductFoodsAll
       } else {
-        const filteredData = originalArray.dataExtra.filter((item) =>
-          extProduct?.data?.ExtProductFoodsAll.some(
-            (newItem) => newItem.exPid === item.exPid
-          )
+        const filteredData = originalArray.dataExtra.filter((item: any) =>
+        {return extProduct?.data?.ExtProductFoodsAll.some(
+          (newItem: any) => {return newItem.exPid === item.exPid}
+        )}
         )
         finalData = originalArray?.dataExtra?.concat(
           extProduct?.data?.ExtProductFoodsAll?.filter(
-            (item) =>
-              !filteredData?.some(
-                (filteredItem) => filteredItem.exPid === item.exPid
-              )
+            (item: any) =>
+            {return !filteredData?.some(
+              (filteredItem: any) => {return filteredItem.exPid === item.exPid}
+            )}
           )
         )
       }
@@ -1265,32 +1201,35 @@ export const useSales = ({
       setLoadingExtraProduct(false)
     } catch (error) {
       setLoadingExtraProduct(false)
-      sendNotification({
-        title: 'error',
-        backgroundColor: 'error',
-        description: error || 'Lo sentimos, ocurrió un error'
-      })
+      if (error instanceof Error) {
+        return sendNotification({
+          title: 'error',
+          backgroundColor: 'error',
+          description: error.message ?? 'Lo sentimos, ocurrió un error'
+        })
+      }
     }
   }
-  const handleCleanFilter = () => {
-    // @ts-ignore
-    setValues({})
+
+  const handleCleanFilter = (): null => {
+    setValues(initialValuesState)
     setValuesDates({ fromDate: yearMonthDay, toDate: '' })
+    return null
   }
 
   const disabledModalItems = (dataOptional?.length > 0 || dataExtra?.length > 0) && !loadingExtProductFoodsSubOptionalAll
 
   /**
-* Filter objects with checked property equal to true.
-* @param {Array} products - Array of objects.
-* @returns {Array} - Array of objects with checked property equal to true.
-*/
-  function filterChecked (products) {
+   * Filter objects with checked property equal to true.
+   * @param {Array} products - Array of objects.
+   * @returns {Array} - Array of objects with checked property equal to true.
+   */
+  function filterChecked(products: any[]) {
     if (!Array.isArray(products)) {
       return []
     }
 
-    return products.filter(product => product?.checked === true).map(product => product.carProId)
+    return products.filter(product => {return product?.checked === true})?.map(product => {return product?.carProId})
   }
 
   // Obtener los carProIds de productos con checked en true
@@ -1300,15 +1239,113 @@ export const useSales = ({
   const filteredProducts = filterProductsByCarProId(productsFood, carProIds)
 
   const allProducts = useMemo(() => {
-    const productMap = new Map(data.PRODUCT.map(item => [String(item.pId), item.ProQuantity || 0]))
+    const productMap = new Map(data?.PRODUCT?.map((item: any) => {return [String(item.pId), item.ProQuantity || 0]}))
 
-    return filteredProducts.map(product => ({
+    return filteredProducts.map(product => {return {
       ...product,
       existsInSale: productMap.has(String(product.pId)),
       ProQuantity: productMap.get(String(product.pId)) || 0
-    }))
+    }})
   }, [data.PRODUCT, filteredProducts])
 
+  const totalProductsPrice = useMemo(() => { return finalArrayProduct.reduce((acc: number, item: any) => {return acc + (Number(item.ProPrice) || 0) + (Number(item.totalExtra) || 0)}, 0) }, [finalArrayProduct])
+
+  const handleAddAllProductsToCart = () => {
+    for (const product of allProducts) {
+      const existsInCart = data.PRODUCT.some((item: any) => {return item.pId === product.pId})
+      if (!existsInCart) {
+        dispatch({ type: SalesActionTypes.ADD_TO_CART, payload: product })
+      } else {
+        dispatch({ type: SalesActionTypes.INCREMENT, id: product.pId })
+      }
+    }
+  }
+
+  /**
+   * handleChangeNumber
+   * Updates product quantity from input change with full validations.
+   * @param {any} state - Current reducer state
+   * @param {any} action - Action with payload { value, index, id }
+   * @param {any[]} productsFood - Products memory source
+   * @param {(n:{title:string,backgroundColor:string,description?:string})=>void} sendNotification
+   * @param {(a:any)=>void} dispatch
+   * @returns {any} Updated state
+   */
+  function handleChangeNumber(
+    state: any,
+    action: any,
+    productsFood: any[] = [],
+    sendNotification: Function
+  ) {
+    const event = action?.payload ?? {}
+    const { value, index, id } = event
+
+    if (!id || index === undefined) return state
+
+    const productExist = productsFood.find((item: any) => {return item.pId === id})
+    const oneProduct = state?.PRODUCT?.find((item: any) => {return item.pId === id})
+
+    // Product not found
+    if (!productExist || !oneProduct) return state
+
+    // No stock
+    if (productExist.stock === 0) {
+      sendNotification({
+        title: 'Sin stock',
+        backgroundColor: 'warning',
+        description: 'Producto sin stock disponible'
+      })
+      return state
+    }
+
+    // Remove product if quantity <= 0
+    if (value <= 0) {
+      sendNotification({
+        title: 'Producto eliminado',
+        backgroundColor: 'info',
+        description: `Has eliminado ${oneProduct.pName} del carrito.`
+      })
+      return {
+        ...state,
+        PRODUCT: state.PRODUCT.filter((t: any) => {return t.pId !== id}),
+        counter: (state.counter ?? 0) - (oneProduct.ProQuantity || 0)
+      }
+    }
+
+    const safeValue = Number(value) || 0
+    const maxStock = productExist.manageStock ? productExist.stock : safeValue
+    const finalQuantity = Math.min(safeValue, maxStock)
+
+    // Stock exceeded
+    if (safeValue > productExist.stock && productExist.manageStock) {
+      sendNotification({
+        title: 'Stock insuficiente',
+        backgroundColor: 'warning',
+        description: `No puedes agregar más unidades de ${oneProduct.pName}. Stock disponible: ${productExist.stock}`
+      })
+    }
+
+    const updatedProducts = state.PRODUCT.map((item: any, i: number) =>
+    {return i === index
+      ? {
+        ...item,
+        ProQuantity: finalQuantity,
+        ProPrice: finalQuantity * (productExist.ProPrice ?? 0)
+      }
+      : item}
+    )
+
+    return {
+      ...state,
+      PRODUCT: updatedProducts,
+      counter: (state.counter ?? 0) + 1
+    }
+  }
+
+  useEffect(() => {
+    Cookies.set(keyToSaveData, JSON.stringify(data), { domain, path: '/' })
+  }, [data, domain])
+
   return {
     loading: loading || loadingSale,
     loadingExtraProduct,
@@ -1329,7 +1366,6 @@ export const useSales = ({
     print,
     finalFilter,
     showMore,
-    max,
     search,
     values,
     initialStateSales,
@@ -1342,13 +1378,14 @@ export const useSales = ({
     dataExtra: dataExtra || [],
     fetchMore,
     pagination,
-    discount,
+    discount: 0,
     datCat: categories,
     currentPage,
     loadingProduct: loading,
     handleChangeCheck,
     errors,
     handleUpdateAllExtra,
+    handleAddAllProductsToCart,
     dispatch,
     handlePageChange,
     handleComment,
@@ -1359,8 +1396,8 @@ export const useSales = ({
     setOpenCurrentSale,
     setErrors,
     onChangeInput,
+    handleAddProduct,
     handleRemoveValue,
-    applyDiscount,
     setDelivery,
     setValues,
     setShowMore,