npm-pkg-hook 1.3.9 → 1.4.0

package/src/hooks/useIncomingOrders/queries.ts

@@ -0,0 +1,87 @@
+import { gql } from '@apollo/client'
+
+export const GET_ALL_INCOMING_ORDERS = gql`
+  query getAllIncomingToDayOrders($statusOrder: Int, $idStore: ID) {
+    getAllIncomingToDayOrders(statusOrder: $statusOrder, idStore: $idStore) {
+      pdpId
+      pCodeRef
+      idStore
+      pPDate
+      channel
+      pSState
+      pDatCre
+      pDatMod
+      pPRecoger
+      payId
+      pdpId
+      totalProductsPrice
+      locationUser
+      getAllPedidoStore {
+        pdpId
+        idStore
+        pCodeRef
+        ShoppingCard
+        getAllShoppingCard {
+          ShoppingCard
+          cantProducts
+          priceProduct
+          refCodePid
+          subProductsId
+          comments
+          pId
+          salesExtProductFoodOptional {
+            pId
+            opExPid
+            OptionalProName
+            state
+            code
+            required
+            numbersOptionalOnly
+            pDatCre
+            pDatMod
+            saleExtProductFoodsSubOptionalAll {
+              pId
+              opExPid
+              idStore
+              opSubExPid
+              OptionalSubProName
+              exCodeOptionExtra
+              exCode
+              state
+              pDatCre
+              pDatMod
+            }
+          }
+          ExtProductFoodsAll {
+            pId
+            exPid
+            exState
+            extraName
+            extraPrice
+            newExtraPrice
+            quantity
+            state
+            pDatCre
+            pDatMod
+          }
+          productFood {
+            pId
+            carProId
+            colorId
+            idStore
+            pName
+            ProPrice
+            ProDescuento
+            ProDescription
+            ValueDelivery
+            ProImage
+            ProStar
+            pState
+            pDatCre
+            pDatMod
+          }
+        }
+      }
+    }
+  }
+`

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

@@ -70,7 +70,7 @@ export const useIntersectionObserver = ({
     }
     return () => {
       if (disconnect) {
-        // eslint-disable-next-line no-void
+         
         observer === null || observer === void 0 ? void 0 : observer.disconnect(refEl)
       }
       if (!disconnect) {

package/src/hooks/useInventory/index.ts

@@ -0,0 +1,2 @@
+export * from './useGetProductsInStock'
+export * from './useUpdateManageStock'

package/src/hooks/useInventory/queries.ts

@@ -0,0 +1,58 @@
+import { gql } from '@apollo/client'
+
+export const GET_PRODUCTS_IN_STOCK = gql`
+query getProductsInStock($limit: Int, $offset: Int) {
+  getProductsInStock(limit: $limit, offset: $offset) {
+        pId
+      sizeId #Talla
+      colorId #Color
+      carProId #Categoria a la cual pertenece el producto
+      caId
+      cId #Country
+      dId #Department
+      ctId #Cuidad
+      fId #Características
+      pName
+      getOneTags {
+        tgId
+        idUser
+        idStore
+        pId
+        nameTag
+      }
+      ProPrice
+      ProDescuento
+      free
+      ProUniDisponibles
+      ProDescription
+      ProProtegido
+      ProAssurance
+      ValueDelivery
+      ProStar
+      sTateLogistic
+      ProImage
+      ProWidth
+      ProHeight
+      ProLength
+      ProWeight
+      ProQuantity
+      ProOutstanding
+      pDatCre
+      pDatMod
+      ProDelivery
+      ProVoltaje
+      pState
+      feat {
+        fId
+        thpId
+        hpqrQuestion
+      }
+      area {
+        aId
+        aName
+      }
+       
+  }
+}
+
+`

package/src/hooks/useInventory/useGetProductsInStock.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@apollo/client'
+
+import { GET_PRODUCTS_IN_STOCK } from './queries'
+
+export const useGetProductsInStock = (storeId) => {
+  const { data, loading, error } = useQuery(GET_PRODUCTS_IN_STOCK, {
+    variables: { storeId },
+    skip: !storeId
+  })
+
+  return {
+    data: data?.getProductsInStock || [],
+    loading,
+    error
+  }
+}

package/src/hooks/useInventory/useUpdateManageStock.ts

@@ -0,0 +1,41 @@
+import { gql, useMutation } from '@apollo/client'
+
+/**
+ * GraphQL Mutation for updating stock and manageStock
+ */
+const UPDATE_MANAGE_STOCK = gql`
+  mutation UpdateManageStock($input: InputManageStock) {
+    updateManageStock(input: $input) {
+      success
+      message
+      data {
+        pId
+        manageStock
+      }
+    }
+  }
+`
+
+/**
+ * Custom hook to update stock and manageStock
+ * @returns {object} { updateManageStock, data, loading, error }
+ */
+export const useUpdateManageStock = () => {
+  const [updateManageStockMutation, { data, loading, error }] = useMutation(UPDATE_MANAGE_STOCK)
+
+  /**
+   * Function to call the mutation with given input
+   * @param {Object} input - { pId, stock, manageStock }
+   * @returns {Promise<Object>} Mutation response
+   */
+  const updateManageStock = async (input) => {
+    try {
+      const { data } = await updateManageStockMutation({ variables: { input } })
+      return data?.updateManageStock
+    } catch (err) {
+      return { success: false, message: err.message }
+    }
+  }
+
+  return [updateManageStock, { data, loading, error }]
+}

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

@@ -32,6 +32,9 @@ export const useLazyScript = (src, delay = null) => {
     }
 
     // code to inject script
+    /**
+     *
+     */
     function injectScript () {
       script = document.createElement('script')
       script.src = src

package/src/hooks/useLocalBackendIp/index.ts

@@ -0,0 +1,34 @@
+import { useQuery, gql } from '@apollo/client'
+
+/**
+ * GraphQL query to get the local IP of the backend server.
+ */
+const GET_LOCAL_BACKEND_IP = gql`
+  query GetLocalBackendIp {
+    getLocalBackendIp
+  }
+`
+
+/**
+ * Custom hook to fetch the local IP address of the backend server.
+ *
+ * @returns {Object} - Contains the IP string, loading state, and error.
+ */
+export const useLocalBackendIp = () => {
+  const {
+    data,
+    loading,
+    error
+  } = useQuery(GET_LOCAL_BACKEND_IP)
+  const port = process.env.URL_ADMIN_SERVER?.split(':')?.[2]
+  const buildUrlBackend = data?.getLocalBackendIp
+    ? `http://${data.getLocalBackendIp}:${port}`
+    : null
+
+  return {
+    urlBackend: buildUrlBackend,
+    ip: data?.getLocalBackendIp || null,
+    loading,
+    error
+  }
+}

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

@@ -1,6 +1,6 @@
 import { useState } from 'react'
 
-export const useLocalStorage = (key, initialValue) => {
+export const useLocalStorage = (key: string, initialValue: string | object | any) => {
   // const { setAlertBox } = useContext(Context)
   // State to store our value
   // Pass initial state function to useState so logic is only executed once
@@ -18,7 +18,7 @@ export const useLocalStorage = (key, initialValue) => {
 
   // Return a wrapped version of useState's setter function that ...
   // ... persists the new value to localStorage.
-  const setValue = value => {
+  const setValue = (value: string | object | any) => {
     try {
       // Allow value to be a function so we have same API as useState
       const valueToStore =
@@ -33,4 +33,4 @@ export const useLocalStorage = (key, initialValue) => {
   }
 
   return [storedValue, setValue]
-}
+}

package/src/hooks/useLocationManager/index.ts

@@ -0,0 +1,63 @@
+import { useState } from 'react'
+
+/**
+ * Hook para gestionar la lógica de ubicaciones, valores y errores.
+ *
+ * @param {Function} getDepartments - Función para obtener los departamentos basado en el ID de país.
+ * @param {Function} getCities - Función para obtener las ciudades basado en el ID de departamento.
+ *
+ * @returns {Object} - Retorna los estados y funciones de manejo asociados.
+ */
+export function useLocationManager (getDepartments, getCities) {
+  const [values, setValues] = useState({})
+  console.log('🚀 ~ useLocationManager ~ values:', values)
+  const [errors, setErrors] = useState({})
+  const [showLocation, setShowLocation] = useState(true)
+
+  const handleUpdateValues = (name, value) => {
+    setValues(prevValues => {return { ...prevValues, [name]: value }})
+  }
+
+  const handleUpdateErrors = (name, error) => {
+    setErrors(prevErrors => {return { ...prevErrors, [name]: error }})
+  }
+
+  const handleCountrySearch = (value) => {
+    getDepartments({ variables: { cId: value } })
+  }
+
+  const handleDepartmentSearch = (value) => {
+    setValues(prevValues => {return { ...prevValues, ctId: '' }})
+    getCities({ variables: { dId: value } })
+  }
+
+  const handleChangeLocation = (e, error) => {
+    const { name, value } = e.target
+    handleUpdateValues(name, value)
+    handleUpdateErrors(name, error)
+  }
+
+  const handleChangeSearch = (e) => {
+    const { name, value } = e.target
+    switch (name) {
+      case 'countryId':
+        handleCountrySearch(value)
+        break
+      case 'code_dId':
+        handleDepartmentSearch(value)
+        break
+      default:
+        break
+    }
+    handleChangeLocation(e)
+  }
+
+  return {
+    values,
+    errors,
+    showLocation,
+    setShowLocation,
+    handleChangeSearch,
+    setValues
+  }
+}

package/src/hooks/useLoginEmployeeInStore/index.ts

@@ -0,0 +1,38 @@
+import { gql, useMutation } from '@apollo/client'
+
+const LOGIN_EMPLOYEE_IN_STORE = gql`
+  mutation loginEmployeeInStore($eId: ID, $tenantId: String, $idStore: ID, $idUser: ID, $eEmail: String) {
+    loginEmployeeInStore(eId: $eId, tenantId: $tenantId, idStore: $idStore, idUser: $idUser, eEmail: $eEmail) {
+      success
+      message
+      token
+      idStore
+    }
+  }
+`
+
+export const useLoginEmployeeInStore = () => {
+  const [loginEmployeeInStore, { data, loading, error }] = useMutation(LOGIN_EMPLOYEE_IN_STORE)
+
+  const loginEmployee = async (idStore: string, eEmail: string) => {
+    try {
+      const response = await loginEmployeeInStore({
+        variables: {
+          idStore,
+          eEmail
+        }
+      })
+      return response.data.loginEmployeeInStore
+    } catch (err) {
+      console.error('Error during loginEmployeeInStore mutation:', err)
+      throw err
+    }
+  }
+
+  return {
+    loginEmployee,
+    data,
+    loading,
+    error
+  }
+}

package/src/hooks/useLogout/helpers/BroadcastChannel.ts

@@ -0,0 +1,74 @@
+/**
+ * Broadcast message shape
+ */
+export interface BroadcastMessage {
+  event?: string
+  data?: unknown
+  [key: string]: unknown
+}
+
+/**
+ * Receive callback type
+ */
+export type BroadcastReceiver = (message: BroadcastMessage) => void
+
+/**
+ * BroadcastChannel utility based on localStorage events.
+ * Keeps original behavior intact.
+ *
+ * @param {string} name - Channel name
+ * @returns {{
+ *   receive: (onReceive: BroadcastReceiver) => () => void
+ *   post: (message: BroadcastMessage) => void
+ * }}
+ */
+function BroadcastChannel(name: string = 'nextauth.message') {
+  return {
+    /**
+     * Listen for broadcast messages
+     * @param onReceive
+     */
+    receive: function (onReceive: BroadcastReceiver): () => void {
+      const handler = function (event: StorageEvent): void {
+        if (event.key !== name) return
+
+        const message: BroadcastMessage = JSON.parse(
+          event.newValue ?? '{}'
+        )
+
+        if (message?.event !== 'session' || !message?.data) return
+
+        onReceive(message)
+      }
+
+      window.addEventListener('storage', handler)
+
+      return function (): void {
+        window.removeEventListener('storage', handler)
+      }
+    },
+
+    /**
+     * Post a broadcast message
+     * @param message
+     */
+    post: function (message: BroadcastMessage): void {
+      if (typeof window === 'undefined') return
+
+      try {
+        localStorage.setItem(
+          name,
+          JSON.stringify({
+            ...message,
+            timestamp: Date.now()
+          })
+        )
+      } catch {
+        // localStorage may be unavailable (private mode, Safari < 11, etc.)
+        // Messages are silently dropped to preserve original behavior.
+      }
+    }
+  }
+}
+
+export { BroadcastChannel }

package/src/hooks/useLogout/helpers/apiBaseUrl.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param __NEXTAUTH
+ */
+export function apiBaseUrl (__NEXTAUTH) {
+  if (typeof window === 'undefined') {
+    // Return absolute path when called server side
+    return `${__NEXTAUTH.baseUrlServer}${__NEXTAUTH.basePathServer}`
+  }
+  // Return relative path when called client side
+  return __NEXTAUTH.basePath
+}

package/src/hooks/useLogout/helpers/fetchData.ts

@@ -0,0 +1,37 @@
+import { apiBaseUrl } from './apiBaseUrl'
+
+/**
+ *
+ * @param path
+ * @param __NEXTAUTH
+ * @param logger
+ * @param root0
+ * @param root0.ctx
+ * @param root0.req
+ */
+async function fetchData (path, __NEXTAUTH, logger, { ctx, req } = {}) {
+  const url = `${apiBaseUrl(__NEXTAUTH)}/${path}`
+  try {
+    const options = {
+      headers: {
+        'Content-Type': 'application/json',
+        ...(req?.headers?.cookie ? { cookie: req.headers.cookie } : {})
+      }
+    }
+
+    if (req?.body) {
+      options.body = JSON.stringify(req.body)
+      options.method = 'POST'
+    }
+
+    const res = await fetch(url, options)
+    const data = await res.json()
+    if (!res.ok) throw data
+    return Object.keys(data).length > 0 ? data : null // Return null if data is empty
+  } catch (error) {
+    logger.error('CLIENT_FETCH_ERROR', { error, url })
+    return null
+  }
+}
+
+export { fetchData }

package/src/hooks/useLogout/helpers/getCsrfToken.ts

@@ -0,0 +1,37 @@
+import { fetchData } from './fetchData'
+import _logger, { proxyLogger } from './logger'
+import { parseUrl } from './parseUrl'
+
+const __NEXTAUTH = {
+  baseUrl: parseUrl(process.env.NEXTAUTH_URL || process.env.VERCEL_URL).origin,
+  basePath: parseUrl(process.env.NEXTAUTH_URL).path,
+  baseUrlServer: parseUrl(
+    process.env.NEXTAUTH_URL_INTERNAL ||
+        process.env.NEXTAUTH_URL ||
+        process.env.VERCEL_URL
+  ).origin,
+  basePathServer: parseUrl(
+    process.env.NEXTAUTH_URL_INTERNAL || process.env.NEXTAUTH_URL
+  ).path,
+  _lastSync: 0,
+  _session: undefined,
+  _getSession: () => {}
+}
+const logger = proxyLogger(_logger, __NEXTAUTH.basePath)
+
+/**
+ *
+ * @param params
+ * @param params.callbackUrl
+ */
+export async function getCsrfToken (params: {
+  callbackUrl?: string
+} = {}): Promise<string | undefined> {
+  const response = await fetchData(
+    'csrf',
+    __NEXTAUTH,
+    logger,
+    params
+  )
+  return response?.csrfToken
+}

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

@@ -0,0 +1,65 @@
+import { apiBaseUrl } from './apiBaseUrl'
+import { BroadcastChannel } from './BroadcastChannel'
+import { getCsrfToken } from './getCsrfToken'
+import { parseUrl } from './parseUrl'
+
+const broadcast = BroadcastChannel()
+
+export const __NEXTAUTH = {
+  baseUrl: parseUrl(process.env.NEXTAUTH_URL || process.env.VERCEL_URL).origin,
+  basePath: parseUrl(process.env.NEXTAUTH_URL).path,
+  baseUrlServer: parseUrl(
+    process.env.NEXTAUTH_URL_INTERNAL ||
+    process.env.NEXTAUTH_URL ||
+    process.env.VERCEL_URL
+  ).origin,
+  basePathServer: parseUrl(
+    process.env.NEXTAUTH_URL_INTERNAL || process.env.NEXTAUTH_URL
+  ).path,
+  _lastSync: 0,
+  _session: undefined,
+  _getSession: ({ ...args }) => { }
+}
+
+/**
+ *
+ * @param options
+ */
+export async function signOutAuth(options: {
+  callbackUrl?: string
+  redirect?: boolean
+  reload?: boolean
+} | undefined = undefined
+): Promise<{ url: string } | void> {
+  const { callbackUrl = window.location.href, reload = true } = options ?? {}
+  const baseUrl = apiBaseUrl(__NEXTAUTH)
+  const fetchOptions = {
+    method: 'post',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded'
+    },
+    // @ts-expect-error
+    body: new URLSearchParams({
+      csrfToken: await getCsrfToken(),
+      callbackUrl,
+      json: true
+    })
+  }
+  const res = await fetch(`${baseUrl}/signout`, fetchOptions)
+  const data = await res.json()
+
+  broadcast.post({ event: 'session', data: { trigger: 'signout' } })
+  if (!reload) {
+    await __NEXTAUTH._getSession({ event: 'storage' })
+    return data
+  }
+  if (options?.redirect ?? true) {
+    const url = data.url ?? callbackUrl
+    window.location.href = url
+    // If url contains a hash, the browser does not reload the page. We reload manually
+    if (url.includes('#') && !reload) window.location.reload()
+    return
+  }
+  await __NEXTAUTH._getSession({ event: 'storage' })
+  return data
+}