npm-pkg-hook 1.12.7 → 1.12.9

package/src/hooks/useLocalSorage/index.ts

@@ -0,0 +1,36 @@
+import { useState } from 'react'
+
+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
+  const [storedValue, setStoredValue] = useState(() => {
+    try {
+      // Get from local storage by key
+      const item = window.localStorage.getItem(key)
+      // Parse stored json or if none return initialValue
+      return item ? JSON.parse(item) : initialValue
+    } catch (error) {
+      // If error also return initialValue
+      return initialValue
+    }
+  })
+
+  // Return a wrapped version of useState's setter function that ...
+  // ... persists the new value to localStorage.
+  const setValue = (value: string | object | any) => {
+    try {
+      // Allow value to be a function so we have same API as useState
+      const valueToStore =
+        value instanceof Function ? value(storedValue) : value
+      // Save state
+      setStoredValue(valueToStore)
+      // Save to local storage
+      window.localStorage.setItem(key, JSON.stringify(valueToStore))
+    } catch (error) {
+      // A more advanced implementation would handle the error case
+    }
+  }
+
+  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/useLocationNavigate/index.ts

@@ -0,0 +1,54 @@
+import { useEffect, useState } from 'react'
+
+const defaultSettings = {
+  enableHighAccuracy: false,
+  timeout: Infinity,
+  maximumAge: 0
+}
+
+export const usePosition = (watch = false, settings = defaultSettings) => {
+  const [position, setPosition] = useState({})
+  const [error, setError] = useState(null)
+
+  const onChange = ({ coords, timestamp }) => {
+    setPosition({
+      latitude: coords.latitude,
+      longitude: coords.longitude,
+      accuracy: coords.accuracy,
+      speed: coords.speed,
+      timestamp
+    })
+  }
+
+  const onError = () => {
+    setError(error?.message)
+  }
+
+  useEffect(() => {
+    if (!navigator || !navigator.geolocation) {
+      setError('Geolocation is not supported')
+      return
+    }
+
+    let watcher = null
+    if (watch) {
+      watcher = navigator.geolocation.watchPosition(
+        onChange,
+        onError,
+        settings
+      )
+    } else {
+      navigator.geolocation.getCurrentPosition(onChange, onError, settings)
+    }
+
+    return () => { return watcher && navigator.geolocation.clearWatch(watcher) }
+  }, [
+    settings,
+    settings.enableHighAccuracy,
+    settings.timeout,
+    settings.maximumAge,
+    watch
+  ])
+
+  return { ...position, error }
+}

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

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