npm-pkg-hook 1.12.4 → 1.12.8

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

@@ -2,7 +2,8 @@ import { useMutation } from '@apollo/client'
 import {
   useRef,
   useState
-} from 'react'
+} from 'react'
+
 import {
   CREATE_BANNER_STORE,
   CREATE_LOGO,
@@ -10,7 +11,8 @@ import {
   DELETE_ONE_LOGO_STORE,
   GET_ONE_BANNER_STORE
 } from '../useProductsFood/queriesStore'
-import { GET_ONE_STORE } from '../useStore/queries'
+import { GET_ONE_STORE } from '../useStore/queries'
+
 import { color } from './utils'
 export * from './queries'
 
@@ -107,9 +109,9 @@ export const useImageStore = ({ idStore, sendNotification = () => { } } = {}) =>
       setPreviewImg(
         files.length
           ? {
-              src: URL.createObjectURL(files[0]),
-              alt: files[0].name
-            }
+            src: URL.createObjectURL(files[0]),
+            alt: files[0].name
+          }
           : initialState
       )
       registerBanner({

package/src/hooks/useImagesStore/{queries.js → queries.ts}

@@ -116,7 +116,7 @@ export const GET_MIN_PEDIDO = gql`
   }
 `
 
-// eslint-disable-next-line camelcase
+ 
 export const GET_All_RATING_STORE = gql`
   query getAllRating($idStore: ID) {
     getAllRating(idStore: $idStore) {

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

@@ -1,4 +1,5 @@
-import { useQuery } from '@apollo/client'
+import { useQuery } from '@apollo/client'
+
 import { GET_ALL_INCOMING_ORDERS } from './queries' // Asegúrate de importar tu consulta GraphQL
 
 export const useIncomingOrders = ({ statusOrder, idStore }) => {

package/src/hooks/useIncomingOrders/{queries.js → queries.ts}

@@ -12,7 +12,7 @@ export const GET_ALL_INCOMING_ORDERS = gql`
       pDatCre
       pDatMod
       pPRecoger
-      payMethodPState
+      payId
       pdpId
       totalProductsPrice
       locationUser

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/{queries.js → queries.ts}

@@ -1,4 +1,4 @@
-import { useQuery, gql } from "@apollo/client";
+import { gql } from '@apollo/client'
 
 export const GET_PRODUCTS_IN_STOCK = gql`
 query getProductsInStock($limit: Int, $offset: Int) {
@@ -55,4 +55,4 @@ query getProductsInStock($limit: Int, $offset: Int) {
   }
 }
 
-`
+`

package/src/hooks/useInventory/{useGetProductsInStock.js → useGetProductsInStock.ts}

@@ -1,4 +1,5 @@
-import { useQuery } from '@apollo/client'
+import { useQuery } from '@apollo/client'
+
 import { GET_PRODUCTS_IN_STOCK } from './queries'
 
 export const useGetProductsInStock = (storeId) => {

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/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.js → index.ts}

@@ -15,11 +15,11 @@ export function useLocationManager (getDepartments, getCities) {
   const [showLocation, setShowLocation] = useState(true)
 
   const handleUpdateValues = (name, value) => {
-    setValues(prevValues => ({ ...prevValues, [name]: value }))
+    setValues(prevValues => {return { ...prevValues, [name]: value }})
   }
 
   const handleUpdateErrors = (name, error) => {
-    setErrors(prevErrors => ({ ...prevErrors, [name]: error }))
+    setErrors(prevErrors => {return { ...prevErrors, [name]: error }})
   }
 
   const handleCountrySearch = (value) => {
@@ -27,7 +27,7 @@ export function useLocationManager (getDepartments, getCities) {
   }
 
   const handleDepartmentSearch = (value) => {
-    setValues(prevValues => ({ ...prevValues, ctId: '' }))
+    setValues(prevValues => {return { ...prevValues, ctId: '' }})
     getCities({ variables: { dId: value } })
   }
 

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

@@ -14,7 +14,7 @@ const LOGIN_EMPLOYEE_IN_STORE = gql`
 export const useLoginEmployeeInStore = () => {
   const [loginEmployeeInStore, { data, loading, error }] = useMutation(LOGIN_EMPLOYEE_IN_STORE)
 
-  const loginEmployee = async (idStore, eEmail) => {
+  const loginEmployee = async (idStore: string, eEmail: string) => {
     try {
       const response = await loginEmployeeInStore({
         variables: {

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.js → apiBaseUrl.ts}

@@ -1,3 +1,7 @@
+/**
+ *
+ * @param __NEXTAUTH
+ */
 export function apiBaseUrl (__NEXTAUTH) {
   if (typeof window === 'undefined') {
     // Return absolute path when called server side

package/src/hooks/useLogout/helpers/{fetchData.js → fetchData.ts}

@@ -1,6 +1,15 @@
 import { apiBaseUrl } from './apiBaseUrl'
 
-async function fetchData(path, __NEXTAUTH, logger, { ctx, req } = {}) {
+/**
+ *
+ * @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 = {

package/src/hooks/useLogout/helpers/{getCsrfToken.js → getCsrfToken.ts}

@@ -19,7 +19,14 @@ const __NEXTAUTH = {
 }
 const logger = proxyLogger(_logger, __NEXTAUTH.basePath)
 
-export async function getCsrfToken (params) {
+/**
+ *
+ * @param params
+ * @param params.callbackUrl
+ */
+export async function getCsrfToken (params: {
+  callbackUrl?: string
+} = {}): Promise<string | undefined> {
   const response = await fetchData(
     'csrf',
     __NEXTAUTH,

package/src/hooks/useLogout/helpers/{index.js → index.ts}

@@ -1,7 +1,7 @@
 import { apiBaseUrl } from './apiBaseUrl'
+import { BroadcastChannel } from './BroadcastChannel'
 import { getCsrfToken } from './getCsrfToken'
 import { parseUrl } from './parseUrl'
-import { BroadcastChannel } from './BroadcastChannel'
 
 const broadcast = BroadcastChannel()
 
@@ -10,18 +10,27 @@ export const __NEXTAUTH = {
   basePath: parseUrl(process.env.NEXTAUTH_URL).path,
   baseUrlServer: parseUrl(
     process.env.NEXTAUTH_URL_INTERNAL ||
-      process.env.NEXTAUTH_URL ||
-      process.env.VERCEL_URL
+    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: () => {}
+  _getSession: ({ ...args }) => { }
 }
 
-export async function signOutAuth (options) {
+/**
+ *
+ * @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 = {
@@ -49,7 +58,6 @@ export async function signOutAuth (options) {
     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()
-    // @ts-expect-error
     return
   }
   await __NEXTAUTH._getSession({ event: 'storage' })

package/src/hooks/useLogout/helpers/{logger.js → logger.ts}

@@ -1,4 +1,8 @@
-function formatError(o) {
+/**
+ *
+ * @param o
+ */
+function formatError (o) {
   if (hasErrorProperty(o)) {
     o.error = formatError(o.error)
     o.message = o.message ?? o.error.message
@@ -6,12 +10,16 @@ function formatError(o) {
   return o
 }
 
-function hasErrorProperty(x) {
-  return !!(x?.error)
+/**
+ *
+ * @param x
+ */
+function hasErrorProperty (x) {
+  return Boolean(x?.error)
 }
 
 const _logger = {
-  error(code, metadata) {
+  error (code, metadata) {
     metadata = formatError(metadata)
     console.error(
       `[next-auth][error][${code}]`,
@@ -20,18 +28,23 @@ const _logger = {
       metadata
     )
   },
-  warn(code) {
+  warn (code) {
     console.warn(
       `[next-auth][warn][${code}]`,
       `\nhttps://next-auth.js.org/warnings#${code.toLowerCase()}`
     )
   },
-  debug(code, metadata) {
+  debug (code, metadata) {
     console.log(`[next-auth][debug][${code}]`, metadata)
   }
 }
 
-export function setLogger(newLogger = {}, debug) {
+/**
+ *
+ * @param newLogger
+ * @param debug
+ */
+export function setLogger (newLogger = {}, debug) {
   if (!debug) _logger.debug = () => { }
 
   if (newLogger.error) _logger.error = newLogger.error
@@ -39,7 +52,12 @@ export function setLogger(newLogger = {}, debug) {
   if (newLogger.debug) _logger.debug = newLogger.debug
 }
 
-export function proxyLogger(logger = _logger, basePath) {
+/**
+ *
+ * @param logger
+ * @param basePath
+ */
+export function proxyLogger (logger = _logger, basePath) {
   try {
     if (typeof window === 'undefined') {
       return logger

package/src/hooks/useLogout/helpers/{parseUrl.js → parseUrl.ts}

@@ -9,8 +9,11 @@ const InternalUrl = {
   }
 }
 
-/** Function to parse a URL-like object for server-side requests/redirects */
-function parseUrl (url) {
+/**
+ * Function to parse a URL-like object for server-side requests/redirects
+ * @param url
+ */
+function parseUrl (url: string | undefined) {
   const defaultUrl = new URL('http://localhost:3000/api/auth')
 
   if (url && !url.startsWith('http')) {

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

@@ -1,22 +1,26 @@
 import { useApolloClient } from '@apollo/client'
 import { useState } from 'react'
+
 import { Cookies } from '../../cookies/index'
-import { signOutAuth } from './helpers'
 import { getCurrentDomain } from '../../utils'
-export { signOutAuth } from './helpers'
 
+import { signOutAuth } from './helpers'
+
+interface UseLogoutOptions {
+  setAlertBox?: (options: { message: string }) => { message: string }
+}
 export const useLogout = ({
   setAlertBox = ({
     message
   }) => { return { message } }
-} = {}) => {
-  const [loading, setLoading] = useState(false)
+}: UseLogoutOptions = {}) => {
+  const [loading, setLoading] = useState<boolean>(false)
   const [error, setError] = useState(false)
   const client = useApolloClient()
 
-  const eliminarCookie = async (nombreCookie) => {
+  const eliminarCookie = async (nombreCookie: string) => {
     try {
-      let domain = getCurrentDomain()
+      let domain = getCurrentDomain() as string | undefined
 
       // Si estás en entorno local, usa 'localhost' como dominio
       if (domain === 'localhost') {
@@ -26,9 +30,9 @@ export const useLogout = ({
       const expirationTime = new Date()
       expirationTime.setTime(expirationTime.getTime() - 1000) // Establece una fecha de expiración en el pasado
 
-      const formattedDomain = domain || getCurrentDomain()
+      const formattedDomain: string | undefined = typeof domain === 'string' ? domain : undefined
 
-      await Cookies.remove(nombreCookie, { domain: formattedDomain, path: '/', secure: process.env.NODE_ENV === 'production' })
+      Cookies.remove(nombreCookie, { domain: formattedDomain, path: '/', secure: process.env.NODE_ENV === 'production' })
 
       console.log('Cookie eliminada correctamente.')
     } catch (error) {
@@ -37,21 +41,24 @@ export const useLogout = ({
     }
   }
   const deleteCookie = async () => {
-    await eliminarCookie(process.env.NEXT_PUBLIC_SESSION_NAME)
-    await eliminarCookie(process.env.LOCAL_SALES_STORE)
+    await eliminarCookie(String(process.env.NEXT_PUBLIC_SESSION_NAME))
+    await eliminarCookie(String(process.env.NEXT_LOCAL_SALES_STORE))
     await eliminarCookie('restaurant')
     await eliminarCookie('usuario')
     await eliminarCookie('session')
   }
-  const onClickLogout = async ({ redirect = true } = { redirect: true }) => {
-    console.log(redirect)
+  const onClickLogout = async (params?: { redirect?: boolean }) => {
+    const redirect = params?.redirect ?? true
     try {
-      if (!redirect) return await deleteCookie()
-      setLoading(true)
+      if (redirect) {
+        setLoading(true)
+      } else {
+        return await deleteCookie()
+      }
       await deleteCookie()
       // Logout from the server
-      const port = window.location.port ? `:${window.location.port}` : ''
-      const baseUrl = `${window.location.protocol}//${window.location.hostname}${port}`
+      const port = globalThis.location.port ? `:${globalThis.location.port}` : ''
+      const baseUrl = `${globalThis.location.protocol}//${globalThis.location.hostname}${port}`
       const logoutResponse = await fetch(`${baseUrl}/api/auth/signout/`, {
         method: 'POST',
         headers: {
@@ -69,8 +76,8 @@ export const useLogout = ({
       console.log('Intentando borrar cookies...')
 
       // Eliminar la cookie process.env.NEXT_PUBLIC_SESSION_NAME
-      await eliminarCookie(process.env.NEXT_PUBLIC_SESSION_NAME)
-      Cookies.remove(process.env.LOCAL_SALES_STORE)
+      await eliminarCookie(String(process.env.NEXT_PUBLIC_SESSION_NAME))
+      Cookies.remove(String(process.env.NEXT_LOCAL_SALES_STORE))
       Cookies.remove('restaurant')
       Cookies.remove('usuario')
       Cookies.remove('session')
@@ -81,13 +88,15 @@ export const useLogout = ({
       setLoading(false)
       console.log('Cookies eliminadas y sesión cerrada con éxito')
       signOutAuth({ redirect: true, callbackUrl: '/' })
-        .catch(() => {
+        .catch((err) => {
           setError(true)
+          console.error('Error in signOutAuth:', err)
           setAlertBox({ message: 'Ocurrió un error al cerrar sesión' })
         })
-    } catch (error) {
+    } catch (err) {
       setLoading(false)
       setError(true)
+      console.error('Error al cerrar sesión:', err)
       setAlertBox({ message: 'Ocurrió un error al cerrar sesión' })
     }
   }

package/src/hooks/useManageNewOrder/helpers/{index.js → index.ts}

@@ -21,7 +21,7 @@ export function findOrderByCodeRef (data, pCodeRef) {
       if (Array.isArray(column)) {
         // Buscar el objeto por pCodeRef dentro de la columna actual
         const foundOrder = column.find(
-          (order) => order && order.pCodeRef === pCodeRef
+          (order) => {return order && order.pCodeRef === pCodeRef}
         )
         // Si se encuentra el objeto, devolverlo
         if (foundOrder) {

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

@@ -1,10 +1,12 @@
-import { useEffect, useState } from 'react'
+import { useEffect, useState } from 'react'
+
 import {
   useGetSale,
-  updateExistingOrders,
+  // updateExistingOrders,
   convertDateFormat,
   useOrdersFromStore
-} from '../../hooks'
+} from '..'
+
 import { findOrderByCodeRef, isDateInRange } from './helpers'
 
 export const useManageNewOrder = ({
@@ -39,7 +41,7 @@ export const useManageNewOrder = ({
       const dataOrder = data[KEY_STATUS_ORDER]
       if (Array.isArray(dataOrder) && dataOrder) {
         const filteredOrders = dataOrder.filter(order =>
-          isDateInRange(order?.pDatCre) && order?.pSState === 1
+        {return isDateInRange(order?.pDatCre) && order?.pSState === 1}
         ) ?? []
         setOrders(filteredOrders)
         setCountOrders(filteredOrders.length)

package/src/hooks/useManageQueryParams/index.ts

@@ -0,0 +1,120 @@
+'use client'
+
+import { useRouter, useSearchParams, useParams } from 'next/navigation'
+
+/**
+ * Generic query params map
+ */
+export type QueryParams = Record<string, string>
+
+/**
+ * Custom location interface (useful for testing or external routers)
+ */
+export interface CustomLocation {
+  query?: QueryParams
+  push?: (url: string) => void
+}
+
+/**
+ * Hook options
+ */
+export interface UseManageQueryParamsOptions {
+  location?: CustomLocation
+}
+
+/**
+ * Params getter options
+ */
+export interface GetParamsOptions {
+  param: string
+  callback?: (value: string) => void
+}
+
+/**
+ * Hook return type
+ */
+export interface UseManageQueryParamsResult {
+  getQuery: (name: string) => string
+  handleQuery: (name: string, value?: string) => void
+  handleCleanQuery: (name: string) => void
+  getParams: (options: GetParamsOptions) => string
+}
+
+/**
+ * Hook to manage query parameters in Next.js 13+ (App Router)
+ * Supports dependency injection for router/query (testing-friendly).
+ *
+ * @param {UseManageQueryParamsOptions} options
+ * @returns {UseManageQueryParamsResult}
+ */
+export const useManageQueryParams = (
+  { location }: UseManageQueryParamsOptions = {}
+): UseManageQueryParamsResult => {
+  const router = useRouter()
+  const searchParams = useSearchParams()
+  const params = useParams()
+
+  const activeQuery: QueryParams =
+    location?.query ??
+    Object.fromEntries(searchParams.entries())
+
+  const pushFn = location?.push ?? ((url: string) => {return router.push(url)})
+
+  /**
+   * Set or update a query param
+   * @param name
+   * @param value
+   */
+  const handleQuery = (name: string, value = ''): void => {
+    if (!name) return
+
+    const query = new URLSearchParams(activeQuery)
+    query.set(name, value)
+
+    pushFn(`?${query.toString()}`)
+  }
+
+  /**
+   * Remove a query param
+   * @param name
+   */
+  const handleCleanQuery = (name: string): void => {
+    if (!name) return
+
+    const query = new URLSearchParams(activeQuery)
+    query.delete(name)
+
+    pushFn(`?${query.toString()}`)
+  }
+
+  /**
+   * Get a query param value
+   * @param name
+   */
+  const getQuery = (name: string): string => {
+    if (!name) return ''
+    return activeQuery?.[name] ?? ''
+  }
+
+  /**
+   * Get a dynamic route param from Next.js
+   * @param root0
+   * @param root0.param
+   * @param root0.callback
+   */
+  const getParams = ({ param, callback }: GetParamsOptions): string => {
+    if (!param) return ''
+
+    const value = String(params?.[param] ?? '')
+    callback?.(value)
+
+    return value
+  }
+
+  return {
+    getQuery,
+    handleQuery,
+    handleCleanQuery,
+    getParams
+  }
+}