npm-pkg-hook 1.3.9 → 1.4.0

package/src/hooks/useSales/helpers/comment-product.utils.ts

@@ -0,0 +1,41 @@
+/**
+ * Adds or removes a comment from a product in cart.
+ * - Pure function (reducer-safe)
+ * - Supports delete mode
+ * - Avoids unnecessary re-renders
+ *
+ * @param {Object} params
+ * @param {Object} params.state - Current reducer state
+ * @param {string | number} params.productId - Product identifier
+ * @param {string} params.comment - Comment text
+ * @param {boolean} params.deleteValue - If true, removes the comment
+ *
+ * @returns {Object} Updated state
+ */
+export const commentProduct = ({
+  state,
+  productId,
+  comment = '',
+  deleteValue = false
+}: {
+  state: any;
+  productId: string | number;
+  comment?: string;
+  deleteValue?: boolean;
+}) => {
+  if (!productId) return state
+
+  const PRODUCT = state.PRODUCT.map((item: any) =>
+  {return item.pId === productId
+    ? {
+      ...item,
+      comment: deleteValue ? '' : comment
+    }
+    : item}
+  )
+
+  return {
+    ...state,
+    PRODUCT
+  }
+}

package/src/hooks/useSales/helpers/constants/index.ts

@@ -0,0 +1,38 @@
+import { SalesState } from '../../types'
+import { TypeDiscount } from '../apply-discount-to-cart.utils'
+
+export enum SalesActionTypes {
+    ADD_TO_CART = 'ADD_TO_CART',
+    ADD_PRODUCT = 'ADD_PRODUCT',
+    REMOVE_PRODUCT = 'REMOVE_PRODUCT',
+    REMOVE_PRODUCT_TO_CART = 'REMOVE_PRODUCT_TO_CART',
+    ON_CHANGE = 'ON_CHANGE',
+    UPDATE_SUCCESS_QUANTITY_EDITING_PRODUCT = 'UPDATE_SUCCESS_QUANTITY_EDITING_PRODUCT',
+    CANCEL_UPDATE_QUANTITY_EDITING_PRODUCT = 'CANCEL_UPDATE_QUANTITY_EDITING_PRODUCT',
+    REMOVE_ALL_PRODUCTS = 'REMOVE_ALL_PRODUCTS',
+    TOGGLE_FREE_PRODUCT = 'TOGGLE_FREE_PRODUCT',
+    TOGGLE_EDITING_PRODUCT = 'TOGGLE_EDITING_PRODUCT',
+    INCREMENT = 'INCREMENT',
+    DECREMENT = 'DECREMENT',
+    PUT_COMMENT = 'PUT_COMMENT',
+    PUT_EXTRA_PRODUCTS_AND_OPTIONAL_PRODUCT = 'PUT_EXTRA_PRODUCTS_AND_OPTIONAL_PRODUCT',
+    PRICE_RANGE = 'PRICE_RANGE',
+    SORT = 'SORT',
+    PAYMENT_METHOD = 'PAYMENT_METHOD',
+    APPLY_DISCOUNT = 'APPLY_DISCOUNT'
+}
+export const initialStateSales: SalesState = {
+  animateType: '',
+  counter: 0,
+  discountAmount: 0,
+  discountPercent: 0,
+  discountType: TypeDiscount.PERCENT,
+  itemsInCart: 0,
+  payId: '',
+  priceRange: 0,
+  PRODUCT: [],
+  sortBy: null,
+  startAnimateUp: '',
+  totalAmount: 0,
+  totalPrice: 0
+}

package/src/hooks/useSales/helpers/extras.utils.ts

@@ -0,0 +1,42 @@
+/**
+ * extrasUtils.ts
+ * Increment/decrement extras handling as pure functions returning new arrays.
+ */
+
+/**
+ * Increment extra entry
+ * @param {Array} dataExtra
+ * @param {string|number} exPid
+ * @returns {Array}
+ */
+export const incrementExtra = (dataExtra = [], exPid: string | number) => {
+  if (!Array.isArray(dataExtra)) return []
+  return dataExtra.map((producto: any) => {
+    if (producto.exPid === exPid) {
+      const initialQuantity = producto.quantity ? producto.quantity : 0
+      const newQuantity = initialQuantity + 1
+      const newExtraPrice = (producto.extraPrice || 0) * newQuantity
+      return { ...producto, quantity: newQuantity, newExtraPrice }
+    }
+    return producto
+  })
+}
+
+/**
+ * Decrement extra entry
+ * @param {Array} dataExtra
+ * @param {string|number} exPid
+ * @returns {Array}
+ */
+export const decrementExtra = (dataExtra = [], exPid: string | number) => {
+  if (!Array.isArray(dataExtra)) return []
+  return dataExtra.map((producto: any) => {
+    if (producto.exPid === exPid) {
+      const { quantity = 0, extraPrice = 0 } = producto
+      const newQuantity = Math.max(quantity - 1, 0)
+      const newExtraPrice = newQuantity === 0 ? extraPrice : extraPrice * newQuantity
+      return { ...producto, quantity: newQuantity, newExtraPrice }
+    }
+    return producto
+  })
+}

package/src/hooks/useSales/helpers/filterProductsByCarProId.utils.ts

@@ -0,0 +1,17 @@
+/**
+ * Filter products by carProId.
+ * @param {Array} products - Array of products to filter.
+ * @param {Array} carProIds - Array of carProId to filter by.
+ * @returns {Array} - Filtered array of products or all products if no matches found.
+ */
+export function filterProductsByCarProId(products: any[], carProIds: (string | number)[]) {
+  if (!Array.isArray(products)) {
+    return []
+  }
+
+  if (!Array.isArray(carProIds) || carProIds.length === 0) {
+    return products
+  }
+
+  return products.filter(product => {return carProIds.includes(product.carProId)})
+}

package/src/hooks/useSales/helpers/increment-product-quantity.utils.ts

@@ -0,0 +1,76 @@
+/**
+ * Increments product quantity in cart safely.
+ * - Validates stock
+ * - Respects free mode
+ * - Avoids unnecessary mutations
+ *
+ * @param {Object} params
+ * @param {Object} params.state - Current reducer state
+ * @param {string | number} params.productId - Product identifier
+ * @param {Object[]} params.productsFood - Source products list
+ * @param {Function} params.sendNotification - Notification handler
+ *
+ * @returns {Object} Updated state
+ */
+export const incrementProductQuantity = ({
+  state,
+  productId,
+  productsFood = [],
+  sendNotification = () => {}
+}: {
+  state: any;
+  productId: string | number;
+  productsFood: any[];
+  sendNotification?: Function;
+}) => {
+  const sourceProduct = productsFood.find(
+    (product) => {return product.pId === productId}
+  )
+
+  if (!sourceProduct) return state
+
+  const PRODUCT = state.PRODUCT.map((item: any) => {
+    if (item.pId !== productId) return item
+
+    const {
+      stock = 0,
+      manageStock,
+      ProPrice: unitPrice = 0
+    } = sourceProduct
+
+    const isFree = Boolean(item.free)
+    const newQuantity = item.ProQuantity + 1
+
+    // Stock = 0
+    if (stock === 0) {
+      sendNotification({
+        title: 'Sin stock',
+        backgroundColor: 'warning',
+        description: `El producto ${item.pName} está agotado y no puede ser añadido al carrito.`
+      })
+      return item
+    }
+
+    // Stock exceeded
+    if (manageStock && newQuantity > stock) {
+      sendNotification({
+        title: 'Stock insuficiente',
+        backgroundColor: 'warning',
+        description: `No puedes agregar más unidades de ${item.pName}, stock disponible: ${stock}`
+      })
+      return item
+    }
+
+    return {
+      ...item,
+      ProQuantity: newQuantity,
+      ProPrice: isFree ? 0 : newQuantity * unitPrice
+    }
+  })
+
+  return {
+    ...state,
+    counter: state.counter + 1,
+    PRODUCT
+  }
+}

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

@@ -0,0 +1,3 @@
+export * from './extras.utils'
+export * from './remove-product.utils'
+export * from './filterProductsByCarProId.utils'

package/src/hooks/useSales/helpers/initializer.utils.ts

@@ -0,0 +1,22 @@
+import { Cookies } from '../../../cookies'
+import { SalesState } from '../types'
+
+import { initialStateSales } from './constants'
+
+/**
+ * Initializes sales state from cookies or fallback state
+ * @param initialValue
+ */
+export const initializer = (
+  initialValue: SalesState = initialStateSales
+): SalesState => {
+  try {
+    const raw = Cookies.get(process.env.NEXT_LOCAL_SALES_STORE)
+
+    if (!raw) return initialValue
+
+    return JSON.parse(raw) as SalesState
+  } catch {
+    return initialValue
+  }
+}

package/src/hooks/useSales/helpers/isStockInsufficient.ts

@@ -0,0 +1,3 @@
+export const isStockInsufficient = (currentQuantity: number, stock: number) => {
+  return currentQuantity >= stock
+}

package/src/hooks/useSales/helpers/remove-product.utils.test.ts

@@ -0,0 +1,49 @@
+import { handleRemoveProduct } from './remove-product.utils'
+
+describe('handleRemoveProduct', () => {
+  test('decrements product quantity and updates price when ProQuantity > 1', () => {
+    const state = {
+      counter: 5,
+      totalAmount: 100,
+      PRODUCT: [
+        { pId: 'p1', ProQuantity: 3, ProPrice: 30 },
+        { pId: 'p2', ProQuantity: 1, ProPrice: 20 }
+      ]
+    }
+    const productsFood = [{ pId: 'p1', ProPrice: 10 }]
+    const action = { payload: { pId: 'p1', ProQuantity: 3, ProPrice: 10 } }
+
+    const result = handleRemoveProduct(state as any, action as any, productsFood as any)
+
+    expect(result.counter).toBe(4)
+    expect(result.totalAmount).toBe(90)
+    expect(result.PRODUCT).toHaveLength(2)
+
+    const updated = result.PRODUCT.find((p: any) => {return p.pId === 'p1'})
+    expect(updated).toEqual({ pId: 'p1', ProQuantity: 2, ProPrice: 20 })
+
+    const unchanged = result.PRODUCT.find((p: any) => {return p.pId === 'p2'})
+    expect(unchanged).toEqual({ pId: 'p2', ProQuantity: 1, ProPrice: 20 })
+  })
+
+  test('removes product from PRODUCT when ProQuantity === 1', () => {
+    const state = {
+      counter: 2,
+      totalAmount: 30,
+      PRODUCT: [
+        { pId: 'p1', ProQuantity: 1, ProPrice: 15 },
+        { pId: 'p2', ProQuantity: 1, ProPrice: 15 }
+      ]
+    }
+    const productsFood = [{ pId: 'p1', ProPrice: 15 }]
+    const action = { payload: { pId: 'p1', ProQuantity: 1, ProPrice: 15 } }
+
+    const result = handleRemoveProduct(state as any, action as any, productsFood as any)
+
+    expect(result.counter).toBe(1)
+    expect(result.totalAmount).toBe(15)
+    expect(result.PRODUCT).toHaveLength(1)
+    expect(result.PRODUCT.find((p: any) => {return p.pId === 'p1'})).toBeUndefined()
+    expect(result.PRODUCT[0]).toEqual({ pId: 'p2', ProQuantity: 1, ProPrice: 15 })
+  })
+})

package/src/hooks/useSales/helpers/remove-product.utils.ts

@@ -0,0 +1,34 @@
+/**
+ *
+ * @param state
+ * @param action
+ * @param productsFood
+ */
+export function handleRemoveProduct(state: any, action: any, productsFood: any) {
+  const productExist = state?.PRODUCT.find((items: any) => {
+    return items.pId === action.payload.pId
+  })
+  const OurProduct = productsFood.find((items: any) => {
+    return items.pId === action.payload.pId
+  })
+  return {
+    ...state,
+    counter: state.counter - 1,
+    totalAmount: state.totalAmount - action.payload.ProPrice,
+    PRODUCT:
+      action.payload.ProQuantity > 1
+        ? state.PRODUCT.map((items: any) => {
+          return items.pId === action.payload.pId
+            ? {
+              ...items,
+              pId: action.payload.pId,
+              ProQuantity: items.ProQuantity - 1,
+              ProPrice: productExist.ProPrice - OurProduct?.ProPrice
+            }
+            : items
+        })
+        : state.PRODUCT.filter((items: any) => {
+          return items.pId !== action.payload.pId
+        })
+  }
+}

package/src/hooks/useSales/helpers/resolveProduct.ts

@@ -0,0 +1,29 @@
+/**
+ * resolveProduct - resolve product from local memory or fetch from API
+ * @param {{ pId: string, productsFood?: any[], fetchProduct: (params:{pId:string}) => Promise<any> }} args
+ * @returns {Promise<any|null>} resolved product or null if not found
+ */
+export const resolveProduct = async ({
+  pId,
+  productsFood = [],
+  fetchProduct
+}: {
+  pId: string
+  productsFood?: any[]
+  fetchProduct: (params: { pId: string }) => Promise<any>
+}): Promise<any | null> => {
+  if (!pId) return null
+
+  // fast memory lookup
+  const mem = productsFood.find((it: any) => {return it?.pId === pId})
+  if (mem) return mem
+
+  // fetch from API and normalize
+  try {
+    const res = await fetchProduct({ pId })
+    return res?.data?.productFoodsOne ?? null
+  } catch (err) {
+    // bubble up null — caller will notify
+    return null
+  }
+}

package/src/hooks/useSales/helpers/useAddToCart.ts

@@ -0,0 +1,64 @@
+import { useCallback } from 'react'
+
+import { resolveProduct } from './resolveProduct'
+
+/**
+ * useAddToCart - returns a stable handler that resolves product and dispatches ADD_TO_CART
+ * @param {Object} params
+ * @param {(params:{pId:string})=>Promise<any>} params.handleGetOneProduct - api fetch function (hook)
+ * @param {any[]} params.productsFood - in-memory products list
+ * @param {(action:any)=>void} params.dispatch - reducer dispatch
+ * @param {(n:{title:string,backgroundColor:string,description:string})=>void} params.sendNotification
+ */
+export const useAddToCart = ({
+  handleGetOneProduct,
+  productsFood,
+  dispatch,
+  sendNotification
+}: {
+  handleGetOneProduct: (p: { pId: string }) => Promise<any>
+  productsFood: any[]
+  dispatch: (a: any) => void
+  sendNotification: (n: { title: string; backgroundColor: string; description: string }) => void
+}) => {
+  return useCallback(
+    async (action: any) => {
+      const pId = action?.payload?.pId
+      if (!pId) {
+        sendNotification?.({
+          title: 'Invalid product',
+          backgroundColor: 'warning',
+          description: 'Product identifier is missing'
+        })
+        return
+      }
+
+      // UX: show immediate feedback if you want (spinner, skeleton, etc.) — omitted for brevity
+
+      const product = await resolveProduct({
+        pId,
+        productsFood,
+        fetchProduct: handleGetOneProduct
+      })
+
+      if (!product) {
+        sendNotification?.({
+          title: 'Producto no encontrado',
+          backgroundColor: 'warning',
+          description: 'No se pudo obtener la información del producto'
+        })
+        return
+      }
+
+      // dispatch synchronous action with resolved product (reducer stays pure)
+      dispatch({
+        type: 'ADD_TO_CART',
+        payload: {
+          ...action.payload,
+          __resolvedProduct: product
+        }
+      })
+    },
+    [handleGetOneProduct, productsFood, dispatch, sendNotification]
+  )
+}