npm-pkg-hook 1.12.3 → 1.12.7

package/src/hooks/useDownloadReports/useGetReportByDateRange/index.ts

@@ -1,115 +0,0 @@
-import { useLazyQuery } from '@apollo/client'
-import { gql } from '@apollo/client'
-import { downloadFileFromResponse } from '../helpers/downloadFileFromResponse'
-import { useState } from 'react'
-
-/**
- * GraphQL query to get report by date range
- */
-const GET_REPORT_BY_DATE_RANGE = gql`
-  query getReportByDateRange($startDate: DateTime!, $endDate: DateTime!) {
-    getReportBydateRange(startDate: $startDate, endDate: $endDate) {
-      success
-      message
-      errors {
-        path
-        message
-        type
-      }
-      data {
-        id
-        name
-        description
-        url
-        createdAt
-      }
-    }
-  }
-`
-
-/**
- * Custom hook to fetch report by a date range
- * @param {Object} options
- * @param {Function} options.sendNotification - Function to notify user
- * @returns {[Function, { loading: boolean, error: any, data: any }]}
- */
-export const useGetReportByDateRange = ({
-  sendNotification = ({ description = '', title = '', backgroundColor = 'info' } = {}) => {
-    return { description, title, backgroundColor }
-  }
-} = {}) => {
-  const [loading, setLoading] = useState(false)
-  const [finished, setFinished] = useState(false)
-
-  const [getReportQuery, { data, error }] = useLazyQuery(GET_REPORT_BY_DATE_RANGE, {
-    onCompleted: () => {
-      setFinished(true)
-    }
-  })
-
-  /**
-   * Triggers the report generation and handles download
-   * @param {string} startDate - Start date in YYYY-MM-DD format
-   * @param {string} endDate - End date in YYYY-MM-DD format
-   * @returns {Promise<any>}
-   */
-  const getReport = async (startDate, endDate) => {
-    try {
-      setLoading(true)
-      const response = await getReportQuery({
-        variables: { startDate, endDate },
-        fetchPolicy: 'network-only'
-      })
-
-      const reportResult = response?.data?.getReportBydateRange ?? {
-        success: false,
-        message: 'No report data found',
-        data: null
-      }
-
-      if (!reportResult) {
-        setLoading(false)
-        return {
-          success: false,
-          message: 'No report data found',
-          data: null
-        }
-      }
-
-      const {
-        success,
-        message,
-        data
-      } = reportResult
-
-      sendNotification({
-        description: message,
-        title: success ? 'Success' : 'Error',
-        backgroundColor: success ? 'success' : 'error'
-      })
-
-      if (success && data?.url && data?.name) {
-        setLoading(true)
-        const res = await fetch(`/api/files/${encodeURIComponent(data.url)}`)
-        await downloadFileFromResponse(res, data.name)
-        setLoading(false)
-      }
-      return reportResult
-    } catch (err) {
-      setLoading(false)
-      sendNotification({
-        description: err.message || 'Unexpected error',
-        title: 'Error',
-        backgroundColor: 'error'
-      })
-      return { success: false, message: err.message, data: null }
-    }
-  }
-
-  return [getReport, {
-    loading,
-    error,
-    finished,
-    data: data?.getReportBydateRange
-  }]
-}

package/src/hooks/useDrag/index.js

@@ -1,63 +0,0 @@
-import { useEffect, useState } from 'react'
-
-export function useDrag2 (ref) {
-  useEffect(() => {
-    if (!ref || !ref?.current) return null
-    const target = ref?.current
-    if (!target) return
-    const previousOffset = { x: 0, y: 0 }
-    let originMouseX
-    let originMouseY
-    function onMousemove (e) {
-      const { pageX, pageY } = e
-      const x = pageX - originMouseX + previousOffset.x
-      const y = pageY - originMouseY + previousOffset.y
-      target.style.transform = `translate(${x}px, ${y}px)`
-    }
-    function onMouseup (e) {
-      previousOffset.x += e.pageX - originMouseX
-      previousOffset.y += e.pageY - originMouseY
-      window.removeEventListener('mousemove', onMousemove)
-      window.removeEventListener('mouseup', onMouseup)
-    }
-    function onMousedown (e) {
-      originMouseX = e.pageX
-      originMouseY = e.pageY
-      window.addEventListener('mousemove', onMousemove)
-      window.addEventListener('mouseup', onMouseup)
-    }
-    target.addEventListener('mousedown', onMousedown)
-    return () => {
-      target?.removeEventListener('mousedown', onMousedown)
-      window?.removeEventListener('mouseup', onMouseup)
-      window?.removeEventListener('mousemove', onMousemove)
-    }
-  }, [ref])
-}
-
-export const useDrag = (x, y) => {
-  const [move, setMove] = useState(false)
-  const [moveTo, setMoveTo] = useState([x, y])
-  const moveIcon = e => {
-    const xcoord = moveTo[0] + e.movementX
-    const ycoord = moveTo[1] + e.movementY
-    setMoveTo([xcoord, ycoord])
-  }
-  const handleMove = e => {
-    move && moveIcon(e)
-  }
-  const handelDown = () => {
-    setMove(true)
-  }
-  const handelUp = () => {
-    setMove(false)
-  }
-
-  return {
-    move,
-    moveTo,
-    handelDown,
-    handelUp,
-    handleMove
-  }
-}

package/src/hooks/useDropzone/index.js

@@ -1,94 +0,0 @@
-import { useEffect, useMemo, useRef, useState } from 'react'
-
-export const useDropzone = (
-  onDrop,
-  dragHandler = {},
-  draggingStyle = { border: 'dashed grey 3px' },
-  dragOverStyle = {
-    border: 'dashed grey 3px'
-  }
-) => {
-  const ref = useRef(null)
-  const [cleanup, setCleanup] = useState(false)
-  const [isDragging, setDragging] = useState(false)
-  const [dragOver, setDragOver] = useState(false)
-  const handle = useMemo(dragHandler, [])
-
-  const eventListeners = {
-    dragenter: e => {
-      return handle.dragEnter(e, () => {
-        if (!dragOver) setDragOver(true)
-      })
-    },
-    dragleave: e => {
-      return handle.dragLeave(e, () => {
-        setDragOver(false)
-      })
-    },
-    dragover: handle.dragBegin,
-    drop: e => {
-      return handle.drop(e, files => {
-        if (typeof onDrop === 'function') onDrop(files, e)
-        setDragOver(false)
-        setDragging(false)
-      })
-    }
-  }
-
-  const windowListeners = {
-    dragenter: e => {
-      return handle.body.dragEnter(e, () => {
-        if (!isDragging) setDragging(true)
-      })
-    },
-    dragleave: e => {
-      return handle.body.dragLeave(e, () => {
-      // eslint-disable-next-line
-              if (isDragging) setDragging(false)
-      })
-    },
-    dragend: () => {
-      // eslint-disable-next-line
-          },
-    drop: e => {
-      return handle.body.drop(e, () => {
-        setDragging(false)
-        setDragOver(false)
-      })
-    }
-  }
-
-  useEffect(() => {
-    if (ref.current) {
-      const { current } = ref
-      Object.keys(eventListeners).forEach(key => { return current.addEventListener(key, eventListeners[key]) }
-      )
-      Object.keys(windowListeners).forEach(key => { return window.addEventListener(key, windowListeners[key]) }
-      )
-      setCleanup(true)
-    }
-
-    return () => {
-      if (cleanup) {
-        const { current } = ref
-        if (current) {
-          Object.keys(eventListeners).forEach(key => { return current.removeEventListener(key, eventListeners[key]) }
-          )
-        }
-        Object.keys(windowListeners).forEach(key => { return window.removeEventListener(key, windowListeners[key]) }
-        )
-      }
-    }
-  }, [ref, windowListeners, cleanup, eventListeners, isDragging, dragOver])
-
-  const dropProps = {
-    ref,
-    style:
-        isDragging || dragOver
-          ? dragOver
-            ? dragOverStyle
-            : draggingStyle
-          : undefined
-  }
-  return { isDragging, dragOver, dropProps }
-}

package/src/hooks/useDynamicAuth/index.js

@@ -1,13 +0,0 @@
-import { useQuery } from '@apollo/client'
-import { useState } from 'react'
-import { GET_ONE_DYNAMIC_PASS } from './queries'
-
-export const useDynamicAuth = () => {
-  const [dynamicPass, setDynamicPass] = useState({})
-  const { loading, error } = useQuery(GET_ONE_DYNAMIC_PASS, {
-    onCompleted: (res) => {
-      setDynamicPass(res.getAOneDynamicPassword)
-    }
-  })
-  return [dynamicPass, { loading, error }]
-}

package/src/hooks/useDynamicAuth/queries.js

@@ -1,24 +0,0 @@
-import { gql } from '@apollo/client'
-
-export const CREATE_ONE_DYNAMIC_PASS = gql`
-mutation registerDynamicPassword($input: IDynamicPassword) {
-  registerDynamicPassword(input: $input) {
-    success
-    message
-  }
-}
-`
-export const GET_ONE_DYNAMIC_PASS = gql`
-query getAOneDynamicPassword {
-  getAOneDynamicPassword {
-    dPassId
-    id
-    idStore
-    keyPassDynamic
-    deviceName
-    dState
-    DatCre
-    DatMod
-  }
-}
-`

package/src/hooks/useEditCategory/index.js

@@ -1,41 +0,0 @@
-import { gql, useMutation } from '@apollo/client'
-
-const EDIT_CATEGORY_PRODUCT = gql`
-  mutation EditOneCategoryProduct($pName: String!, $ProDescription: String, $carProId: ID!) {
-    editOneCategoryProduct(pName: $pName, ProDescription: $ProDescription, carProId: $carProId) {
-      success
-      message
-    }
-  }
-`
-
-export const useEditCategoryProduct = ({ sendNotification = () => { } } = {}) => {
-  const [editCategoryProductMutation] = useMutation(EDIT_CATEGORY_PRODUCT)
-
-  const editCategoryProduct = async (pName, ProDescription, carProId) => {
-    try {
-      const { data } = await editCategoryProductMutation({
-        variables: { pName, ProDescription, carProId }
-      })
-
-      if (data.editOneCategoryProduct.success) {
-        return {
-          success: true,
-          message: 'Categoría de producto editada correctamente'
-        }
-      } else {
-        return {
-          success: false,
-          message: data.editOneCategoryProduct.message || 'Error al editar la categoría de producto'
-        }
-      }
-    } catch (error) {
-      return {
-        success: false,
-        message: error.message || 'Error al editar la categoría de producto'
-      }
-    }
-  }
-
-  return { editCategoryProduct }
-}

package/src/hooks/useEditOneExtProductFoodOptional/index.js

@@ -1,28 +0,0 @@
-import React from 'react'
-import { useState } from 'react';
-import { useMutation } from '@apollo/client'
-import { UPDATE_EXT_PRODUCT_FOOD_OPTIONAL } from './queries';
-export const useEditOneExtProductFoodOptional = () => {
-    const [updateExtProductFood] = useMutation(UPDATE_EXT_PRODUCT_FOOD_OPTIONAL);
-    const [loading, setLoading] = useState(false);
-
-    const updateOneExtraProductFood = async (input) => {
-        setLoading(true);
-
-        try {
-        const { data } = await updateExtProductFood({
-            variables: { input }
-        });
-        console.log('Product food updated:', data.editExtProductFoodOptional);
-        setLoading(false);
-        } catch (error) {
-        console.error('Error updating product food:', error.message);
-        setLoading(false);
-        throw new Error('Error updating product food');
-        }
-    };
-    return {
-        loading,
-        updateOneExtraProductFood
-    }
-}

package/src/hooks/useEditOneExtProductFoodOptional/queries.js

@@ -1,16 +0,0 @@
-import { gql } from "@apollo/client"
-
-export const UPDATE_EXT_PRODUCT_FOOD_OPTIONAL = gql`
-mutation editExtProductFoodOptional($input: EditExtProductFoodOptionalInput!) {
-    editExtProductFoodOptional(input: $input) {
-      pId
-      opExPid
-      OptionalProName
-      state
-      code
-      required
-      numbersOptionalOnly
-      pDatMod
-    }
-  }
-`

package/src/hooks/useEditSubProductOptional/index.js

@@ -1,11 +0,0 @@
-import { EDIT_EXTRA_SUB_OPTIONAL_PRODUCTS } from "./queries"
-import { useMutation } from '@apollo/client'
-
-export const useEditSubProductOptional = () => {
-    const [editExtFoodSubsOptional, {
-        loading,
-        error,
-        called
-      }] = useMutation(EDIT_EXTRA_SUB_OPTIONAL_PRODUCTS)
-  return [editExtFoodSubsOptional, { loading, error, called }]
-}

package/src/hooks/useEditSubProductOptional/queries.js

@@ -1,10 +0,0 @@
-import { gql } from '@apollo/client'
-
-export const EDIT_EXTRA_SUB_OPTIONAL_PRODUCTS = gql`
-mutation  editExtFoodSubsOptional($opSubExPid: ID, $state: Int, $isCustomSubOpExPid: Boolean, $OptionalSubProName: String){
-  editExtFoodSubsOptional(opSubExPid: $opSubExPid, state: $state, isCustomSubOpExPid: $isCustomSubOpExPid, OptionalSubProName: $OptionalSubProName){
-    success,
-    message
-  }
-}
-`

package/src/hooks/useEmployee/index.js

@@ -1,17 +0,0 @@
-import { useQuery } from '@apollo/client'
-import { GET_EMPLOYEES } from './queries'
-
-export const useEmployee = () => {
-  const {
-    data,
-    loading,
-    error,
-    fetchMore
-  } = useQuery(GET_EMPLOYEES)
-  return [data?.employees?.data ?? [], {
-    loading,
-    error,
-    fetchMore,
-    pagination: data?.employees?.pagination ?? {}
-  }]
-}

package/src/hooks/useEmployee/queries.js

@@ -1,85 +0,0 @@
-import { gql } from '@apollo/client'
-
-export const GET_EMPLOYEES = gql`
-query employees {
-  employees {
-    data {
-        eId
-        idStore
-        idRole
-        eEmail
-        eState
-        status
-      user {
-        id
-        name
-        username
-        lastName
-        email
-        avatar
-        uToken
-        uPhoNum
-        ULocation
-        upLat
-        uState
-        upLon
-        upIdeDoc
-        siteWeb
-        description
-        createAt
-        associateStore
-      }
-      roles {
-        idRole
-name
-priority
-description
-permissions
-createdAt
-updatedAt
-      }
-    }
-    success
-    message
- pagination {
-      totalRecords
-      totalPages
-      currentPage
-    }
-    errors {
-      path
-      message
-      type
-      context {
-        limit
-        value
-        label
-        key
-      }
-    }
-    
-  }
-}
-`
-/**
- * GraphQL mutation for creating an employee, store, and user.
- */
-export const CREATE_ONE_EMPLOYEE_STORE_AND_USER = gql`
-  mutation createOneEmployeeStoreAndUser($input: IEmployeeStore!) {
-    createOneEmployeeStoreAndUser(input: $input) {
-      success
-      message
-      errors {
-        path
-        message
-        type
-        context {
-          limit
-          value
-          label
-          key
-        }
-      }
-    }
-  }
-`

package/src/hooks/useEmployee/useCreateEmployee.js

@@ -1,86 +0,0 @@
-import { useMutation } from '@apollo/client'
-import { useState } from 'react'
-import { CREATE_ONE_EMPLOYEE_STORE_AND_USER } from './queries'
-
-/**
- * Custom hook to handle the createOneEmployeeStoreAndUser mutation.
- *
- * @param
- * @param {Object}
- * @returns {{
- *   createEmployeeStoreAndUser: (input: IEmployeeStore) => Promise<void>,
- *   loading: boolean,
- *   error: Error | null,
- *   data: Object | null
- * }} An object containing the mutation function, loading status, error, and data.
- */
-export const useCreateEmployeeStoreAndUser = ({
-  sendNotification = () => {
-    return {
-      description: '',
-      title: '',
-      backgroundColor: ''
-    }
-  },
-  onCompleted = () => {
-    return {
-    }
-  },
-  onError = () => {
-    return {
-    }
-  }
-} = {}) => {
-  const [createEmployeeStoreAndUserMutation, { loading, error, data }] = useMutation(CREATE_ONE_EMPLOYEE_STORE_AND_USER, {
-    onError: () => {
-      sendNotification({
-        description: 'Error creando empleado',
-        title: 'Error',
-        backgroundColor: 'error'
-      })
-    },
-    onCompleted: (response) => {
-      console.log(response)
-      const { createOneEmployeeStoreAndUser } = response ?? {}
-      const { message, success } = createOneEmployeeStoreAndUser ?? {}
-      if (success === false) {
-        onError(response)
-      }
-      if (success) {
-        onCompleted(response)
-      }
-      sendNotification({
-        description: message,
-        title: success ? 'Exito' : 'Error',
-        backgroundColor: success ? 'success' : 'error'
-      })
-    }
-  })
-  const [errors, setErrors] = useState([])
-
-  /**
-   * Calls the createOneEmployeeStoreAndUser mutation.
-   *
-   * @param {Object} input - The input data for the mutation.
-   * @returns {Promise<void>}
-   */
-  const createEmployeeStoreAndUser = async (input) => {
-    try {
-      const response = await createEmployeeStoreAndUserMutation({ variables: { input } })
-      if (response.data.createOneEmployeeStoreAndUser.errors) {
-        setErrors(response.data.createOneEmployeeStoreAndUser.errors)
-      } else {
-        setErrors([])
-      }
-    } catch (err) {
-      setErrors([{ message: err.message }])
-    }
-  }
-
-  return [createEmployeeStoreAndUser, {
-    loading,
-    error,
-    data,
-    errors
-  }]
-}

package/src/hooks/useEvent/index.js

@@ -1,34 +0,0 @@
-import { useEffect } from 'react'
-
-export const on = ({ eventType, callBack }) => {
-  document.addEventListener(eventType, callBack)
-}
-export const off = ({ eventType, callBack }) => {
-  document.removeEventListener(eventType, callBack)
-}
-export const once = ({ eventType, callBack }) => {
-  const handleEventOnce = (event) => {
-    callBack(event)
-    off({ eventType, callBack: handleEventOnce })
-  }
-  on({ eventType, callBack: handleEventOnce })
-}
-export const trigger = ({ eventType, data }) => {
-  const event = new CustomEvent(eventType, { detail: data })
-  document.dispatchEvent(event)
-}
-// This function is used to subscribe components an any event
-export const useEvents = ({ eventType, callBack }) => {
-  useEffect(() => {
-    on({ eventType, callBack })
-    return () => {
-      off({ eventType, callBack })
-    }
-  }, [eventType, callBack])
-}
-// This function create and dispatch event
-export const useTrigerEvent = () => {
-  return {
-    trigger
-  }
-}

package/src/hooks/useFavoriteStores/index.js

@@ -1,29 +0,0 @@
-import { useQuery } from '@apollo/client'
-import { GET_ALL_FAV_STORE } from './queries'
-import { filterAndSortByDate } from '../useRestaurant/helpers'
-import { getStatusForStores } from '../useRestaurant/helpers/manageStatusOpen'
-
-export const useFavoriteStores = () => {
-  const {
-    data,
-    loading,
-    error
-  } = useQuery(GET_ALL_FAV_STORE, {
-    fetchPolicy: 'cache-and-network',
-    onError: () => {
-      console.log('')
-    }
-  })
-  const newArray = data?.getFavorite?.map(store => {
-    return {
-      ...store.getOneStore
-    }
-  }) || []
-  const dataSort = filterAndSortByDate(newArray)
-
-  const statuses = getStatusForStores(dataSort)
-
-  const favoriteStores = statuses || []
-
-  return [loading ? [] : favoriteStores, { loading, error }]
-}