npm-pkg-hook 1.13.0 → 1.13.1

package/src/hooks/useLocalSorage/index.ts

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

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

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

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

@@ -1,74 +0,0 @@
-/**
- * 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

@@ -1,12 +0,0 @@
-/**
- *
- * @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

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

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

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

@@ -1,88 +0,0 @@
-/**
- *
- * @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

@@ -1,39 +0,0 @@
-/** 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

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

@@ -1,45 +0,0 @@
-/**
- * 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
-}