npm-pkg-hook 1.3.8 → 1.4.0

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

@@ -0,0 +1,88 @@
+/**
+ *
+ * @param o
+ */
+function formatError (o) {
+  if (hasErrorProperty(o)) {
+    o.error = formatError(o.error)
+    o.message = o.message ?? o.error.message
+  }
+  return o
+}
+
+/**
+ *
+ * @param x
+ */
+function hasErrorProperty (x) {
+  return Boolean(x?.error)
+}
+
+const _logger = {
+  error (code, metadata) {
+    metadata = formatError(metadata)
+    console.error(
+      `[next-auth][error][${code}]`,
+      `\nhttps://next-auth.js.org/errors#${code.toLowerCase()}`,
+      metadata.message,
+      metadata
+    )
+  },
+  warn (code) {
+    console.warn(
+      `[next-auth][warn][${code}]`,
+      `\nhttps://next-auth.js.org/warnings#${code.toLowerCase()}`
+    )
+  },
+  debug (code, metadata) {
+    console.log(`[next-auth][debug][${code}]`, metadata)
+  }
+}
+
+/**
+ *
+ * @param newLogger
+ * @param debug
+ */
+export function setLogger (newLogger = {}, debug) {
+  if (!debug) _logger.debug = () => { }
+
+  if (newLogger.error) _logger.error = newLogger.error
+  if (newLogger.warn) _logger.warn = newLogger.warn
+  if (newLogger.debug) _logger.debug = newLogger.debug
+}
+
+/**
+ *
+ * @param logger
+ * @param basePath
+ */
+export function proxyLogger (logger = _logger, basePath) {
+  try {
+    if (typeof window === 'undefined') {
+      return logger
+    }
+
+    const clientLogger = {}
+    for (const level in logger) {
+      clientLogger[level] = (code, metadata) => {
+        _logger[level](code, metadata)
+
+        if (level === 'error') {
+          metadata = formatError(metadata)
+        }
+        metadata.client = true
+        const url = `${basePath}/_log`
+        const body = new URLSearchParams({ level, code, ...metadata })
+        if (navigator.sendBeacon) {
+          return navigator.sendBeacon(url, body)
+        }
+        return fetch(url, { method: 'POST', body, keepalive: true })
+      }
+    }
+    return clientLogger
+  } catch {
+    return _logger
+  }
+}
+export { _logger as default }

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

@@ -0,0 +1,39 @@
+/** Interface for the internal URL structure */
+const InternalUrl = {
+  origin: 'http://localhost:3000',
+  host: 'localhost:3000',
+  path: '/api/auth',
+  base: 'http://localhost:3000/api/auth',
+  toString: function () {
+    return this.base
+  }
+}
+
+/**
+ * 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')) {
+    url = `https://${url}`
+  }
+
+  const _url = new URL(url || defaultUrl)
+  const path = (_url.pathname === '/' ? defaultUrl.pathname : _url.pathname).replace(/\/$/, '')
+
+  const base = `${_url.origin}${path}`
+
+  return {
+    origin: _url.origin,
+    host: _url.host,
+    path,
+    base,
+    toString: function () {
+      return base
+    }
+  }
+}
+
+export { InternalUrl, parseUrl }

package/src/hooks/useLogout/index.ts

@@ -0,0 +1,105 @@
+import { useApolloClient } from '@apollo/client'
+import { useState } from 'react'
+
+import { Cookies } from '../../cookies/index'
+import { getCurrentDomain } from '../../utils'
+import { signOutAuth } from './helpers'
+
+
+interface UseLogoutOptions {
+  setAlertBox?: (options: { message: string }) => { message: string }
+}
+export const useLogout = ({
+  setAlertBox = ({
+    message
+  }) => { return { message } }
+}: UseLogoutOptions = {}) => {
+  const [loading, setLoading] = useState<boolean>(false)
+  const [error, setError] = useState(false)
+  const client = useApolloClient()
+
+  const eliminarCookie = async (nombreCookie: string) => {
+    try {
+      let domain = getCurrentDomain() as string | undefined
+
+      // Si estás en entorno local, usa 'localhost' como dominio
+      if (domain === 'localhost') {
+        domain = undefined // Esto permitirá la cookie en 'localhost'
+      }
+
+      const expirationTime = new Date()
+      expirationTime.setTime(expirationTime.getTime() - 1000) // Establece una fecha de expiración en el pasado
+
+      const formattedDomain: string | undefined = typeof domain === 'string' ? domain : undefined
+
+      Cookies.remove(nombreCookie, { domain: formattedDomain, path: '/', secure: process.env.NODE_ENV === 'production' })
+
+      console.log('Cookie eliminada correctamente.')
+    } catch (error) {
+      console.error('Error al eliminar la cookie:', error)
+      throw new Error('Error al eliminar la cookie. ')
+    }
+  }
+  const deleteCookie = async () => {
+    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 (params?: { redirect?: boolean }) => {
+    const redirect = params?.redirect ?? true
+    try {
+      if (redirect) {
+        setLoading(true)
+      } else {
+        return await deleteCookie()
+      }
+      await deleteCookie()
+      // Logout from the server
+      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: {
+          'Content-Type': 'application/json'
+        },
+        credentials: 'include'
+      })
+
+      if (!logoutResponse.ok) {
+        setLoading(false)
+        return
+      }
+
+      await logoutResponse.json()
+      console.log('Intentando borrar cookies...')
+
+      // Eliminar la cookie process.env.NEXT_PUBLIC_SESSION_NAME
+      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')
+
+      // Clear Apollo Client cache
+      client?.clearStore()
+
+      setLoading(false)
+      console.log('Cookies eliminadas y sesión cerrada con éxito')
+      signOutAuth({ redirect: true, callbackUrl: '/' })
+        .catch((err) => {
+          setError(true)
+          console.error('Error in signOutAuth:', err)
+          setAlertBox({ message: 'Ocurrió un error al cerrar sesión' })
+        })
+    } catch (err) {
+      setLoading(false)
+      setError(true)
+      console.error('Error al cerrar sesión:', err)
+      setAlertBox({ message: 'Ocurrió un error al cerrar sesión' })
+    }
+  }
+
+  return [onClickLogout, { loading, error }]
+}

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

@@ -0,0 +1,45 @@
+/**
+ * Busca un objeto dentro de un conjunto de columnas por su código de referencia.
+ * @param {Object} data - El objeto que contiene las columnas.
+ * @param {string} pCodeRef - El código de referencia a buscar.
+ * @returns {Object|null} - El objeto encontrado o null si no se encuentra.
+ */
+export function findOrderByCodeRef (data, pCodeRef) {
+  if (!data || typeof data !== 'object') {
+    throw new Error('El parámetro "data" debe ser un objeto no nulo.')
+  }
+
+  if (typeof pCodeRef !== 'string') {
+    throw new Error('El parámetro "pCodeRef" debe ser una cadena de texto.')
+  }
+
+  // Iterar sobre cada columna en el objeto data
+  for (const columnKey in data) {
+    if (Object.hasOwnProperty.call(data, columnKey)) {
+      const column = data[columnKey]
+      // Verificar si la columna es un array
+      if (Array.isArray(column)) {
+        // Buscar el objeto por pCodeRef dentro de la columna actual
+        const foundOrder = column.find(
+          (order) => {return order && order.pCodeRef === pCodeRef}
+        )
+        // Si se encuentra el objeto, devolverlo
+        if (foundOrder) {
+          return foundOrder
+        }
+      }
+    }
+  }
+  // Si no se encuentra el objeto en ninguna columna, devolver null
+  return null
+}
+
+export const isDateInRange = (dateString) => {
+  const currentDate = new Date()
+  const todayStart = new Date(currentDate.setHours(0, 0, 0, 0))
+  const tomorrowStart = new Date(todayStart)
+  tomorrowStart.setDate(tomorrowStart.getDate() + 1)
+
+  const date = new Date(dateString)
+  return date >= todayStart && date < tomorrowStart
+}

package/src/hooks/useManageNewOrder/index.ts

@@ -0,0 +1,104 @@
+import { useEffect, useState } from 'react'
+
+import {
+  useGetSale,
+  // updateExistingOrders,
+  convertDateFormat,
+  useOrdersFromStore
+} from '..'
+
+import { findOrderByCodeRef, isDateInRange } from './helpers'
+
+export const useManageNewOrder = ({
+  client,
+  idStore,
+  setAlertBox = ({ message, duration }) => {
+    return { message, duration }
+  },
+  playNotificationSound = () => {},
+  setIsOpenOrder = (boolean) => { return boolean },
+  setCountOrders = (number) => { return number },
+  sendNotification = ({ title, description, backgroundColor }) => {
+    return {
+      title,
+      description,
+      backgroundColor
+    }
+  }
+}) => {
+  const KEY_STATUS_ORDER = 'ACEPTA'
+  const [orders, setOrders] = useState([])
+
+  const [data] = useOrdersFromStore({
+    idStore,
+    search: '',
+    fromDate: convertDateFormat({ start: true }),
+    toDate: convertDateFormat({ start: false })
+  })
+
+  useEffect(() => {
+    if (data) {
+      const dataOrder = data[KEY_STATUS_ORDER]
+      if (Array.isArray(dataOrder) && dataOrder) {
+        const filteredOrders = dataOrder.filter(order =>
+        {return isDateInRange(order?.pDatCre) && order?.pSState === 1}
+        ) ?? []
+        setOrders(filteredOrders)
+        setCountOrders(filteredOrders.length)
+      }
+    }
+  }, [data])
+
+  const { getOneSalesStore } = useGetSale()
+
+  const handleNewOrder = (order) => {
+    const dataOrder = data[KEY_STATUS_ORDER]
+    setOrders(dataOrder)
+    const { pCodeRef } = order || {}
+    if (pCodeRef) {
+      const isCodeRefExists = findOrderByCodeRef(data, pCodeRef)
+      if (isCodeRefExists) {
+        return
+      }
+      setIsOpenOrder(true)
+      getOneSalesStore({
+        variables: {
+          pCodeRef: pCodeRef ?? ''
+        }
+      }).then((response) => {
+        console.log(response)
+        // const currentSale = response?.data?.getOneSalesStore || {}
+        client.cache.modify({
+          fields: {
+            // getAllOrdersFromStore (existingOrders = []) {
+            //   try {
+            //     const cache = updateExistingOrders(
+            //       existingOrders,
+            //       pCodeRef,
+            //       1,
+            //       currentSale
+            //     )
+            //     const currentOrder = cache[KEY_STATUS_ORDER]
+            //     const filteredOrders = currentOrder.filter(order =>
+            //       isDateInRange(order.pDatCre)
+            //     )
+            //     setOrders(filteredOrders)
+            //     playNotificationSound()
+            //     return cache
+            //   } catch (e) {
+            //     return existingOrders
+            //   }
+            // }
+          }
+        })
+      })
+      sendNotification({
+        title: 'Pedido',
+        description: 'Nuevo pedido',
+        backgroundColor: 'success'
+      })
+    }
+  }
+
+  return [orders, { handleNewOrder }]
+}

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
+  }
+}

package/src/hooks/useMobile/index.ts

@@ -0,0 +1,65 @@
+import { useEffect, useRef, useState } from 'react'
+
+export const MEDIA_QUERY = {
+  MOBILE: '(max-width: 768px)',
+  TABLET: '(max-width: 960px)',
+  DESKTOP: '(min-width: 961px)'
+}
+
+export const useMobile = ({ callback } = {}) => {
+  const [isMobile, setIsMobile] = useState(false)
+  const [isTablet, setIsTablet] = useState(false)
+  const [isDesktop, setIsDesktop] = useState(false)
+
+  const prevValues = useRef({
+    isMobile: false,
+    isTablet: false,
+    isDesktop: false
+  })
+
+  useEffect(() => {
+    if (typeof window === 'undefined') return
+
+    const mobileQuery = window.matchMedia(MEDIA_QUERY.MOBILE)
+    const tabletQuery = window.matchMedia(MEDIA_QUERY.TABLET)
+    const desktopQuery = window.matchMedia(MEDIA_QUERY.DESKTOP)
+
+    const updateMatches = () => {
+      const newIsMobile = mobileQuery.matches
+      const newIsTablet = tabletQuery.matches
+      const newIsDesktop = desktopQuery.matches
+
+      const hasChanged =
+        newIsMobile !== prevValues.current.isMobile ||
+        newIsTablet !== prevValues.current.isTablet ||
+        newIsDesktop !== prevValues.current.isDesktop
+
+      if (hasChanged) {
+        prevValues.current = {
+          isMobile: newIsMobile,
+          isTablet: newIsTablet,
+          isDesktop: newIsDesktop
+        }
+        callback?.(prevValues.current)
+      }
+
+      setIsMobile(newIsMobile)
+      setIsTablet(newIsTablet)
+      setIsDesktop(newIsDesktop)
+    }
+
+    updateMatches()
+
+    mobileQuery.addEventListener('change', updateMatches)
+    tabletQuery.addEventListener('change', updateMatches)
+    desktopQuery.addEventListener('change', updateMatches)
+
+    return () => {
+      mobileQuery.removeEventListener('change', updateMatches)
+      tabletQuery.removeEventListener('change', updateMatches)
+      desktopQuery.removeEventListener('change', updateMatches)
+    }
+  }, [callback])
+
+  return { isMobile, isTablet, isDesktop }
+}

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

@@ -0,0 +1 @@
+export * from './validateModules'

package/src/hooks/useModules/helpers/validateModules.ts

@@ -0,0 +1,43 @@
+/**
+ * Validates and filters modules based on the "read" permission.
+ * If a module's view does not have "read" permission in the permissions object, the module is removed.
+ */
+type PermissionMap = Record<string, string[]>
+
+interface SubModule {
+  view: string
+  [key: string]: any
+}
+
+interface Module {
+  view: string
+  subModules?: SubModule[]
+  [key: string]: any
+}
+
+export const validateModules = (
+  modules: Module[] = [],
+  permissions: PermissionMap = {}
+): Module[] => {
+  if (!Array.isArray(modules) || modules.length <= 0) return []
+  return modules
+    .map((module) => {
+      // Check if the main module's view has "read" permission
+      const hasReadPermission = permissions[module.view]?.includes('read')
+
+      // Validate and filter subModules if they exist
+      const validSubModules =
+        module.subModules?.filter((subModule: SubModule) =>
+          permissions[subModule.view]?.includes('read')
+        ) || []
+
+      // If the module or its subModules don't have read permission, exclude it
+      if (!hasReadPermission && validSubModules.length === 0) {
+        return null
+      }
+
+      // Return the module with its valid subModules
+      return { ...module, subModules: validSubModules }
+    })
+    .filter(Boolean) as Module[] // Remove null values
+}