npm-pkg-hook 1.12.4 → 1.12.8

package/src/hooks/useSubscriptionValidation/index.ts

@@ -0,0 +1,112 @@
+import { gql, useQuery } from '@apollo/client'
+import { useEffect, useState } from 'react'
+
+/**
+ * GraphQL query to validate free subscription
+ */
+const VALIDATE_SUBSCRIPTION_QUERY = gql`
+  query validateFreeSubscription($idStore: ID) {
+    validateFreeSubscription(idStore: $idStore) {
+      subscriptionId
+      status
+      businessName
+      currentPeriodEnd
+      currentPeriodStart
+    }
+  }
+`
+
+/**
+ * Subscription entity returned by the API
+ */
+export interface SubscriptionData {
+  subscriptionId: string
+  status: string
+  businessName: string
+  currentPeriodEnd: string
+  currentPeriodStart: string
+}
+
+/**
+ * GraphQL query response shape
+ */
+interface ValidateSubscriptionResponse {
+  validateFreeSubscription: SubscriptionData
+}
+
+/**
+ * Hook return type
+ */
+export interface UseSubscriptionValidationResult {
+  loading: boolean
+  error?: Error
+  subscriptionData?: SubscriptionData
+  daysRemaining: number | null
+  daysElapsed: number | null
+}
+
+/**
+ * Hook to validate store subscription and calculate elapsed/remaining days.
+ * Keeps original behavior and calculations intact.
+ *
+ * @param {string} idStore - Store identifier
+ * @returns {UseSubscriptionValidationResult}
+ */
+export const useSubscriptionValidation = (
+  idStore: string
+): UseSubscriptionValidationResult => {
+  const { loading, error, data } = useQuery<ValidateSubscriptionResponse>(
+    VALIDATE_SUBSCRIPTION_QUERY,
+    {
+      variables: { idStore }
+    }
+  )
+
+  const [daysRemaining, setDaysRemaining] = useState<number | null>(null)
+  const [daysElapsed, setDaysElapsed] = useState<number | null>(null)
+
+  useEffect(() => {
+    if (data?.validateFreeSubscription) {
+      const { currentPeriodEnd, currentPeriodStart } =
+        data.validateFreeSubscription
+
+      const currentDate = new Date()
+      const endOfPeriod = new Date(parseInt(currentPeriodEnd, 10))
+      const startOfPeriod = new Date(parseInt(currentPeriodStart, 10))
+
+      const differenceInTimeUntilEnd =
+        endOfPeriod.getTime() - currentDate.getTime()
+
+      const differenceInDaysUntilEnd = Math.ceil(
+        differenceInTimeUntilEnd / (1000 * 3600 * 24)
+      )
+
+      setDaysRemaining(
+        isNaN(differenceInDaysUntilEnd)
+          ? 0
+          : differenceInDaysUntilEnd
+      )
+
+      const differenceInTimeSinceStart =
+        currentDate.getTime() - startOfPeriod.getTime()
+
+      const differenceInDaysSinceStart = Math.ceil(
+        differenceInTimeSinceStart / (1000 * 3600 * 24)
+      )
+
+      setDaysElapsed(
+        isNaN(differenceInDaysSinceStart)
+          ? 0
+          : differenceInDaysSinceStart
+      )
+    }
+  }, [data])
+
+  return {
+    loading,
+    error: error ?? undefined,
+    subscriptionData: data?.validateFreeSubscription,
+    daysRemaining,
+    daysElapsed
+  }
+}

package/src/hooks/useTagProducts/useDeleteOneTag.ts

@@ -27,80 +27,80 @@ const DELETE_ONE_TAG = gql`
  * @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
+  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
+      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
-                        ) || []
+      // Update cache for getAllTags
+      cache.modify({
+        fields: {
+          getAllTags(existing = {}) {
+            const filteredData = existing?.data?.filter(
+              (tag: any) => {return 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)
+            return {
+              ...existing,
+              data: filteredData,
+              pagination: {
+                ...existing.pagination,
+                totalRecords: Math.max((existing.pagination?.totalRecords || 1) - 1, 0)
+              }
+            }
+          }
         }
-    })
-    /**
-     * 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
-    }: {
+      })
+    },
+    // 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'
-                    }
-                ]
-            }
+    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
-    }]
+  return [handleDeleteTag, {
+    data,
+    loading,
+    error
+  }]
 }

package/src/hooks/useTagProducts/useGetAllTags.ts

@@ -51,7 +51,7 @@ query getAllTags {
  */
 export const useGetAllTags = () => {
   const { data, loading, error } = useQuery(GET_ALL_TAGS, {
-    fetchPolicy: 'network-only',
+    fetchPolicy: 'network-only'
   })
 
   const result = data?.getAllTags ?? {}
@@ -63,6 +63,6 @@ export const useGetAllTags = () => {
     message: result?.message ?? '',
     success: result?.success ?? false,
     pagination: result?.pagination ?? null,
-    errors: result?.errors ?? null,
+    errors: result?.errors ?? null
   }
 }

package/src/hooks/useTagProducts/useRegisterMultipleTags.ts

@@ -1,4 +1,5 @@
-import { useMutation, gql, useApolloClient } from '@apollo/client'
+import { useMutation, gql, useApolloClient } from '@apollo/client'
+
 import { GET_ALL_TAGS } from './useGetAllTags'
 
 /**
@@ -98,7 +99,7 @@ export const useRegisterMultipleTags = (
    * @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')) {
+    if (!Array.isArray(tags) || tags.length === 0 || tags.some(tag => {return typeof tag !== 'string'})) {
       throw new Error('Tag list must be a non-empty array of strings.')
     }
 
@@ -106,36 +107,36 @@ export const useRegisterMultipleTags = (
       variables: {
         input: tags
       },
-       update: (cache, { data }) => {
-      if (!data?.registerMultipleTags?.data?.length) return;
+      update: (cache, { data }) => {
+        if (!data?.registerMultipleTags?.data?.length) return
 
-      const newTags = data.registerMultipleTags.data;
+        const newTags = data.registerMultipleTags.data
 
-      try {
-        const existing = client.readQuery({ query: GET_ALL_TAGS });
+        try {
+          const existing = client.readQuery({ query: GET_ALL_TAGS })
 
-        const updatedTags = [
-          ...newTags,
-          ...(existing?.getAllTags?.data || [])
-        ];
+          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,
-              },
+          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);
+          })
+        } catch (error) {
+          console.warn('Failed to update cache for GET_ALL_TAGS:', error)
+        }
       }
-    },
     })
     return response.data?.registerMultipleTags ?? {
       success: false,

package/src/hooks/useTheme/index.ts

@@ -0,0 +1,65 @@
+import { useState } from 'react'
+
+import { Cookies } from '../../cookies'
+
+enum Theme {
+  LIGHT = 'light',
+  DARK = 'dark',
+}
+
+/**
+ * Handles light/dark theme switching using data-theme attribute.
+ * Cookie is used only for persistence, not as source of truth.
+ */
+export const useTheme = () => {
+
+  // STATES
+  const [theme, setTheme] = useState<Theme>(Theme.LIGHT)
+  /**
+   * Applies theme to DOM and persists it.
+   * @param theme
+   */
+  const applyTheme = (theme: Theme): void => {
+    document.documentElement.setAttribute('data-theme', theme)
+    Cookies.set('theme', theme, { expires: 365 })
+    setTheme(theme)
+  }
+
+  /**
+   * Toggles between light and dark themes.
+   */
+  const toggleTheme = (): void => {
+    if (typeof document === 'undefined') return
+
+    const current =
+      (document.documentElement.getAttribute('data-theme') as Theme) ??
+      Theme.LIGHT
+
+    applyTheme(current === Theme.DARK ? Theme.LIGHT : Theme.DARK)
+    setTheme(current === Theme.DARK ? Theme.LIGHT : Theme.DARK)
+  }
+
+  /**
+   * Initializes theme from cookie or system preference.
+   */
+  const initTheme = (): void => {
+    if (typeof document === 'undefined') return
+
+    const cookieTheme = Cookies.get('theme') as Theme | undefined
+
+    const systemTheme =
+      window.matchMedia?.('(prefers-color-scheme: dark)').matches
+        ? Theme.DARK
+        : Theme.LIGHT
+
+    applyTheme(cookieTheme ?? systemTheme)
+    setTheme(cookieTheme ?? systemTheme)
+  }
+
+  return {
+    setTheme: applyTheme,
+    toggleTheme,
+    initTheme,
+    theme
+  }
+}

package/src/hooks/useTimeAgo/{useTimeAgo.js → useTimeAgo.ts}

@@ -1,13 +1,15 @@
 import { useEffect, useState } from 'react'
 
-const DATE_UNITS = [
+const DATE_UNITS: [unit: Intl.RelativeTimeFormatUnit, secondsInUnit: number][] = [
   ['day', 86400],
   ['hour', 3600],
   ['minute', 60],
   ['second', 1]
 ]
 
-const getDateDiffs = (timestamp) => {
+type DateDiff = { value: number; unit: Intl.RelativeTimeFormatUnit }
+
+const getDateDiffs = (timestamp: number): DateDiff | undefined => {
   const now = Date.now()
   const elapsed = (timestamp - now) / 1000
 
@@ -19,8 +21,8 @@ const getDateDiffs = (timestamp) => {
   }
 }
 
-export const useTimeAgo = (timestamp) => {
-  const [timeAgo, setTimeAgo] = useState(() => { return getDateDiffs(timestamp) })
+export const useTimeAgo = (timestamp: number) => {
+  const [timeAgo, setTimeAgo] = useState<DateDiff | undefined>(() => getDateDiffs(timestamp))
 
   useEffect(() => {
     const interval = setInterval(() => {
@@ -33,7 +35,5 @@ export const useTimeAgo = (timestamp) => {
 
   const rtf = new Intl.RelativeTimeFormat('es', { style: 'short' })
 
-  const { value, unit } = timeAgo
-
-  return rtf && rtf?.format(value, unit)
+  return rtf?.format(timeAgo?.value ?? 0, (timeAgo?.unit ?? 'second'))
 }

package/src/hooks/useTokenCards/{index.js → index.ts}

@@ -2,10 +2,10 @@ import { useState } from 'react'
 
 export const useTokenCards = () => {
   const [loading, setLoading] = useState(false)
-  const [error, setError] = useState(null)
+  const [error, setError] = useState<string | null>(null)
   const [responseData, setResponseData] = useState(null)
 
-  const handleTokenCardsSubmit = async (postData) => {
+  const handleTokenCardsSubmit = async (postData: any) => {
     setLoading(true)
     setError(null)
     try {
@@ -28,7 +28,11 @@ export const useTokenCards = () => {
       setResponseData(responseData)
       return responseData
     } catch (error) {
-      setError(error.message)
+      if (error instanceof Error) {
+        setError(String(error.message))
+      } else {
+        setError(String(error))
+      }
       return {
 
       }

package/src/hooks/useUpdateCart/{index.js → index.ts}

@@ -1,8 +1,9 @@
 import debounce from 'lodash'
-import { useState, useEffect } from 'react'
+import { useState, useEffect } from 'react'
+
+import { Cookies } from '../../cookies'
 import { getCurrentDomain } from '../../utils'
 import { trigger } from '../useEvent'
-import { Cookies } from '../../cookies'
 
 // EXAMPLE
 // https://codesandbox.io/s/nextjs-cart-system-tfg1e?file=/pages/_app.js

package/src/hooks/useUpdateCartCookie/{index.js → index.ts}

@@ -1,18 +1,35 @@
 import { useEffect, useReducer } from 'react'
-import { initializer } from '../useSales'
+
 import { Cookies } from '../../cookies'
 import { getCurrentDomain } from '../../utils'
 
+type Product = {
+  pId: string;
+  ProQuantity: number;
+  [key: string]: any;
+};
+
+type State = {
+  PRODUCT: Product[];
+  counter: number;
+};
+
+type Action =
+  | { type: 'REMOVE_PRODUCT_TO_CART'; payload: Product }
+  | { type: 'ADD_PRODUCT_TO_CART'; payload: Product }
+  | { type: 'UPDATE_PRODUCT_IN_CART'; payload: Product }
+  | { type: string; payload?: any };
+
 export const useUpdateCartCookie = () => {
-  const keyToSaveData = process.env.LOCAL_SALES_STORE
+  const keyToSaveData = process.env.NEXT_LOCAL_SALES_STORE
   const domain = getCurrentDomain()
 
-  const PRODUCT = (state, action) => {
+  const PRODUCT = (state: State, action: Action): State => {
     switch (action.type) {
       case 'REMOVE_PRODUCT_TO_CART':
         return {
           ...state,
-          PRODUCT: state?.PRODUCT?.filter((t) => {
+          PRODUCT: state?.PRODUCT?.filter((t: Product) => {
             return t.pId !== action?.payload.pId
           }),
           counter: state.counter - action.payload.ProQuantity
@@ -27,9 +44,9 @@ export const useUpdateCartCookie = () => {
         return state
     }
   }
-  const [data, dispatch] = useReducer(PRODUCT, { PRODUCT: [], counter: 0 }, initializer)
+  const [data, dispatch] = useReducer(PRODUCT, { PRODUCT: [], counter: 0 })
 
-  const handleRemoveProductToCookieCart = (product) => {
+  const handleRemoveProductToCookieCart = (product: Product) => {
     dispatch({ type: 'REMOVE_PRODUCT_TO_CART', payload: product })
   }
   useEffect(() => {

package/src/hooks/useUpdateDashboardComponent/index.ts

@@ -1,4 +1,4 @@
-import { gql, useMutation } from '@apollo/client';
+import { gql, useMutation } from '@apollo/client'
 
 /**
  * GraphQL mutation for updating a dashboard component.
@@ -24,7 +24,7 @@ const UPDATE_DASHBOARD_COMPONENT = gql`
       }
     }
   }
-`;
+`
 
 /**
  * Types for the mutation response and input.
@@ -66,7 +66,7 @@ export const useUpdateDashboardComponent = () => {
   const [mutate, { loading, error, data }] = useMutation<
     UpdateDashboardComponentResponse,
     { input: UpdateDashboardComponentInput[] }
-  >(UPDATE_DASHBOARD_COMPONENT);
+  >(UPDATE_DASHBOARD_COMPONENT)
 
   /**
    * Calls the mutation with the provided input.
@@ -74,18 +74,18 @@ export const useUpdateDashboardComponent = () => {
    */
   const updateComponent = async (input: UpdateDashboardComponentInput[]) => {
     try {
-      const response = await mutate({ variables: { input } });
-      return response.data?.updateDashboardComponent;
+      const response = await mutate({ variables: { input } })
+      return response.data?.updateDashboardComponent
     } catch (err) {
-      console.error('UpdateDashboardComponent Error:', err);
-      throw err;
+      console.error('UpdateDashboardComponent Error:', err)
+      throw err
     }
-  };
+  }
 
   return {
     updateComponent,
     loading,
     error,
-    data: data?.updateDashboardComponent,
-  };
-};
+    data: data?.updateDashboardComponent
+  }
+}

package/src/hooks/useUpdateExtProductFoodsSubOptional/{index.js → index.ts}

@@ -1,4 +1,5 @@
-import { useMutation } from '@apollo/client'
+import { useMutation } from '@apollo/client'
+
 import { updateCacheMod } from '../../utils'
 import { GET_EXTRAS_PRODUCT_FOOD_OPTIONAL, GET_EXTRAS_PRODUCT_FOOD_SUB_OPTIONAL } from '../useProductsFood/queriesStore'
 

package/src/hooks/useUpdateModuleOrder/{index.js → index.ts}

@@ -1,5 +1,5 @@
-import { useCallback } from 'react'
 import { gql, useMutation } from '@apollo/client'
+import { useCallback } from 'react'
 
 const UPDATE_MODULE_ORDER = gql`
   mutation UpdateModuleOrder($input: [UpdateModuleOrderInput]!) {
@@ -25,7 +25,7 @@ export const useUpdateModuleOrder = () => {
     // Enviar la actualización a la API (GraphQL)
     try {
       await updateModuleOrderMutation({
-        variables: { input: newOrder.map(({ mId, mPriority }) => ({ mId, mPriority })) }
+        variables: { input: newOrder.map(({ mId, mPriority }) => {return { mId, mPriority }}) }
       })
     } catch (error) {
       console.error('Error updating module order:', error)

package/src/hooks/useUpdateMultipleExtProduct/{index.js → index.ts}

@@ -1,4 +1,5 @@
-import { useMutation } from '@apollo/client'
+import { useMutation } from '@apollo/client'
+
 import { UPDATE_MULTI_EXTRAS_PRODUCT_FOOD } from './queries'
 
 /**