npm-pkg-hook 1.13.0 → 1.13.1

package/src/hooks/useManageNewOrder/index.ts

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

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

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

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

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

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

package/src/hooks/useModules/index.ts

@@ -1,124 +0,0 @@
-import { gql, useQuery } from '@apollo/client'
-
-import { validateModules } from './helpers/validateModules'
-
-/**
- * GraphQL query to get modules and submodules
- */
-const GET_MODULES = gql`
-  query GetModules {
-    modules {
-      mName
-      mId
-      mPath
-      mPriority
-      mIcon
-      view
-      subModules {
-        smId
-        smName
-        smPath
-        view
-        smIcon
-        smState
-      }
-    }
-  }
-`
-
-/**
- * SubModule entity
- */
-export interface SubModule {
-  smId: string
-  smName: string
-  smPath: string
-  smIcon?: string | null
-  smState?: boolean | null
-  view?: boolean | null
-}
-
-/**
- * Module entity
- */
-export interface Module {
-  mId: string
-  mName: string
-  mPath: string
-  mPriority?: number | null
-  mIcon?: string | null
-  view?: boolean | null
-  subModules?: SubModule[]
-}
-
-/**
- * Permissions map
- */
-export type Permissions = Record<string, boolean>
-
-/**
- * User role structure
- */
-export interface Role {
-  permissions?: Permissions
-}
-
-/**
- * User data structure
- */
-export interface UserData {
-  role?: Role
-}
-
-/**
- * Hook params
- */
-export interface UseModulesParams {
-  dataUser?: UserData
-  callback?: (modules: Module[]) => void
-}
-
-/**
- * Hook return type
- */
-export interface UseModulesResult {
-  loading: boolean
-  error?: Error
-  modules: Module[]
-}
-
-/**
- * Custom hook to fetch and validate modules based on user permissions
- *
- * @param {UseModulesParams} params - Hook parameters
- * @returns {UseModulesResult}
- */
-export const useModules = ({
-  dataUser = {},
-  callback = () => {}
-}: UseModulesParams = {}): UseModulesResult => {
-  const permissions: Permissions = dataUser?.role?.permissions ?? {}
-
-  const { loading, error, data } = useQuery<{ modules: Module[] }>(GET_MODULES, {
-    fetchPolicy: 'cache-and-network',
-    onCompleted: (response) => {
-      if (Array.isArray(response?.modules)) {
-        callback(response.modules)
-      }
-    },
-    onError: (err) => {
-      console.error('Error fetching modules:', err)
-    }
-  })
-
-  const safeModules: Module[] = Array.isArray(data?.modules) ? data.modules : []
-
-  // cast to any to work around a too-narrow parameter type in the helper
-  const filteredModules: Module[] = validateModules(safeModules as any, permissions)
-
-  return {
-    loading,
-    error: error ?? undefined,
-    modules: filteredModules
-  }
-}

package/src/hooks/useMouse/index.ts

@@ -1,55 +0,0 @@
-import { useEffect, useRef, useState } from 'react'
-
-/**
- *
- * @param options
- * @param options.resetOnExit
- */
-export function useMouse(
-  options: { resetOnExit } = { resetOnExit: false }
-) {
-  const [position, setPosition] = useState({ x: 0, y: 0 })
-
-  const ref = useRef()
-
-  const setMousePosition = (event) => {
-    if (ref.current) {
-      const rect = event.currentTarget.getBoundingClientRect()
-
-      const x = Math.max(
-        0,
-        Math.round(
-          event.pageX - rect.left - (window.pageXOffset || window.scrollX)
-        )
-      )
-
-      const y = Math.max(
-        0,
-        Math.round(
-          event.pageY - rect.top - (window.pageYOffset || window.scrollY)
-        )
-      )
-
-      setPosition({ x, y })
-    } else {
-      setPosition({ x: event.clientX, y: event.clientY })
-    }
-  }
-
-  const resetMousePosition = () => {return setPosition({ x: 0, y: 0 })}
-
-  useEffect(() => {
-    const element = ref?.current ? ref.current : document
-    element.addEventListener('mousemove', setMousePosition)
-    if (options.resetOnExit)
-      {element.addEventListener('mouseleave', resetMousePosition)}
-
-    return () => {
-      element.removeEventListener('mousemove', setMousePosition)
-      if (options.resetOnExit)
-        {element.removeEventListener('mouseleave', resetMousePosition)}
-    }
-  }, [ref.current])
-
-  return { ref, ...position }
-}

package/src/hooks/useMutateHeight/index.ts

@@ -1,36 +0,0 @@
-import {
-  useEffect,
-  useRef,
-  useState
-} from 'react'
-
-export const useMutateHeight = ({ isCollapsed = false }) => {
-  const [collapsed, setCollapsed] = useState(isCollapsed)
-  const childrenContainerRef = useRef(null)
-
-  useEffect(() => {
-    setCollapsed(isCollapsed)
-    if (childrenContainerRef.current !== null) {
-      const height = isCollapsed
-        ? childrenContainerRef.current.scrollHeight
-        : 0
-      childrenContainerRef.current.style.height = `${height}px`
-    }
-  }, [isCollapsed])
-
-  const handleCollapsed = visible => {
-    setCollapsed(visible)
-    if (childrenContainerRef.current !== null) {
-      const height = visible ? childrenContainerRef.current.scrollHeight : 0
-      childrenContainerRef.current.style.height = `${height}px`
-    }
-  }
-
-  return {
-    handleCollapsed,
-    childrenContainerRef,
-    collapsed
-  }
-}
-
-// https://codesandbox.io/s/dropdown-navigation-9fx6r?file=/src/Navigation/Navigation.js:357-775

package/src/hooks/useOrderClient/index.ts

@@ -1,5 +0,0 @@
-export const useOrderClient = () => {
-  return {
-
-  }
-}

package/src/hooks/useOrderStatusTypes/index.ts

@@ -1,2 +0,0 @@
-export * from './useUpdateOrderStatusPriorities'
-export * from './useOrderStatusTypes'

package/src/hooks/useOrderStatusTypes/useOrderStatusTypes/index.ts

@@ -1,133 +0,0 @@
-import { useQuery, gql } from '@apollo/client'
-
-/**
- * GraphQL query to fetch order status types.
- */
-const GET_ORDER_STATUS_TYPES = gql`
-  query getAllOrderStatusTypes {
-    getAllOrderStatusTypes {
-      message
-      success
-      __typename
-      data {
-        backgroundColor
-        color
-        createdAt
-        description
-        idStatus
-        name
-        priority
-        state
-        updatedAt
-        __typename
-      }
-      pagination {
-        currentPage
-        totalPages
-        totalRecords
-        __typename
-      }
-      errors {
-         context {
-          key
-          label
-          limit
-          value
-          __typename
-         }
-      }
-    }
-  }
-`
-
-/**
- * @typedef {Object} OrderStatusType
- * @property {string} idStatus - Unique identifier for the status
- * @property {string} name - Name of the status
- * @property {number} priority - Priority level
- * @property {string} backgroundColor - Background color in hex
- * @property {string} color - Text color in hex
- * @property {number} state - Status state (e.g. active/inactive)
- */
-
-/**
- * Custom hook to fetch order status types.
- *
- * @returns {{
- *   statusTypes: OrderStatusType[] | null,
- *   loading: boolean,
- *   error: Error | undefined,
- *   refetch: () => void
- * }}
- */
-/**
- * Retrieves order status types via the corresponding GraphQL query and exposes loading state, errors, and refetch capabilities.
- *
- * @param options - Optional configuration values for the hook.
- * @param options.callback - Callback invoked when the query completes successfully, receiving the raw query response.
- * @returns An object containing the normalized status types data along with loading, error, and refetch helpers.
- */
-export interface OrderStatusType {
-  idStatus: string
-  name: string
-  priority: number
-  backgroundColor: string
-  color: string
-  state: number
-  description: string
-  createdAt: string
-  updatedAt: string
-  __typename: string
-}
-
-export interface OrderStatusTypeErrorContext {
-  key: string
-  label: string
-  limit: number
-  value: string
-  __typename: string
-}
-
-export interface OrderStatusTypeError {
-  context: OrderStatusTypeErrorContext[]
-  __typename: string
-}
-
-export interface GetAllOrderStatusTypesResponse {
-  message: string
-  success: boolean
-  __typename: string
-  data: OrderStatusType[]
-  errors?: OrderStatusTypeError[] | null
-}
-
-export interface OrderStatusTypesQueryResult {
-  getAllOrderStatusTypes: GetAllOrderStatusTypesResponse
-}
-
-export interface UseOrderStatusTypesOptions {
-  callback?: (payload: OrderStatusTypesQueryResult) => void
-}
-
-export const useOrderStatusTypes = ({
-  callback = () => {return undefined}
-}: UseOrderStatusTypesOptions = {}) => {
-  const {
-    data,
-    loading,
-    error,
-    refetch
-  } = useQuery<OrderStatusTypesQueryResult>(GET_ORDER_STATUS_TYPES, {
-    onCompleted: callback,
-    fetchPolicy: 'cache-and-network'
-  })
-
-  const statusTypes = data?.getAllOrderStatusTypes?.data ?? null
-
-  return {
-    data: statusTypes,
-    loading,
-    error,
-    refetch
-  }
-}