npm-pkg-hook 1.3.8 → 1.4.0

package/src/hooks/useRoads/queries.ts

@@ -0,0 +1,13 @@
+import { gql } from '@apollo/client'
+
+export const GET_ALL_ROAD = gql`
+query getTypeRoad {
+  road{
+    rId
+    rName
+    rState
+    rDatCre
+    rDatMod
+  }
+}
+`

package/src/hooks/useRoles/index.ts

@@ -0,0 +1,4 @@
+export * from './useCreateRole'
+export * from './useGetRoles'
+export * from './useUpdateRolesPriority'
+export * from './useRemoveRoles'

package/src/hooks/useRoles/queries.ts

@@ -0,0 +1,70 @@
+import { gql } from '@apollo/client'
+
+export const GET_ALL_ROLES = gql`
+query getRoles($idStore: ID, $search: String, $min: Int, $max: Int, $fromDate: DateTime, $toDate: DateTime, $page: Int) {
+  getRoles(idStore: $idStore, search: $search, min: $min, max: $max, fromDate: $fromDate, toDate: $toDate, page: $page) {
+  success
+    message
+    errors {
+      path
+      message
+      type
+      context {
+        limit
+        value
+        label
+        key
+      }
+      __typename
+    }
+    pagination {
+      totalRecords
+      totalPages
+      currentPage
+      __typename
+    }
+    data { 
+     idRole
+      name
+      priority
+      description
+      permissions
+      createdAt
+      updatedAt
+    }
+  }
+}
+`
+
+/**
+ * Mutación para crear un nuevo rol
+ */
+export const CREATE_ROLE_MUTATION = gql`
+mutation createRoleMutation($input: IRole!) {
+  createRoleMutation(input: $input) {
+   success
+    message
+    errors {
+      path
+      message
+      type
+      context {
+        limit
+        value
+        label
+        key
+      }
+      __typename
+    }
+      data { 
+     idRole
+      name
+      priority
+      description
+      permissions
+      createdAt
+      updatedAt
+    }
+  }
+}
+`

package/src/hooks/useRoles/useCreateRole.ts

@@ -0,0 +1,40 @@
+import { useMutation } from '@apollo/client'
+
+import { CREATE_ROLE_MUTATION } from './queries'
+/**
+ * Custom hook para crear un nuevo rol
+ * @param root0
+ * @param root0.sendNotification
+ * @returns {Object} - Estado de la mutación, incluyendo loading, error, data y la función createRoleMutation
+ */
+export const useCreateRole = ({
+  sendNotification = () => {
+    return {
+      title: '',
+      description: '',
+      backgroundColor: ''
+    }
+  }
+} = {
+  sendNotification: () => {
+  }
+}) => {
+  const [createRoleMutation, { loading, error, data }] = useMutation(CREATE_ROLE_MUTATION, {
+    onError: () => {
+      sendNotification({
+        title: 'Error',
+        description: 'Ocurrió un error inesperado',
+        backgroundColor: 'error'
+      })
+    },
+    onCompleted: () => {
+      return null
+    }
+  })
+
+  return [createRoleMutation, {
+    loading,
+    error,
+    data: data?.createRoleMutation ?? null
+  }]
+}

package/src/hooks/useRoles/useGetRoles.ts

@@ -0,0 +1,37 @@
+import { useQuery } from '@apollo/client'
+
+import { GET_ALL_ROLES } from './queries'
+
+export const useGetRoles = ({
+  max,
+  order = 'DESC',
+  search,
+  sendNotification = () => { }
+} = {}) => {
+  const {
+    loading,
+    error,
+    called,
+    data,
+    refetch
+  } = useQuery(GET_ALL_ROLES, {
+    onError: () => {
+      sendNotification({
+        title: 'Error',
+        description: 'Algo salió mal',
+        backgroundColor: 'error'
+      })
+    },
+    variables: {
+      search,
+      max: max || 25,
+      order
+    }
+  })
+  return [data?.getRoles, {
+    loading: called ? false : loading,
+    buttonLoading: loading,
+    error,
+    refetch
+  }]
+}

package/src/hooks/useRoles/useRemoveRoles.ts

@@ -0,0 +1,40 @@
+import { useMutation, gql } from '@apollo/client'
+
+// Define the GraphQL mutation
+const REMOVE_ROLES_MUTATION = gql`
+  mutation removeRoles($roleIds: [ID!]!) {
+    removeRoles(roleIds: $roleIds) {
+      success
+      message
+    }
+  }
+`
+
+/**
+ * Custom hook to call removeRoles mutation.
+ *
+ * @returns {Object} An object containing the mutation function and the loading/error state.
+ */
+export function useRemoveRoles () {
+  const [removeRoles, { loading, error, data }] = useMutation(REMOVE_ROLES_MUTATION, {
+    onError: (err) => {
+      console.error('Error removing roles:', err)
+    }
+  })
+
+  const removeRolesHandler = async ({ roleIds = [] }) => {
+    try {
+      const { data } = await removeRoles({ variables: { roleIds } })
+      return data.removeRoles
+    } catch (err) {
+      console.error('Error removing roles:', err)
+      throw err
+    }
+  }
+
+  return [removeRolesHandler, {
+    loading,
+    error,
+    data
+  }]
+}

package/src/hooks/useRoles/useUpdateRolesPriority.ts

@@ -0,0 +1,44 @@
+import { useMutation, gql } from '@apollo/client'
+
+// Define the mutation
+const UPDATE_ROLES_PRIORITY = gql`
+  mutation updateRolesPriority($roles: [IParamsPriority]!) {
+    updateRolesPriority(roles: $roles) {
+      success
+      message
+    }
+  }
+`
+
+/**
+ * Custom hook to update roles priority
+ * @returns {Object} - Returns the mutation function and the mutation state
+ */
+export const useUpdateRolesPriority = () => {
+  const [updateRolesPriority, { data, loading, error }] = useMutation(UPDATE_ROLES_PRIORITY)
+
+  /**
+   * Function to update the priority of roles
+   * @param {Array} roles - The array of roles with their priorities to be updated
+   * @returns {Promise<void>}
+   */
+  const handleUpdateRolesPriority = async (roles) => {
+    try {
+      const response = await updateRolesPriority({
+        variables: { roles }
+      })
+
+      // You can handle the response or any additional logic here
+      return response
+    } catch (err) {
+      // Handle the error as needed
+      console.error('Error updating roles priority:', err)
+    }
+  }
+
+  return [handleUpdateRolesPriority, {
+    data,
+    loading,
+    error
+  }]
+}

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

@@ -0,0 +1,120 @@
+import { NotificationPayload } from '../types'
+
+import { isStockInsufficient } from './isStockInsufficient'
+
+interface AddToCartProps {
+  state: any
+  action: any
+  product: any
+  sendNotification?: (args: NotificationPayload) => any
+  sendAlertStock: (stock: number) => void
+}
+
+/**
+ * Adds a product to the cart with maximum performance.
+ * Avoids full array scans and minimizes object cloning.
+ * @param {any} state - Current reducer state.
+ * @param {any} action - Action containing product data.
+ * @returns {any} Updated state.
+ */
+export const addToCartFunc = ({
+  state = {},
+  action = {},
+  product,
+  sendNotification = () => { },
+  sendAlertStock = () => { }
+}: AddToCartProps) => {
+  const payload = action?.payload ?? {}
+  const {
+    pId,
+    pName,
+    getOneTags,
+    stock,
+    ProDescription,
+    ProImage,
+    ProPrice,
+    ProDescuento
+  } = payload
+
+  // Validate basic stock
+  if (stock === 0) {
+    sendNotification({
+      title: 'Sin stock',
+      backgroundColor: 'warning',
+      description: 'Producto sin stock disponible en tu inventario'
+    })
+    return state
+  }
+
+  // PRE-FETCH product references (only ONCE)
+  const productExistIndex = state.PRODUCT.findIndex((item: any) => {return item.pId === pId})
+  const productExist = productExistIndex !== -1 ? state.PRODUCT[productExistIndex] : null
+  if (!product) return state
+
+  // Check stock handling rules
+  const currentQty = productExist?.ProQuantity ?? 0
+  if (product.manageStock && isStockInsufficient(currentQty, product.stock)) {
+    sendAlertStock(stock)
+    return state
+  }
+
+  const isFree = productExist?.free ?? false
+  const newQuantity = productExist ? currentQty + 1 : 1
+
+  // Calculate new unit price only once
+  const unitPrice = product.ProPrice ?? 0
+
+  // Calculate final price respecting 'free' mode
+  const newPrice = isFree ? 0 : newQuantity * unitPrice
+
+  // COMMON STATE UPDATES
+  const baseState = {
+    ...state,
+    counter: state.counter + 1,
+    totalAmount: state.totalAmount + ProPrice,
+    startAnimateUp: 'start-animate-up'
+  }
+
+  // CASE 1: Product does NOT exist → add it
+  if (!productExist) {
+    const newProduct = {
+      pId,
+      pName,
+      editing: false,
+      getOneTags,
+      unitPrice,
+      manageStock: product.manageStock ?? false,
+      ProDescription,
+      ProImage,
+      ProPrice,
+      stock,
+      ProDescuento,
+      ProQuantity: 1,
+      free: false
+    }
+
+    return {
+      ...baseState,
+      PRODUCT: [...state.PRODUCT, newProduct]
+    }
+  }
+
+  // CASE 2: Product already exists → update only ONE item
+  const newList = [...state.PRODUCT]
+
+  newList[productExistIndex] = {
+    ...productExist,
+    getOneTags: product.genderTags,
+    unitPrice,
+    editing: false,
+    oldQuantity: newQuantity,
+    ProPrice: newPrice,
+    ProQuantity: newQuantity,
+    free: isFree
+  }
+
+  return {
+    ...baseState,
+    PRODUCT: newList
+  }
+}

package/src/hooks/useSales/helpers/apply-discount-to-cart.utils.ts

@@ -0,0 +1,292 @@
+export enum TypeDiscount {
+  PERCENT = 'PERCENT',
+  AMOUNT = 'AMOUNT'
+}
+interface DiscountPayload {
+  type: TypeDiscount
+  value: number
+}
+
+/**
+ * Apply a discount to the reducer state in a mathematically-exact way.
+ *
+ * - Supports two discount types: "PERCENT" (0-100) and "AMOUNT" (fixed currency amount).
+ * - Works in integer cents to avoid floating point errors, distributes rounding
+ *   remainders using the Largest Remainder Method so allocations sum exactly.
+ * - BEFORE applying a new discount, restores original prices if they were previously saved
+ *   (originalProPrice and originalNewExtraPrice). This prevents stacking discounts.
+ * - Applies discount first to `ProPrice` (base) and, if needed, to `dataExtra[].newExtraPrice`
+ *   proportionally, never producing negative prices.
+ * - Returns a new state (immutable) and sets metadata: discountType, discountPercent,
+ *   discountAmount, discountBreakdown and preserves original prices in `originalProPrice`
+ *   and `dataExtra[].originalNewExtraPrice`.
+ *
+ * NOTE: Uses optional `sendNotification` to report errors/success.
+ *
+ * @param {any} state - current reducer state
+ * @param {{ type: string, value: number }} payload - { type: 'PERCENT'|'AMOUNT', value: number }
+ * @param {(notification: {title:string,backgroundColor:'success'|'error'|'warning'|'info',description:string}) => void} sendNotification
+ * @returns {any} new state with discounts applied (idempotent w.r.t repeated calls)
+ */
+export const applyDiscountToCart = (
+  state: any,
+  payload: DiscountPayload,
+  sendNotification?: (notification: {
+    title: string
+    backgroundColor: 'success' | 'error' | 'warning' | 'info'
+    description: string
+  }) => void
+) => {
+  const discountType = (payload?.type ?? TypeDiscount.PERCENT).toString().toUpperCase()
+  const rawValue = Number(payload?.value)
+
+  // Basic validations
+  if (!Array.isArray(state?.PRODUCT) || state.PRODUCT.length === 0) {
+    sendNotification?.({
+      title: 'Warning',
+      backgroundColor: 'warning',
+      description: 'No items in cart to apply discount.'
+    })
+    return {
+      ...state,
+      discountType,
+      discountPercent: 0,
+      discountAmount: 0,
+      discountBreakdown: []
+    }
+  }
+
+  if (Number.isNaN(rawValue) || rawValue < 0) {
+    sendNotification?.({
+      title: 'Error',
+      backgroundColor: 'error',
+      description: 'Invalid discount value.'
+    })
+    return state
+  }
+
+  if (discountType !== TypeDiscount.PERCENT && discountType !== TypeDiscount.AMOUNT) {
+    sendNotification?.({
+      title: 'Error',
+      backgroundColor: 'error',
+      description: 'Invalid discount type.'
+    })
+    return state
+  }
+
+  if (discountType === TypeDiscount.PERCENT && (rawValue < 0 || rawValue > 100)) {
+    sendNotification?.({
+      title: 'Error',
+      backgroundColor: 'warning',
+      description: 'Percentage must be between 0 and 100.'
+    })
+    return state
+  }
+
+  // Helpers - work in cents to preserve exactness
+  const toCents = (n: number) => {return Math.round((Number(n) || 0) * 100)}
+  const fromCents = (c: number) => {return c / 100}
+
+  // --- Normalize / Restore originals to avoid stacking discounts ---
+  // For each product, use saved original prices if present; otherwise use current as "original"
+  const normalizedItems = state.PRODUCT.map((item: any) => {
+    // Determine original base price (prefer originalProPrice if present)
+    const origBaseRaw =
+      item.originalProPrice !== undefined && item.originalProPrice !== null
+        ? Number(item.originalProPrice)
+        : Number(item.ProPrice || 0)
+
+    const baseCents = toCents(origBaseRaw)
+
+    // Normalize extras: preserve originalNewExtraPrice if exists, else take current newExtraPrice
+    const extrasRaw = Array.isArray(item.dataExtra) ? item.dataExtra : []
+    const extrasNormalized = extrasRaw.map((ex: any) => {
+      const origExRaw =
+        ex.originalNewExtraPrice !== undefined && ex.originalNewExtraPrice !== null
+          ? Number(ex.originalNewExtraPrice)
+          : Number(ex.newExtraPrice || 0)
+      return {
+        originalExtraObject: ex,
+        originalNewExtraPriceRaw: origExRaw,
+        originalNewExtraPriceCents: toCents(origExRaw)
+      }
+    })
+
+    const extrasCentsList = extrasNormalized.map((e: any) => {return e.originalNewExtraPriceCents})
+    const extrasTotalCents = extrasCentsList.reduce((s: number, v: number) => {return s + v}, 0)
+    const itemTotalCents = baseCents + extrasTotalCents
+
+    return {
+      originalItem: item,
+      baseCents,
+      extrasNormalized,
+      extrasCentsList,
+      extrasTotalCents,
+      itemTotalCents
+    }
+  })
+
+  const cartTotalCents = normalizedItems.reduce((s: number, it: any) => {return s + it.itemTotalCents}, 0)
+
+  if (cartTotalCents === 0) {
+    sendNotification?.({
+      title: 'Warning',
+      backgroundColor: 'warning',
+      description: 'Cart total is zero; nothing to discount.'
+    })
+    return {
+      ...state,
+      discountType,
+      discountPercent: 0,
+      discountAmount: 0,
+      discountBreakdown: []
+    }
+  }
+
+  // Determine requested total discount in cents
+  let totalDiscountCents = 0
+  if (discountType === TypeDiscount.PERCENT) {
+    totalDiscountCents = Math.round((cartTotalCents * rawValue) / 100)
+  } else {
+    totalDiscountCents = toCents(rawValue)
+    // Cap to cart total
+    if (totalDiscountCents > cartTotalCents) {
+      totalDiscountCents = cartTotalCents
+    }
+  }
+
+  // If no discount to apply
+  if (totalDiscountCents <= 0) {
+    sendNotification?.({
+      title: 'Notice',
+      backgroundColor: 'info',
+      description: 'No discount applied.'
+    })
+    return {
+      ...state,
+      discountType,
+      discountPercent: discountType === TypeDiscount.PERCENT ? rawValue : +((totalDiscountCents / cartTotalCents) * 100).toFixed(2),
+      discountAmount: fromCents(totalDiscountCents),
+      discountBreakdown: []
+    }
+  }
+
+  // ---- Allocation using Largest Remainder Method (exact cents) ----
+  const rawAllocs = normalizedItems.map((it: any) => {return (it.itemTotalCents * totalDiscountCents) / cartTotalCents})
+  const floorAllocs = rawAllocs.map((v: any) => {return Math.floor(v)})
+  const remainders = rawAllocs.map((v: any, i: number) => {return { idx: i, rem: v - floorAllocs[i] }})
+  const sumFloor = floorAllocs.reduce((s: number, v: number) => {return s + v}, 0)
+  let remainingCents = totalDiscountCents - sumFloor
+
+  remainders.sort((a: any, b: any) => {return b.rem - a.rem})
+  const finalAllocs = [...floorAllocs]
+  for (let i = 0; i < remainders.length && remainingCents > 0; i++) {
+    finalAllocs[remainders[i].idx] += 1
+    remainingCents -= 1
+  }
+
+  // ---- Apply allocations to restored originals (base first, then extras) ----
+  const breakdown: { pId: string | number; discountAmount: number }[] = []
+  const newProducts = normalizedItems.map((it: any, idx: number) => {
+    const allocated = finalAllocs[idx] // cents
+    let remainingToTake = allocated
+
+    // Apply on base
+    const origBaseCents = it.baseCents
+    const usedOnBase = Math.min(origBaseCents, remainingToTake)
+    const baseAfter = origBaseCents - usedOnBase
+    remainingToTake -= usedOnBase
+
+    // Apply on extras proportionally if needed
+    let newExtrasCentsList = it.extrasCentsList.slice() // copy
+    if (remainingToTake > 0 && it.extrasTotalCents > 0) {
+      const extrasTotal = it.extrasTotalCents
+      // raw per-extra allocation
+      const rawExtraAllocs = newExtrasCentsList.map((exCents: number) => {return (exCents / extrasTotal) * remainingToTake})
+      const floorExtraAllocs = rawExtraAllocs.map((v: number) => {return Math.floor(v)})
+      const usedExtraFloor = floorExtraAllocs.reduce((s: number, v: number) => {return s + v}, 0)
+      let rest = remainingToTake - usedExtraFloor
+
+      const extraRemainders = rawExtraAllocs.map((v: number, i: number) => {return { idx: i, rem: v - floorExtraAllocs[i] }})
+      extraRemainders.sort((a: any, b: any) => {return b.rem - a.rem})
+      const finalExtraAllocs = [...floorExtraAllocs]
+      for (let k = 0; k < extraRemainders.length && rest > 0; k++) {
+        finalExtraAllocs[extraRemainders[k].idx] += 1
+        rest -= 1
+      }
+
+      // apply finalExtraAllocs with cap
+      newExtrasCentsList = newExtrasCentsList.map((exCents: number, i: number) => {
+        const reduceBy = Math.min(exCents, finalExtraAllocs[i])
+        return exCents - reduceBy
+      })
+
+      remainingToTake = 0
+    }
+
+    // Build updated product object:
+    const newBaseCents = baseAfter
+    const newProPrice = fromCents(newBaseCents)
+
+    const originalExtrasObjects = it.extrasNormalized.map((e: any) => {return e.originalExtraObject || {}})
+    const newDataExtra = originalExtrasObjects.map((exObj: any, i: number) => {
+      const newExtraPrice = fromCents(newExtrasCentsList[i] || 0)
+      // preserve originalNewExtraPrice on each extra (if not already)
+      return {
+        ...exObj,
+        originalNewExtraPrice: exObj.originalNewExtraPrice !== undefined ? exObj.originalNewExtraPrice : exObj.newExtraPrice,
+        newExtraPrice
+      }
+    })
+
+    const appliedDiscountCents = allocated - remainingToTake
+    breakdown.push({ pId: it.originalItem.pId, discountAmount: fromCents(appliedDiscountCents) })
+
+    const itemTotalCentsBefore = it.itemTotalCents || 0
+    const itemDiscountPercent = itemTotalCentsBefore > 0 ? +((appliedDiscountCents / itemTotalCentsBefore) * 100).toFixed(4) : 0
+
+    return {
+      ...it.originalItem,
+      // save originalProPrice if not present (so future calls can restore)
+      originalProPrice:
+        it.originalItem.originalProPrice !== undefined && it.originalItem.originalProPrice !== null
+          ? it.originalItem.originalProPrice
+          : fromCents(it.baseCents),
+      ProPrice: newProPrice,
+      dataExtra: newDataExtra,
+      // per-item metadata
+      discountAmount: fromCents(appliedDiscountCents),
+      discountPercent: itemDiscountPercent
+    }
+  })
+
+  // Final safety check & tiny correction if needed
+  const allocatedSumCents = breakdown.reduce((s, b) => {return s + toCents(Number(b.discountAmount) || 0)}, 0)
+  if (allocatedSumCents !== totalDiscountCents) {
+    const diff = totalDiscountCents - allocatedSumCents
+    if (newProducts.length > 0 && diff !== 0) {
+      const first = newProducts[0]
+      first.discountAmount = Number(first.discountAmount || 0) + fromCents(diff)
+      const adjustOnBase = Math.min(toCents(first.ProPrice), diff)
+      first.ProPrice = fromCents(Math.max(0, toCents(first.ProPrice) - adjustOnBase))
+      breakdown[0].discountAmount = Number(breakdown[0].discountAmount || 0) + fromCents(diff)
+    }
+  }
+
+  const overallPercent = +((totalDiscountCents / cartTotalCents) * 100).toFixed(4)
+
+  sendNotification?.({
+    title: 'Discount applied',
+    backgroundColor: 'success',
+    description: `${discountType === TypeDiscount.PERCENT ? rawValue + '%' : fromCents(totalDiscountCents)} discount applied successfully.`
+  })
+
+  return {
+    ...state,
+    PRODUCT: newProducts,
+    discountType,
+    discountPercent: discountType === TypeDiscount.PERCENT ? rawValue : overallPercent,
+    discountAmount: fromCents(totalDiscountCents),
+    discountBreakdown: breakdown
+  }
+}