npm-pkg-hook 1.11.3 → 1.11.7

package/src/hooks/useTagProducts/useDeleteOneTag.ts

@@ -0,0 +1,106 @@
+import { gql, useMutation } from '@apollo/client'
+
+/**
+ * GraphQL mutation to delete a tag by ID or name.
+ */
+const DELETE_ONE_TAG = gql`
+  mutation deleteOneTag($tgId: ID, $nameTag: String) {
+    deleteOneTag(tgId: $tgId, nameTag: $nameTag) {
+      success
+      message
+      data {
+        tgId
+        nameTag
+        state
+      }
+      errors {
+        path
+        message
+        type
+      }
+    }
+  }
+`
+
+/**
+ * Custom hook to delete a tag by ID or name.
+ * @returns {Object} An object with the deleteTag function and mutation state.
+ */
+export const useDeleteOneTag = () => {
+    const [deleteOneTag, { data, loading, error }] = useMutation(DELETE_ONE_TAG, {
+        update(cache, { data }) {
+            const deleted = data?.deleteOneTag?.data
+            const success = data?.deleteOneTag?.success
+
+            if (!success || !deleted?.tgId) return
+
+            // Update cache for getAllTags
+            cache.modify({
+                fields: {
+                    getAllTags(existing = {}) {
+                        const filteredData = existing?.data?.filter(
+                            (tag: any) => tag.tgId !== deleted.tgId
+                        ) || []
+
+                        return {
+                            ...existing,
+                            data: filteredData,
+                            pagination: {
+                                ...existing.pagination,
+                                totalRecords: Math.max((existing.pagination?.totalRecords || 1) - 1, 0)
+                            }
+                        }
+                    }
+                }
+            })
+        },
+        // optional, remove if you prefer default behavior
+        onError(err) {
+            console.error('❌ Apollo error in deleteOneTag:', err)
+        }
+    })
+    /**
+     * Deletes a tag by ID or name.
+     * @param {Object} variables - Mutation input.
+     * @param {string} [variables.tgId] - Tag ID (optional).
+     * @param {string} [variables.nameTag] - Tag name (optional).
+     * @returns {Promise<Object>} Response from server.
+     */
+    const handleDeleteTag = async ({
+        tgId,
+        nameTag
+    }: {
+        tgId?: string
+        nameTag?: string
+    }) => {
+        try {
+            const { data } = await deleteOneTag({
+                variables: {
+                    tgId,
+                    nameTag
+                }
+            })
+
+            return data.deleteOneTag
+        } catch (err: any) {
+            return {
+                success: false,
+                message: 'An error occurred while deleting the tag.',
+                data: null,
+                errors: [
+                    {
+                        path: 'mutation',
+                        message: err.message || 'Unknown error',
+                        type: 'server'
+                    }
+                ]
+            }
+        }
+    }
+
+    return [handleDeleteTag, {
+        data,
+        loading,
+        error
+    }]
+}

package/src/hooks/useTagProducts/useGetAllTags.ts

@@ -0,0 +1,68 @@
+import { useQuery, gql } from '@apollo/client'
+
+/**
+ * GraphQL query to fetch all tags
+ */
+export const GET_ALL_TAGS = gql`
+query getAllTags {
+  getAllTags {
+    success
+    message
+    pagination {
+      totalRecords
+      totalPages
+      currentPage
+    }
+    data {
+      tgId
+      idUser
+      idStore
+      pId
+      nameTag
+      aName
+    }
+    errors {
+      path
+      message
+      type
+      context {
+        limit
+        value
+        label
+        key
+      }
+    }
+  }
+}
+`
+
+/**
+ * Custom hook to fetch all tags
+ *
+ * @returns {{
+ *  tags: any[],
+ *  loading: boolean,
+ *  error: Error | null,
+ *  message: string,
+ *  success: boolean,
+ *  pagination: { totalRecords: number, totalPages: number, currentPage: number } | null,
+ *  errors: any[] | null
+ * }}
+ */
+export const useGetAllTags = () => {
+  const { data, loading, error } = useQuery(GET_ALL_TAGS, {
+    fetchPolicy: 'network-only',
+  })
+
+  const result = data?.getAllTags ?? {}
+
+  return {
+    tags: result?.data || [],
+    loading,
+    error,
+    message: result?.message ?? '',
+    success: result?.success ?? false,
+    pagination: result?.pagination ?? null,
+    errors: result?.errors ?? null,
+  }
+}

package/src/hooks/useTagProducts/useRegisterMultipleTags.ts

@@ -0,0 +1,156 @@
+import { useMutation, gql, useApolloClient } from '@apollo/client'
+import { GET_ALL_TAGS } from './useGetAllTags'
+
+/**
+ * GraphQL mutation to register multiple tags.
+ */
+const REGISTER_MULTIPLE_TAGS = gql`
+  mutation registerMultipleTags($input: [String!]!) {
+    registerMultipleTags(input: $input) {
+      success
+      message
+      errors {
+        path
+        message
+      }
+      data {
+        tgId
+        nameTag
+        idStore
+        idUser
+      }
+    }
+  }
+`
+
+/**
+ * Response structure for tag registration errors.
+ */
+interface ITagError {
+  path: string
+  message: string
+}
+
+/**
+ * Structure for a registered tag.
+ */
+interface ITag {
+  tgId: string
+  nameTag: string
+  idStore: string
+  idUser: string
+}
+
+/**
+ * General GraphQL response for registering tags.
+ */
+interface IResponseTag {
+  success: boolean
+  message: string
+  errors: ITagError[]
+  data: ITag[]
+}
+
+/**
+ * Options for the useRegisterMultipleTags hook.
+ */
+interface UseRegisterMultipleTagsOptions {
+  callback?: (response: IResponseTag) => void
+}
+
+/**
+ * Return type for the useRegisterMultipleTags hook.
+ */
+type UseRegisterMultipleTagsReturn = [
+  (tags: string[]) => Promise<IResponseTag>,
+  {
+    loading: boolean
+    error: any
+    data: IResponseTag | null
+  }
+]
+
+/**
+ * Hook to register multiple tags via GraphQL mutation.
+ *
+ * @param {UseRegisterMultipleTagsOptions} [options] - Optional callback for post-mutation handling.
+ * @returns {UseRegisterMultipleTagsReturn} - Mutation handler and state.
+ */
+export const useRegisterMultipleTags = (
+  { callback = () => { } }: UseRegisterMultipleTagsOptions = {}
+): UseRegisterMultipleTagsReturn => {
+  const client = useApolloClient()
+  const [registerMultipleTags, { loading, error, data }] = useMutation<
+    { registerMultipleTags: IResponseTag },
+    { input: string[] }
+  >(REGISTER_MULTIPLE_TAGS, {
+    onCompleted: (data) => {
+      if (typeof callback === 'function') {
+        callback(data.registerMultipleTags)
+      }
+    }
+  })
+
+  /**
+   * Register multiple tags with the provided names.
+   *
+   * @param {string[]} tags - Array of tag names.
+   * @returns {Promise<IResponseTag>} - Mutation response.
+   */
+  const handleRegisterTags = async (tags: string[]): Promise<IResponseTag> => {
+    if (!Array.isArray(tags) || tags.length === 0 || tags.some(tag => typeof tag !== 'string')) {
+      throw new Error('Tag list must be a non-empty array of strings.')
+    }
+
+    const response = await registerMultipleTags({
+      variables: {
+        input: tags
+      },
+       update: (cache, { data }) => {
+      if (!data?.registerMultipleTags?.data?.length) return;
+
+      const newTags = data.registerMultipleTags.data;
+
+      try {
+        const existing = client.readQuery({ query: GET_ALL_TAGS });
+
+        const updatedTags = [
+          ...newTags,
+          ...(existing?.getAllTags?.data || [])
+        ];
+
+        cache.writeQuery({
+          query: GET_ALL_TAGS,
+          data: {
+            getAllTags: {
+              ...existing.getAllTags,
+              data: updatedTags,
+              pagination: {
+                ...existing.getAllTags.pagination,
+                totalRecords: updatedTags.length,
+              },
+            }
+          }
+        });
+      } catch (error) {
+        console.warn('Failed to update cache for GET_ALL_TAGS:', error);
+      }
+    },
+    })
+    return response.data?.registerMultipleTags ?? {
+      success: false,
+      message: 'No response from server',
+      errors: [],
+      data: []
+    }
+  }
+
+  return [
+    handleRegisterTags,
+    {
+      loading,
+      error,
+      data: data?.registerMultipleTags ?? null
+    }
+  ]
+}

package/src/hooks/useUpdateDashboardComponent/index.ts

@@ -0,0 +1,91 @@
+import { gql, useMutation } from '@apollo/client';
+
+/**
+ * GraphQL mutation for updating a dashboard component.
+ */
+const UPDATE_DASHBOARD_COMPONENT = gql`
+  mutation UpdateDashboardComponent($input: [DashboardComponentUpdateInput]) {
+    updateDashboardComponent(input: $input) {
+      success
+      message
+      data {
+        id
+        idStore
+        idUser
+        coordinates
+        createAt
+        updateAt
+        title
+      }
+      errors {
+      path
+      message
+      type
+      }
+    }
+  }
+`;
+
+/**
+ * Types for the mutation response and input.
+ */
+interface DashboardComponent {
+  id: string;
+  idStore: string;
+  idUser: string;
+  coordinates: any;
+  createAt: string;
+  updateAt: string;
+  title: string;
+}
+
+interface ErrorResponse {
+  message: string;
+  field?: string;
+}
+
+interface UpdateDashboardComponentResponse {
+  updateDashboardComponent: {
+    success: boolean;
+    message?: string;
+    data?: DashboardComponent;
+    errors?: ErrorResponse[];
+  };
+}
+
+interface UpdateDashboardComponentInput {
+  id: string;
+  coordinates?: any;
+  title?: string;
+}
+
+/**
+ * Custom hook to update a dashboard component.
+ */
+export const useUpdateDashboardComponent = () => {
+  const [mutate, { loading, error, data }] = useMutation<
+    UpdateDashboardComponentResponse,
+    { input: UpdateDashboardComponentInput[] }
+  >(UPDATE_DASHBOARD_COMPONENT);
+
+  /**
+   * Calls the mutation with the provided input.
+   * @param input DashboardComponentUpdateInput
+   */
+  const updateComponent = async (input: UpdateDashboardComponentInput[]) => {
+    try {
+      const response = await mutate({ variables: { input } });
+      return response.data?.updateDashboardComponent;
+    } catch (err) {
+      console.error('UpdateDashboardComponent Error:', err);
+      throw err;
+    }
+  };
+
+  return {
+    updateComponent,
+    loading,
+    error,
+    data: data?.updateDashboardComponent,
+  };
+};

package/src/hooks/useUpdateExistingOrders/index.js

@@ -2,11 +2,6 @@ export const isValidCodeRef = (codeRef) => {
   return typeof codeRef === 'string' && codeRef.trim() !== ''
 }
 
-export const isValidState = (state) => {
-  const validStates = [1, 2, 3, 4, 5]
-  return validStates.includes(state)
-}
-
 export const updateExistingOrders = (
   existingOrders,
   pCodeRef,
@@ -17,11 +12,11 @@ export const updateExistingOrders = (
     // existingOrders no es un objeto válido
     return existingOrders
   }
-  if (typeof pCodeRef !== 'string' || typeof pSState !== 'number') {
-    // Los tipos de datos de pCodeRef y pSState no son los esperados
+  if (typeof pCodeRef !== 'string') {
+    // Los tipos de datos de pCodeRef
     return existingOrders
   }
-  if (!isValidCodeRef(pCodeRef) || !isValidState(pSState)) {
+  if (!isValidCodeRef(pCodeRef)) {
     // Valores de entrada no válidos, devuelve existingOrders sin cambios
     return existingOrders
   }
@@ -41,7 +36,6 @@ export const updateExistingOrders = (
     // El valor de pSState no está mapeado a ninguna propiedad existente en existingOrders
     return existingOrders
   }
-
   Object.keys(updatedExistingOrders).forEach((key) => {
     if (Array.isArray(updatedExistingOrders[key])) {
       const oneSale = updatedExistingOrders[key].find((order) => {

package/src/hooks/useUpdateExtProductFoodsSubOptional/index.js

@@ -2,8 +2,30 @@ import { useMutation } from '@apollo/client'
 import { updateCacheMod } from '../../utils'
 import { GET_EXTRAS_PRODUCT_FOOD_OPTIONAL, GET_EXTRAS_PRODUCT_FOOD_SUB_OPTIONAL } from '../useProductsFood/queriesStore'
 
-export const useUpdateExtProductFoodsSubOptional = () => {
-  const [updateExtProductFoodsSubOptional] = useMutation(GET_EXTRAS_PRODUCT_FOOD_SUB_OPTIONAL)
+export const useUpdateExtProductFoodsSubOptional = ({
+  sendNotification = (args) => { return args }
+} = {}) => {
+  const [updateExtProductSubOptional] = useMutation(GET_EXTRAS_PRODUCT_FOOD_SUB_OPTIONAL, {
+    onCompleted: (data) => {
+      console.log('🚀 ~ useUpdateExtProductFoodsSubOptional ~ data:', data)
+      const { updateExtProductSubOptional } = data ?? {}
+      const { success, message, errors } = updateExtProductSubOptional ?? {}
+      sendNotification({
+        description: message,
+        title: success ? 'Sub item creado' : 'Error',
+        backgroundColor: success ? 'success' : 'error'
+      })
+      for (const err of errors || []) {
+        const { message: msg } = err || {}
+        sendNotification({
+          description: msg,
+          title: 'Error',
+          backgroundColor: 'error'
+        })
+      }
+      return data
+    }
+  })
 
   const handleMutateExtProductFoodsSubOptional = ({
     pId,
@@ -12,7 +34,7 @@ export const useUpdateExtProductFoodsSubOptional = () => {
     id,
     state = 1
   }) => {
-    updateExtProductFoodsSubOptional({
+    updateExtProductSubOptional({
       variables: {
         input: {
           pId,

package/src/hooks/useUpdateMultipleExtProduct/index.js

@@ -0,0 +1,33 @@
+import { useMutation } from '@apollo/client'
+import { UPDATE_MULTI_EXTRAS_PRODUCT_FOOD } from './queries'
+
+/**
+ * Custom hook para manejar la actualización de múltiples extras de productos alimenticios.
+ * @param {Function} cleanLines - Función para limpiar líneas después de completar la mutación.
+ * @param {Function} handleCleanLines - Función.
+ * @returns {Array} Retorna un array con la función de mutación y el estado de carga.
+ */
+export const useUpdateMultipleExtProduct = ({
+  cleanLines = () => { },
+  handleCleanLines = () => { },
+  sendNotification = () => { }
+} = {
+  cleanLines: () => { },
+  handleCleanLines: () => { },
+  sendNotification: () => { }
+}) => {
+  const [updateMultipleExtProduct, { loading }] = useMutation(UPDATE_MULTI_EXTRAS_PRODUCT_FOOD, {
+    onCompleted: (data) => {
+      const { updateMultipleExtProduct: result } = data
+      const { success, message } = result ?? {}
+      sendNotification({
+        title: message,
+        description: success ? 'Operación exitosa' : 'Error',
+        backgroundColor: success ? 'success' : 'error'
+      })
+      cleanLines()
+    }
+  })
+
+  return [updateMultipleExtProduct, { loading }]
+}

package/src/hooks/useUpdateMultipleExtProduct/queries.js

@@ -0,0 +1,33 @@
+import { gql } from '@apollo/client'
+
+// CREATE EXTRAS PRODUCT
+export const UPDATE_MULTI_EXTRAS_PRODUCT_FOOD = gql`
+mutation updateMultipleExtProduct($inputLineItems: ILineItemsExtraFinal) {
+  updateMultipleExtProduct(inputLineItems: $inputLineItems) {
+    success
+    message
+    data {
+      pId
+      exPid
+      exState
+      extraName
+      extraPrice
+      state
+      createdAt
+      updatedAt
+    }
+    errors {
+      path
+      message
+      type
+      context {
+        limit
+        value
+        label
+        key
+        __typename
+      }
+    }
+  }
+}
+`

package/src/hooks/useUploadProducts/index.js

@@ -14,7 +14,6 @@ export const useUploadProducts = ({
   sendNotification: () => { return null }
 }) => {
   const [data, setData] = useState([])
-  console.log("🚀 ~ data:", data)
   const [isLoading, setIsLoading] = useState(false)
   const [active, setActive] = useState(STEPS.UPLOAD_FILE)
   const [overActive, setOverActive] = useState(STEPS.UPLOAD_FILE)

package/src/hooks/useUser/queries.js

@@ -67,7 +67,6 @@ upIdeDoc
 siteWeb
 description
 associateStore
-createAt
   role {
     name
     permissions

package/src/utils/index.js

@@ -1,3 +1,5 @@
+import { randomBytes } from 'crypto'
+
 /**
  * @description It takes an array of elements and returns an object with a submit hook for each element.
  * @version 0.1.1
@@ -57,15 +59,33 @@ export const getCurrentDomain = () => {
   return typeof window !== 'undefined' && window.location.hostname
 }
 
-export function RandomCode (length) {
-  let result = ''
+/**
+ * Generates a cryptographically secure random string of given length.
+ * @param length - Desired length of the generated code.
+ * @param options - Optional prefix/suffix configuration.
+ * @returns Random alphanumeric string with optional prefix and suffix.
+ */
+export const RandomCode = (
+  length,
+  options
+) => {
+  if (length <= 0) {
+    throw new Error('Length must be greater than 0')
+  }
+
   const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
   const charactersLength = characters.length
+
+  // Generate enough random bytes
+  const randomBuffer = randomBytes(length)
+  let code = ''
+
   for (let i = 0; i < length; i++) {
-    result += characters.charAt(Math.floor(Math.random() *
-        charactersLength))
+    const index = randomBuffer[i] % charactersLength
+    code += characters.charAt(index)
   }
-  return result
+
+  return `${options?.prefix ?? ''}${code}${options?.suffix ?? ''}`
 }
 
 /**
@@ -212,3 +232,75 @@ export const paymentMethodCards = [
 export const CATEGORY_EMPTY = 'NINGUNO'
 
 export * from './UtilDateRange'
+
+const cleanValue = ({ value, decimalSeparator, groupSeparator, allowDecimals, decimalsLimit, allowNegativeValue, disableAbbreviations }) => {
+  if (typeof value !== 'string') return null
+
+  // Remove currency symbols and whitespace
+  let cleaned = value.replace(/[$€£¥]/g, '').trim()
+
+  // Handle abbreviations like K, M, B
+  if (!disableAbbreviations) {
+    cleaned = cleaned.replace(/([kmb])\b/i, (match) => {
+      const multipliers = { k: 1e3, m: 1e6, b: 1e9 }
+      return multipliers[match.toLowerCase()] ? `*${multipliers[match.toLowerCase()]}` : ''
+    })
+  }
+
+  // Replace group separator with empty string
+  if (groupSeparator) {
+    cleaned = cleaned.replace(new RegExp(`\\${groupSeparator}`, 'g'), '')
+  }
+
+  // Replace decimal separator with a dot
+  if (decimalSeparator) {
+    cleaned = cleaned.replace(new RegExp(`\\${decimalSeparator}`, 'g'), '.')
+  }
+
+  // Remove any non-numeric characters except for the decimal point
+  cleaned = cleaned.replace(/[^0-9.-]/g, '')
+
+  // Limit decimals if specified
+  if (allowDecimals && decimalsLimit > 0) {
+    const parts = cleaned.split('.')
+    if (parts.length > 1) {
+      parts[1] = parts[1].slice(0, decimalsLimit)
+      cleaned = parts.join('.')
+    }
+  }
+
+  // Handle negative values
+  if (!allowNegativeValue) {
+    cleaned = cleaned.replace(/-/g, '')
+  }
+
+  return cleaned
+}
+/**
+ * Converts a formatted string with group and decimal separators into a float number.
+ *
+ * @param value - The formatted string input, e.g., "$ 1.234,56"
+ * @param decimalSeparator - The character used as decimal separator, e.g., ','
+ * @param groupSeparator - The character used as group/thousands separator, e.g., '.'
+ * @returns The parsed float value or null if input is invalid
+ */
+export function parseFormattedFloat (value) {
+  if (!value) return 0
+  const options = {
+    decimalSeparator: ',',
+    groupSeparator: '.',
+    allowDecimals: true,
+    decimalsLimit: 20,
+    allowNegativeValue: true,
+    disableAbbreviations: false
+  }
+  const cleaned = cleanValue({ value, ...options })
+
+  const normalized = (typeof options.decimalSeparator === 'string' && options.decimalSeparator !== '')
+  // Replace the decimal separator with a dot for parsing
+    ? cleaned.replace(options.decimalSeparator, '.')
+    : cleaned
+
+  const num = parseFloat(normalized)
+  return isNaN(num) ? 0 : num
+}