npm-pkg-hook 1.12.4 → 1.12.7

package/src/hooks/useOrders/queries.js

@@ -1,89 +0,0 @@
-import { gql } from '@apollo/client'
-
-export const CHANGE_STATE_STORE_ORDER = gql`
-mutation changePPStateOrder($pPStateP: Int, $pCodeRef: String, $pDatMod: String) {
-  changePPStateOrder(pPStateP: $pPStateP, pCodeRef: $pCodeRef,  pDatMod: $pDatMod){
-    success
-    message
-  }
-}
-
-`
-export const GET_ALL_ORDER = gql`
-query getAllOrderStoreFinal($idStore: ID, $search: String, $min: Int, $max: Int, $statusOrder: Int, $fromDate:  DateTime, $toDate:  DateTime) {
-  getAllOrderStoreFinal(idStore: $idStore, search: $search, min: $min, max: $max, statusOrder: $statusOrder, toDate: $toDate,fromDate: $fromDate ) {
-    pdpId
-    idStore
-    pCodeRef
-    payMethodPState
-    pPRecoger
-    totalProductsPrice
-    pSState
-    pDatCre
-    channel
-    locationUser
-    pDatMod
-    getAllPedidoStore{
-        pdpId
-        pId
-        idStore
-        ShoppingCard
-        pCodeRef
-        pPStateP
-        payMethodPState
-        pPRecoger
-        pDatCre
-        pDatMod
-        getAllShoppingCard {
-          ShoppingCard
-          comments
-          cantProducts
-          pId
-        productFood{
-          pId
-          carProId
-          colorId
-          idStore
-          pName
-          ProPrice
-          ProDescuento
-          ProDescription
-          ValueDelivery
-          ProImage
-          ProStar
-          pState
-          pDatCre
-          pDatMod
-        }
-      }
-    }
-  }
-}
-`
-
-export const GET_ALL_ORDER_FROM_STORE = gql`
-query getAllSalesStore {
-  getAllSalesStore {
-      change
-      channel
-      status
-      createdAt
-      pCodeRef
-      idStore
-      pdpId
-      locationUser
-      shoppingCartRefCode
-      payMethodPState
-      updatedAt
-      totalProductsPrice
-      unidProducts
-      getUser {
-         associateStore
-         avatar
-         createdAt
-         id
-         email
-      }
-  }
-}
-`

package/src/hooks/useOrders/useChangeOrderState/index.ts

@@ -1,125 +0,0 @@
-import { gql, useApolloClient, useMutation } from '@apollo/client'
-import { SendNotificationFn } from '../../useImageUploaderProduct'
-import { updateExistingOrders } from '../../useUpdateExistingOrders'
-/**
- * GraphQL mutation to change the state of a store order (pedido).
- */
-const CHANGE_STATE_STORE_ORDER = gql`
-  mutation changePPStateOrder($idStatus: ID, $pCodeRef: String, $pDatMod: String) {
-    changePPStateOrder(idStatus: $idStatus, pCodeRef: $pCodeRef, pDatMod: $pDatMod) {
-      success
-      message
-      errors {
-        path
-        message
-        type
-      }
-      data {
-        pdpId
-        id
-        idStore
-        pPStateP
-        pSState
-        
-        ppState
-        pCodeRef
-      }
-    }
-  }
-`
-
-interface IUseChangeStateOrder {
-    sendNotification: SendNotificationFn
-}
-/**
- * Hook to trigger the `changePPStateOrder` mutation.
- * @returns {Object} Contains the mutation function, loading and error state.
- */
-export const useChangeStateOrder = ({
-    sendNotification
-}: IUseChangeStateOrder) => {
-    const client = useApolloClient()
-
-    const [changeState, { loading, error, data }] = useMutation(CHANGE_STATE_STORE_ORDER, {
-        onCompleted: (res) => {
-            if (!res || !res.changePPStateOrder) {
-                return
-            }
-            const { success, data } = res?.changePPStateOrder || {}
-            if (success) {
-                const { pCodeRef, pSState } = data ?? {
-                    pCodeRef: null,
-                    pSState: null
-                }
-                if (!pCodeRef || !pSState) {
-                    return
-                }
-                // client.cache.modify({
-                //     fields: {
-                //         getAllOrdersFromStore(existingOrders = []) {
-                //             try {
-                //                 // return 
-                //                 console.log({ cache: updateExistingOrders(existingOrders, pCodeRef, pSState) })
-                //             } catch (e) {
-                //                 return existingOrders
-                //             }
-                //         }
-                //     }
-                // })
-            }
-        }
-    })
-
-    /**
-     * Triggers the mutation to update the pedido state.
-     * @param {Object} params
-     * @param {number} params.idStatus - New state of the pedido (required).
-     * @param {string} params.pCodeRef - Reference code for the pedido (required).
-     * @param {string} params.pDatMod - Modification date in ISO format (required).
-     * @returns {Promise<Object>} Response from the mutation.
-     */
-    const changeStateOrder = async ({
-        idStatus,
-        pCodeRef,
-        pDatMod,
-    }: {
-        idStatus: string
-        pCodeRef: string
-        pDatMod: string
-    }) => {
-        try {
-            const response = await changeState({
-                variables:
-                {
-                    idStatus,
-                    pCodeRef,
-                    pDatMod
-                },
-            })
-            const { success, message } = response?.data?.changePPStateOrder ?? {
-                success: false,
-                message: ''
-            }
-            sendNotification({
-                title: success ? 'Exitoso' : 'Error',
-                description: message,
-                backgroundColor: success ? 'success' : 'error'
-            })
-            return response?.data?.changePPStateOrder ?? {
-                success: false,
-                message,
-            }
-        } catch (err) {
-            return {
-                success: false,
-                message: err.message || 'Unexpected error occurred',
-            }
-        }
-    }
-
-    return [changeStateOrder, {
-        loading,
-        error,
-        data,
-    }]
-}

package/src/hooks/useOrders/useOrdersFromStore/index.ts

@@ -1,77 +0,0 @@
-import { useQuery } from '@apollo/client'
-import { GET_ALL_ORDER, GET_ALL_ORDER_FROM_STORE } from '../queries.js'
-import groupBy from 'lodash/groupBy'
-
-export const useOrders = ({
-  refetchWritePolicy = 'merge',
-  refetchReadPolicy,
-  refetch,
-  statusOrder,
-  fromDate,
-  toDate,
-  nextFetchPolicy = 'cache-first',
-  fetchPolicy = 'cache-and-network',
-  pollInterval = 60000,
-  onError
-}) => {
-  const { data, loading, error, fetchMore } = useQuery(GET_ALL_ORDER, {
-    notifyOnNetworkStatusChange: true,
-    refetchWritePolicy,
-    pollInterval,
-    fetchPolicy,
-    refetch,
-    refetchReadPolicy,
-    nextFetchPolicy,
-    onError: onError || (() => {
-
-    }),
-    variables: {
-      statusOrder,
-      fromDate,
-      toDate
-    }
-  })
-
-  return [
-    data?.getAllOrderStoreFinal,
-    { loading, error, data, fetchMore }
-  ]
-}
-
-export const useOrdersFromStore = ({
-  idStore,
-  cId,
-  dId,
-  ctId,
-  search = '',
-  min,
-  fromDate,
-  toDate,
-  max,
-  statusOrder,
-  callback = (data) => {
-    return data
-  }
-}) => {
-   const key = 'status'
-  const {
-    data,
-    loading,
-    refetch,
-    error,
-    called
-  } = useQuery(GET_ALL_ORDER_FROM_STORE, {
-    notifyOnNetworkStatusChange: true,
-    fetchPolicy: 'network-only',
-    onCompleted: (data) => {
-      if (typeof callback === 'function') {
-        callback(data)
-      }
-    }
-  })
-  const grouped = groupBy(data?.getAllSalesStore ?? [], key)
- 
-
-  return [grouped, { refetch, loading: called ? false : loading, error }]
-}
-

package/src/hooks/usePWAInstall/index.js

@@ -1,38 +0,0 @@
-import { useState, useEffect } from 'react'
-
-export const usePWAInstall = () => {
-  const [deferredPrompt, setDeferredPrompt] = useState(null)
-  const [isInstallable, setIsInstallable] = useState(false)
-
-  useEffect(() => {
-    const handleBeforeInstallPrompt = (e) => {
-      e.preventDefault() // Evita que el navegador muestre el diálogo automáticamente
-      setDeferredPrompt(e) // Almacena el evento para que puedas llamarlo más tarde
-      setIsInstallable(true) // Marca que la PWA es instalable
-    }
-
-    window.addEventListener('beforeinstallprompt', handleBeforeInstallPrompt)
-
-    return () => {
-      window.removeEventListener('beforeinstallprompt', handleBeforeInstallPrompt)
-    }
-  }, [])
-
-  const installPWA = () => {
-    if (deferredPrompt) {
-      deferredPrompt.prompt()
-
-      deferredPrompt.userChoice.then((choiceResult) => {
-        if (choiceResult.outcome === 'accepted') {
-          console.log('User accepted the install prompt')
-        } else {
-          console.log('User dismissed the install prompt')
-        }
-        setDeferredPrompt(null) // Limpia el evento después de usarlo
-        setIsInstallable(false) // Oculta el botón de instalación
-      })
-    }
-  }
-
-  return { isInstallable, installPWA }
-}

package/src/hooks/usePortFetcher/index.ts

@@ -1,33 +0,0 @@
-import { useEffect, useState } from 'react'
-
-/**
- * Custom hook to fetch a free port from the API route `/api/port`.
- *
- * @returns {Object} Object containing the fetched port and loading/error states
- */
-export const usePortFetcher = () => {
-  const [port, setPort] = useState<string | null>(null)
-  const [loading, setLoading] = useState(true)
-  const [error, setError] = useState<string | null>(null)
-
-  useEffect(() => {
-    const fetchPort = async () => {
-      try {
-        const res = await fetch('/api/port')
-        if (!res.ok) throw new Error('Failed to fetch port')
-
-        const data = await res.json()
-        setPort(data.port)
-      } catch (err: any) {
-        console.error('Error fetching port:', err)
-        setError(err.message || 'Unknown error')
-      } finally {
-        setLoading(false)
-      }
-    }
-
-    fetchPort()
-  }, [])
-
-  return { port, loading, error }
-}

package/src/hooks/usePrintSaleTicket/index.ts

@@ -1,64 +0,0 @@
-// usePrintSaleTicket.ts
-import { gql, useMutation, MutationHookOptions } from '@apollo/client'
-import { useCallback } from 'react'
-
-/* ------------------------------
-   TYPES
------------------------------- */
-
-export interface PrintSaleTicketResponse {
-  printSaleTicket: {
-    message: string
-    success: boolean
-    data: string | null
-    __typename: string
-  }
-}
-
-export interface PrintSaleTicketVars {
-  saleId: string
-}
-
-/* ------------------------------
-   GQL
------------------------------- */
-
-const PRINT_SALE_TICKET = gql`
-  mutation printSaleTicket($saleId: ID!) {
-    printSaleTicket(saleId: $saleId) {
-      message
-      success
-      data
-      __typename
-    }
-  }
-`
-
-/* ------------------------------
-   HOOK
------------------------------- */
-
-export function usePrintSaleTicket(
-  options?: MutationHookOptions<PrintSaleTicketResponse, PrintSaleTicketVars>
-) {
-  const [runMutation, { loading, data, error }] = useMutation<
-    PrintSaleTicketResponse,
-    PrintSaleTicketVars
-  >(PRINT_SALE_TICKET, options)
-
-  const printSale = useCallback(
-    async (saleId: string) => {
-      const result = await runMutation({
-        variables: { saleId }
-      })
-      return result.data?.printSaleTicket
-    },
-    [runMutation]
-  )
-
-  return [printSale, {
-    loading,
-    data: data?.printSaleTicket,
-    error
-  }]
-}

package/src/hooks/useProductsFood/index.js

@@ -1,253 +0,0 @@
-import {
-  useLazyQuery,
-  useMutation,
-  useQuery
-} from '@apollo/client'
-import { useState } from 'react'
-import {
-  GET_ALL_EXTRA_PRODUCT,
-  GET_ALL_PRODUCT_STORE,
-  GET_EXTRAS_PRODUCT_FOOD_OPTIONAL,
-  GET_ONE_PRODUCTS_FOOD,
-  UPDATE_PRODUCT_FOOD
-} from './queriesStore'
-export * from './useEditProduct'
-
-export const useProductsFood = ({
-  categories = [],
-  desc = [],
-  fetchPolicy = 'cache-and-network',
-  fromDate = null,
-  gender = [],
-  max = 100,
-  min = null,
-  pState,
-  search = null,
-  toDate = null,
-  dataSale = [],
-  isShopppingCard = false
-}) => {
-  const [showMore, setShowMore] = useState(500)
-
-  const { data, loading, fetchMore, refetch, error, called } = useQuery(GET_ALL_PRODUCT_STORE, {
-    fetchPolicy,
-    notifyOnNetworkStatusChange: true,
-    nextFetchPolicy: 'cache-first',
-    refetchWritePolicy: 'merge',
-    variables: {
-      categories,
-      desc,
-      // fromDate,
-      gender,
-      max,
-      min,
-      pState,
-      search
-      // toDate
-    }
-  })
-
-  const productsFood = data?.productFoodsAll?.data ?? []
-
-  if (!isShopppingCard) {
-    return [
-      productsFood, {
-        pagination: data?.productFoodsAll?.pagination || {},
-        loading: called ? false : loading,
-        error,
-        showMore,
-        fetchMore,
-        refetch,
-        setShowMore
-      }
-    ]
-  }
-
-  const updatedProductsFood = productsFood.map(product => ({
-    ...product,
-    existsInSale: Array.isArray(dataSale) && dataSale.some(item => item.pId === product.pId)
-  }))
-
-  return [
-    updatedProductsFood, {
-      pagination: data?.productFoodsAll?.pagination || {},
-      loading: called ? false : loading,
-      error,
-      showMore,
-      fetchMore,
-      refetch,
-      setShowMore
-    }
-  ]
-}
-
-export const useDeleteProductsFood = ({
-  sendNotification = (arg) => { return arg },
-  onSuccess = (arg) => { return arg }
-} = {
-  sendNotification: (arg) => { return arg },
-  onSuccess: (arg) => { return arg }
-}) => {
-  const [updateProductFoods, { data, loading, error }] = useMutation(UPDATE_PRODUCT_FOOD)
-
-  const handleDelete = async product => {
-    const { pId, pState } = product || {}
-    return await updateProductFoods({
-      variables: {
-        input: {
-          pId,
-          pState
-        }
-      },
-      update (cache) {
-        cache.modify({
-          fields: {
-            productFoodsAll (dataOld = []) {
-              if (Array.isArray(dataOld) && dataOld?.length) {
-                const product = dataOld?.find((product) => {
-                  return product.pId === pId
-                })
-                if (product) {
-                  const newProductList = dataOld?.filter((product) => {
-                    return product?.pId !== pId
-                  })
-                  return newProductList
-                }
-                return dataOld
-              } else {
-                return []
-              }
-            }
-          }
-        })
-        cache.modify({
-          fields: {
-            getCatProductsWithProduct (dataOld = []) {
-              if (Array.isArray(dataOld?.catProductsWithProduct) && dataOld?.catProductsWithProduct?.length) {
-                const newListCatProducts = dataOld?.catProductsWithProduct?.map((categories) => {
-                  return {
-                    ...categories,
-                    productFoodsAll: categories?.productFoodsAll?.length
-                      ? categories?.productFoodsAll?.filter((product) => {
-                        return product?.pId !== pId
-                      })
-                      : []
-                  }
-                })
-                return {
-                  catProductsWithProduct: newListCatProducts,
-                  totalCount: newListCatProducts?.length
-                }
-              }
-              return dataOld
-            }
-          }
-        })
-      }
-    }).then(() => {
-      onSuccess()
-      return sendNotification({
-        title: 'Éxito',
-        description: pState === 1 ? 'El producto se ha eliminado correctamente' : 'El producto se ha restaurando correctamente',
-        backgroundColor: 'success'
-      })
-    }).catch((e) => {
-      console.log(e)
-      return sendNotification({
-        title: 'Error',
-        description: 'Ocurrió un error',
-        backgroundColor: 'error'
-      })
-    })
-  }
-  return {
-    handleDelete, data, loading, error
-  }
-}
-
-export const useExtProductFoodsAll = () => {
-  const [ExtProductFoodsAll,
-    {
-      data,
-      loading,
-      error
-    }
-  ] = useLazyQuery(GET_ALL_EXTRA_PRODUCT)
-
-  const handleExtProductFoodsAll = (pId) => {
-    if (!pId) return
-    return ExtProductFoodsAll({
-      variables: {
-        pId
-      }
-    })
-  }
-  return [handleExtProductFoodsAll,
-    {
-      data: data?.ExtProductFoodsAll || [],
-      loading,
-      error
-    }
-  ]
-}
-
-export const useExtProductFoodsOptionalAll = () => {
-  const [ExtProductFoodsOptionalAll,
-    {
-      data,
-      loading,
-      error
-    }] = useLazyQuery(GET_EXTRAS_PRODUCT_FOOD_OPTIONAL)
-
-  const handleGetExtProductFood = (pId) => {
-    try {
-      ExtProductFoodsOptionalAll({
-        variables: {
-          pId
-        }
-      })
-    } catch (e) {
-      console.log(e)
-    }
-  }
-  return [handleGetExtProductFood,
-    {
-      data: data?.ExtProductFoodsOptionalAll || [],
-      loading,
-      error
-    }]
-}
-
-export const useGetOneProductsFood = ({ fetchOnlyProduct = false } = {}) => {
-  const [productFoodsOne,
-    {
-      data,
-      loading,
-      error
-    }] = useLazyQuery(GET_ONE_PRODUCTS_FOOD)
-
-  const [handleGetExtProductFood, { data: dataOptional }] = useExtProductFoodsOptionalAll()
-  const [handleExtProductFoodsAll, { data: dataExtra }] = useExtProductFoodsAll()
-  const handleGetOneProduct = async (food) => {
-    const { pId } = food
-    try {
-      productFoodsOne({
-        variables: {
-          pId
-        }
-      })
-      if (!fetchOnlyProduct) handleGetExtProductFood(pId)
-      if (!fetchOnlyProduct) handleExtProductFoodsAll(pId)
-    } catch (e) {
-      console.log(e)
-    }
-  }
-  const handleFunctionQuery = fetchOnlyProduct ? productFoodsOne : handleGetOneProduct
-  return [handleFunctionQuery, {
-    data: data?.productFoodsOne || {},
-    dataExtra,
-    dataOptional,
-    loading,
-    error
-  }]
-}