npm-pkg-hook 1.13.1 → 1.13.2

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

package/src/hooks/useModules/index.ts

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

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

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

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

package/src/hooks/useOrderStatusTypes/index.ts

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

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

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