npm-pkg-hook 1.3.9 → 1.4.0

package/src/hooks/usePWAInstall/index.ts

@@ -0,0 +1,38 @@
+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/usePaymentMethod/index.ts

@@ -0,0 +1,3 @@
+export * from './useCreatePaymentMethod'
+export * from './useGetAllPaymentMethods'
+export * from './useGetPaymentMethod'

package/src/hooks/usePaymentMethod/paymentMethod.gql.ts

@@ -0,0 +1,62 @@
+import { gql } from '@apollo/client'
+
+export const GET_PAYMENT_METHOD = gql`
+  query getPaymentMethod($payId: ID!) {
+    getPaymentMethod(payId: $payId) {
+      payId
+      name
+      icon
+      state
+      paymentPriority
+      createdAt
+      updatedAt
+    }
+  }
+`
+
+export const GET_ALL_PAYMENT_METHODS = gql`
+  query getAllPaymentMethods {
+    getAllPaymentMethods {
+      payId
+      name
+      icon
+      state
+      paymentPriority
+      createdAt
+      updatedAt
+    }
+  }
+`
+
+export const CREATE_PAYMENT_METHOD = gql`
+  mutation createPaymentMethod($input: CreatePaymentMethodInput!) {
+    createPaymentMethod(input: $input) {
+      payId
+      name
+      icon
+      state
+      paymentPriority
+      createdAt
+      updatedAt
+    }
+  }
+`
+
+export const UPDATE_PAYMENT_METHOD = gql`
+  mutation updatePaymentMethod($payId: ID!, $input: UpdatePaymentMethodInput!) {
+    updatePaymentMethod(payId: $payId, input: $input) {
+      payId
+      name
+      icon
+      state
+      paymentPriority
+      updatedAt
+    }
+  }
+`
+
+export const DELETE_PAYMENT_METHOD = gql`
+  mutation deletePaymentMethod($payId: ID!) {
+    deletePaymentMethod(payId: $payId)
+  }
+`

package/src/hooks/usePaymentMethod/paymentMethod.types.ts

@@ -0,0 +1,28 @@
+export interface PaymentMethod {
+  payId: string
+  name: string
+  icon: string
+  state: string
+  paymentPriority: number
+  createdAt?: string
+  updatedAt?: string
+}
+
+export interface CreatePaymentMethodInput {
+  payId: string
+  name: string
+  icon: string
+  state: string
+  paymentPriority: number
+  mIcon?: number
+  mState?: number
+}
+
+export interface UpdatePaymentMethodInput {
+  name?: string
+  icon?: string
+  state?: string
+  paymentPriority?: number
+  mIcon?: number
+  mState?: number
+}

package/src/hooks/usePaymentMethod/useCreatePaymentMethod/index.ts

@@ -0,0 +1,25 @@
+'use client'
+
+import { useMutation } from '@apollo/client'
+
+import { CREATE_PAYMENT_METHOD, GET_ALL_PAYMENT_METHODS } from '../paymentMethod.gql'
+import { CreatePaymentMethodInput, PaymentMethod } from '../paymentMethod.types'
+
+
+export const useCreatePaymentMethod = () => {
+  const [createPaymentMethod, { loading, error }] = useMutation<
+        { createPaymentMethod: PaymentMethod },
+        { input: CreatePaymentMethodInput }
+    >(CREATE_PAYMENT_METHOD, {
+      refetchQueries: [{ query: GET_ALL_PAYMENT_METHODS }]
+    })
+
+  const handleCreate = async (input: CreatePaymentMethodInput) => {
+    const res = await createPaymentMethod({ variables: { input } })
+    return res.data?.createPaymentMethod
+  }
+  return [handleCreate, {
+    loading,
+    error
+  }]
+}

package/src/hooks/usePaymentMethod/useGetAllPaymentMethods/index.ts

@@ -0,0 +1,19 @@
+'use client'
+
+import { useQuery } from '@apollo/client'
+
+import { GET_ALL_PAYMENT_METHODS } from '../paymentMethod.gql'
+import { PaymentMethod } from '../paymentMethod.types'
+
+export const useGetAllPaymentMethods = () => {
+  const { data, loading, error, refetch } = useQuery<{
+    getAllPaymentMethods: PaymentMethod[]
+  }>(GET_ALL_PAYMENT_METHODS)
+
+  return {
+    data: data?.getAllPaymentMethods ?? [],
+    loading,
+    error,
+    refetch
+  }
+}

package/src/hooks/usePaymentMethod/useGetPaymentMethod/index.ts

@@ -0,0 +1,26 @@
+'use client'
+
+import { useQuery } from '@apollo/client'
+
+import { GET_PAYMENT_METHOD } from '../paymentMethod.gql'
+import { PaymentMethod } from '../paymentMethod.types'
+
+interface Props {
+  payId: string
+}
+
+export const useGetPaymentMethod = ({ payId }: Props) => {
+  const { data, loading, error } = useQuery<{ getPaymentMethod: PaymentMethod }>(
+    GET_PAYMENT_METHOD,
+    {
+      variables: { payId },
+      skip: !payId
+    }
+  )
+
+  return {
+    paymentMethod: data?.getPaymentMethod,
+    loading,
+    error
+  }
+}

package/src/hooks/usePortFetcher/index.ts

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,68 @@
+// 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
+------------------------------ */
+
+/**
+ *
+ * @param options
+ */
+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.ts

@@ -0,0 +1,341 @@
+import {
+  useApolloClient,
+  useLazyQuery,
+  useMutation,
+  useQuery
+} from '@apollo/client'
+import { useCallback, useMemo, useState } from 'react'
+
+import { useStockUpdatedAllSubscription } from '../useStock'
+
+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'
+
+interface UseProductsFoodOptions {
+  idStore?: string | null
+  categories?: string[]
+  desc?: string[]
+  fetchPolicy?: 'cache-first' | 'cache-and-network' | 'network-only' | 'no-cache'
+  fromDate?: string | null
+  gender?: string[]
+  max?: number
+  min?: number | null
+  pState?: number
+  search?: string | null
+  toDate?: string | null
+  dataSale?: Array<{ pId: string }>
+  isShopppingCard?: boolean
+  callback: (args: any) => void
+}
+export const useProductsFood = ({
+  idStore = null,
+  categories = [],
+  desc = [],
+  fetchPolicy = 'cache-and-network',
+  fromDate = null,
+  gender = [],
+  max = 100,
+  min = null,
+  pState,
+  search = null,
+  toDate = null,
+  dataSale = [],
+  isShopppingCard = false,
+  callback
+}: UseProductsFoodOptions) => {
+  const [showMore, setShowMore] = useState(500)
+  const client = useApolloClient()
+  const variables = useMemo(() => {return {
+    categories,
+    desc,
+    gender,
+    max,
+    min,
+    pState,
+    search
+  }}, [categories, desc, gender, max, min, pState, search, callback])
+
+  const { data, loading, fetchMore, refetch, error, called } = useQuery(GET_ALL_PRODUCT_STORE, {
+    onCompleted: (data) => {
+      callback(data)
+    },
+    fetchPolicy,
+    notifyOnNetworkStatusChange: true,
+    nextFetchPolicy: 'cache-first',
+    refetchWritePolicy: 'merge',
+    variables
+  })
+
+  const productsFood = data?.productFoodsAll?.data ?? []
+  /**
+   * Callback when subscription emits a stock update.
+   * Updates Apollo cache for GET_ALL_PRODUCT_STORE with same variables so UI updates reactively.
+   */
+  const onStockUpdated = useCallback(
+    (payload: any) => {
+      try {
+        if (!payload || !payload.pId) return
+
+        // Try to read current query result from cache (may throw if not present)
+        const cached = client.readQuery({
+          query: GET_ALL_PRODUCT_STORE,
+          variables
+        })
+
+        if (!cached?.productFoodsAll?.data) return
+
+        const updatedData = cached.productFoodsAll.data.map((prod: any) => {
+          if (!prod || prod.pId !== payload.pId) return prod
+
+          // update stock in-place preserving other fields; prefer 'stock' field name but keep others
+          return {
+            ...prod,
+            // if your product model uses another field name replace 'stock' accordingly
+            stock: payload.newStock,
+            previousStock: payload.previousStock ?? prod.previousStock ?? null,
+            // keep a meta object with event info for UI if needed
+            lastStockEvent: {
+              event: payload.event,
+              meta: payload.meta
+            }
+          }
+        })
+
+        // Write back to cache so queries using GET_ALL_PRODUCT_STORE update automatically
+        client.writeQuery({
+          query: GET_ALL_PRODUCT_STORE,
+          variables,
+          data: {
+            ...cached,
+            productFoodsAll: {
+              ...cached.productFoodsAll,
+              data: updatedData
+            }
+          }
+        })
+      } catch (err) {
+        // be silent but log for debugging
+        // (don't throw — subscription should not break the app)
+         
+        console.error('useProductsFood: failed updating cache from subscription', err)
+      }
+    },
+    // include all variables that affect the cache key
+    [client, JSON.stringify(variables)]
+  )
+  // Attach subscription only if idStore is provided (the subscription hook internally skips when idStore is falsy)
+  useStockUpdatedAllSubscription(idStore ?? '', onStockUpdated)
+
+  if (!isShopppingCard) {
+    return [
+      productsFood, {
+        pagination: data?.productFoodsAll?.pagination || {},
+        loading: called ? false : loading,
+        error,
+        showMore,
+        fetchMore,
+        refetch,
+        setShowMore
+      }
+    ]
+  }
+
+  const updatedProductsFood = productsFood.map((product: any) => {return {
+    ...product,
+    existsInSale: Array.isArray(dataSale) && dataSale.some(item => {return 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
+              } 
+              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
+    }]
+}
+
+interface UseGetOneProductsFoodOptions {
+  fetchOnlyProduct?: boolean
+}
+export const useGetOneProductsFood = ({ fetchOnlyProduct = false }: UseGetOneProductsFoodOptions = {}) => {
+  const [productFoodsOne,
+    {
+      data,
+      loading,
+      error
+    }] = useLazyQuery(GET_ONE_PRODUCTS_FOOD)
+
+  const [handleGetExtProductFood, { data: dataOptional }] = useExtProductFoodsOptionalAll()
+  const [handleExtProductFoodsAll, { data: dataExtra }] = useExtProductFoodsAll()
+  const handleGetOneProduct = async (food: any) => {
+    const { pId } = food
+    try {
+      const product = await productFoodsOne({
+        variables: {
+          pId
+        }
+      })
+      if (!fetchOnlyProduct) handleGetExtProductFood(pId)
+      if (!fetchOnlyProduct) handleExtProductFoodsAll(pId)
+      return product
+    } catch (e) {
+      console.log(e)
+    }
+  }
+  const handleFunctionQuery = fetchOnlyProduct ? productFoodsOne : handleGetOneProduct
+  return [handleFunctionQuery, {
+    data: data?.productFoodsOne || {},
+    dataExtra,
+    dataOptional,
+    loading,
+    error
+  }]
+}