npm-pkg-hook 1.12.4 → 1.12.8

package/eslint.config.mts

@@ -0,0 +1,153 @@
+import js from "@eslint/js"
+import { defineConfig } from "eslint/config"
+import importPlugin from "eslint-plugin-import"
+import jsdoc from "eslint-plugin-jsdoc"
+import react from "eslint-plugin-react"
+import globals from "globals"
+import tseslint from "typescript-eslint"
+
+export default defineConfig([
+  // base JS/TS files
+  {
+    files: ["**/*.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
+    plugins: { 
+      js,
+      import: importPlugin, // 👈 ,
+      jsdoc,
+      react,
+      "react-hooks": require("eslint-plugin-react-hooks"),
+    },
+    extends: ["js/recommended"],
+    languageOptions: {
+      globals: { ...globals.browser, ...globals.node },
+      ecmaVersion: "latest",
+      sourceType: "module",
+    },
+  },
+
+  // recommended TS config (from typescript-eslint)
+  tseslint.configs.recommended,
+
+  // Strict, opinionated ruleset applied across the codebase
+  {
+    files: ["**/*.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
+    // rely on previously loaded parsers/plugins (typescript-eslint, etc.)
+    rules: {
+      // JavaScript hygiene
+      eqeqeq: "error",
+      curly: ["error", "multi-line"],
+      "no-var": "error",
+      "prefer-const": ["error", { destructuring: "all" }],
+      "no-debugger": "error",
+      "no-console": ["warn", { allow: ["warn", "error"] }],
+      "consistent-return": "error",
+      "no-implicit-coercion": "error",
+
+      // complexity / maintainability
+      complexity: ["warn", 10],
+      "max-params": ["warn", 4],
+      "max-depth": ["warn", 4],
+      "max-lines": ["warn", { max: 400, skipBlankLines: true, skipComments: true }],
+
+      // import/order (requires eslint-plugin-import)
+      "import/order": [
+        "error",
+        {
+          groups: ["builtin", "external", "internal", "parent", "sibling", "index", "type"],
+          "newlines-between": "always",
+          alphabetize: { order: "asc", caseInsensitive: true },
+        },
+      ],
+
+      // encourage clear async/await and promise handling
+      "no-return-await": "error",
+      "require-atomic-updates": "error",
+
+      // jsdoc (requires eslint-plugin-jsdoc) — keep docs enforced
+      "jsdoc/check-alignment": "warn",
+      "jsdoc/require-jsdoc": [
+        "warn",
+        {
+          require: {
+            FunctionDeclaration: true,
+            MethodDefinition: true,
+            ClassDeclaration: true,
+            ArrowFunctionExpression: false,
+            FunctionExpression: false,
+          },
+        },
+      ],
+      "jsdoc/require-param": "error",
+      "jsdoc/require-returns": "error",
+    },
+    settings: {
+      react: { version: "detect" },
+      // import resolver for TypeScript projects (if installed)
+      "import/parsers": { "@typescript-eslint/parser": [".ts", ".tsx"] },
+      "import/resolver": {
+        typescript: {
+          // Use default tsconfig lookup. Override if monorepo packages have own tsconfigs.
+        },
+      },
+    },
+  },
+
+  // React / Next / Hooks specific rules
+  {
+    files: ["**/*.{jsx,tsx}"],
+    rules: {
+      "react/prop-types": "off", // TS covers prop types
+      "react/react-in-jsx-scope": "off",
+      "react/jsx-uses-react": "off",
+      "react/jsx-boolean-value": ["error", "always"],
+      "react/jsx-curly-brace-presence": ["error", { props: "always", children: "never" }],
+      "react/jsx-no-useless-fragment": "error",
+      "react-hooks/rules-of-hooks": "error",
+      "react-hooks/exhaustive-deps": ["warn", { additionalHooks: "(useRecoilCallback)" }],
+    },
+    // ensure react plugin is available in projects using JSX
+    // (no explicit plugin import here plugin must be installed)
+  },
+
+  // Node-only package override for packages/logic (no browser globals, no React)
+  {
+    files: ["packages/logic/**/*.{ts,js}"],
+    languageOptions: {
+      globals: { ...globals.node },
+      sourceType: "module",
+    },
+    rules: {
+      // logic package should be pure and side-effect free where possible
+      "no-restricted-syntax": [
+        "error",
+        {
+          selector: "CallExpression[callee.name='fetch']",
+          message: "Avoid fetch in logic package inject HTTP clients from caller.",
+        },
+      ],
+      "import/no-extraneous-dependencies": ["error", { devDependencies: false, optionalDependencies: false }],
+      // allow fewer UI-related rules
+      "react/no-unknown-property": "off",
+    },
+  },
+
+  // GraphQL linting placeholder (if @graphql-eslint installed + .graphqlrc present)
+  {
+    files: ["**/*.graphql", "**/*.gql", "**/*.{ts,tsx,js,jsx}"],
+    rules: {
+      // keep GraphQL checks opt-in via plugin these are examples you can enable
+      // '@graphql-eslint/no-deprecated-fields': 'warn',
+      // '@graphql-eslint/known-type-names': 'error',
+    },
+  },
+
+  // Strictness for commit-time / CI (can be toggled by CI pipeline)
+  {
+    files: ["**/*.{js,ts,tsx}"],
+    // treat some warnings as errors in CI — consumer can override in CI env
+    rules: {
+      // This is intentionally conservative in local dev CI pipeline can set env to escalate
+      "no-warning-comments": ["warn", { terms: ["todo", "fixme", "xxx"], location: "start" }],
+    },
+  },
+])

package/package.json

@@ -1,50 +1,35 @@
 {
-  "author": "",
-  "dependencies": {
-    "@apollo/client": "3.6.9",
-    "@typescript-eslint/parser": "^5.37.0",
-    "file-saver": "2.0.5",
-    "js-cookie": "3.0.1",
-    "lodash": "^4.17.21",
-    "moment": "^2.29.4",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "react-query": "^3.39.2",
-    "xlsx": "0.18.5"
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
   },
-  "description": "description-pkg-hook",
-  "devDependencies": {
-    "@babel/preset-env": "^7.19.1",
-    "@babel/preset-react": "^7.18.6",
-    "@babel/preset-typescript": "^7.18.6",
-    "@types/node": "^20.11.16",
-    "@types/react": "^18.0.20",
-    "@typescript-eslint/eslint-plugin": "5.29.0",
-    "@typescript-eslint/parser": "5.29.0",
-    "eslint": "^8.0.1",
-    "eslint-config-standard": "^17.0.0",
-    "eslint-plugin-import": "^2.25.2",
-    "eslint-plugin-n": "^15.0.0",
-    "eslint-plugin-promise": "^6.0.0",
-    "eslint-plugin-react": "^7.33.2",
-    "eslint-plugin-react-hooks": "^4.6.0"
-  },
-  "license": "ISC",
-  "main": "/src/index.jsx",
-  "name": "npm-pkg-hook",
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org/"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Jesus123780/pkg-hook"
-  },
-  "private": false,
   "scripts": {
+    "build": "tsup",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build",
     "lint": "eslint .",
-    "lint:fix": "npm run lint -- --fix",
-    "rm": "rm -rf node_modules package-lock.json && npm i",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest"
+  },
+  "peerDependencies": {
+    "react": "^18 || ^19",
+    "react-dom": "^18 || ^19",
+    "next": "^14 || ^15",
+    "@apollo/client": "^3 || ^4",
+    "graphql": "^16"
+  },
+  "devDependencies": {
+    "tsup": "8.5.1",
+    "typescript": "5.9.3",
+    "@types/react": "18.0.20",
+    "@types/js-cookie": "3.0.6",
+    "@types/file-saver": "2.0.7"
   },
-  "version": "1.12.4"
-}
+  "version": "1.12.8",
+  "name": "npm-pkg-hook"
+}

package/src/config/client/errors.ts

@@ -0,0 +1,39 @@
+import { onError } from '@apollo/client/link/error'
+
+interface GraphQLErrorExtension {
+  code?: string
+  message?: string
+}
+
+interface GraphQLErrorItem {
+  extensions?: GraphQLErrorExtension
+}
+
+interface ErrorWithErrors {
+  errors?: GraphQLErrorItem[]
+}
+
+export const errorHandler = (error: ErrorWithErrors | null | undefined): boolean | null => {
+  let logout: boolean | null = null
+  if (error && Array.isArray(error?.errors)) {
+    error.errors?.length && error?.errors?.forEach((err: GraphQLErrorItem) => {
+      if (err?.extensions) {
+        const { code, message }: GraphQLErrorExtension = err?.extensions || {}
+        if (code === 'UNAUTHENTICATED' || code === 'FORBIDDEN') {
+          logout = true
+          return {
+            status: 'FORBIDDEN',
+            message
+          }
+        }
+      }
+    })
+  }
+  return logout
+}
+
+export const errorLink = onError(({ graphQLErrors, networkError }) => {
+  if (graphQLErrors)graphQLErrors.map(({ message, path }) => { return console.log(`[GraphQL error]: Message: ${message}, Path: ${path}`) })
+
+  if (networkError) console.log(`[Network error]: ${networkError}`)
+})

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

@@ -3,12 +3,12 @@
  * @param {number} num - The number of minutes (between 1 and 60).
  * @returns {string} A string indicating the original number and the result of adding 10 minutes.
  */
-export const addTenMinutes = (num) => {
+export const addTenMinutes = (num: number) => {
   if (num > 60) return ''
   if (num >= 50) {
     const newNum = num - 10
     return `${newNum} - ${60} min`
-  } else {
-    return `${num} - ${num + 10} min`
-  }
+  } 
+  return `${num} - ${num + 10} min`
+  
 }

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

@@ -1,15 +1,26 @@
-function deg2rad (deg) {
+/**
+ *
+ * @param deg
+ */
+function deg2rad(deg: number): number {
   return deg * (Math.PI / 180)
 }
 
 // Función para calcular la distancia entre un punto fijo y un punto dado utilizando la fórmula de Haversine
-export function calculateLogLatHaversine (lat1, lon1, lat2, lon2) {
+/**
+ *
+ * @param lat1
+ * @param lon1
+ * @param lat2
+ * @param lon2
+ */
+export function calculateLogLatHaversine(lat1: number, lon1: number, lat2: number, lon2: number): number {
   const radioTierra = 6371 // Radio de la Tierra en kilómetros
   const dLat = deg2rad(lat2 - lat1)
   const dLon = deg2rad(lon2 - lon1)
   const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-              Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2)) *
-              Math.sin(dLon / 2) * Math.sin(dLon / 2)
+    Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2)) *
+    Math.sin(dLon / 2) * Math.sin(dLon / 2)
   const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
   const distancia = radioTierra * c
   return distancia

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

@@ -1,4 +1,4 @@
-export const completeSchedules = (dataSchedules) => {
+export const completeSchedules = (dataSchedules: { schDay: number; schHoSta: string; schHoEnd: string }[]) => {
   // Días de la semana
   const daysSemana = ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado', 'Domingo']
 
@@ -10,13 +10,13 @@ export const completeSchedules = (dataSchedules) => {
     }
     mapa[day].push({ horaInicio: horario.schHoSta, horaFin: horario.schHoEnd })
     return mapa
-  }, {})
+  }, {} as Record<string, { horaInicio: string; horaFin: string }[]>)
 
   // Completar los días que faltan y formatear el objeto
-  const horariosFormateados = daysSemana.map((day, index) => ({
+  const horariosFormateados = daysSemana.map((day, index) => {return {
     day,
     horarios: horariosPorDia[day] || [{ horaInicio: '', horaFin: '' }]
-  }))
+  }})
 
   return horariosFormateados
 }

package/src/hooks/convertToMilitaryTime/index.ts

@@ -0,0 +1,18 @@
+/**
+ *
+ * @param time12Hour
+ */
+export function convertToMilitaryTime(time12Hour: string): string {
+  const [time, period]: [string, string] = time12Hour.split(' ') as [string, string]
+  let [hours, minutes]: [string, string] = time.split(':') as [string, string]
+
+  if (period === 'PM' && hours !== '12') {
+    hours = String(Number(hours) + 12)
+  }
+
+  if (period === 'AM' && hours === '12') {
+    hours = '00'
+  }
+
+  return `${hours}:${minutes}`
+}

package/src/hooks/generateStoreURL/index.ts

@@ -0,0 +1,41 @@
+/**
+ * Generate the store URL based on given parameters.
+ * @returns The generated URL or '/' if any field is missing.
+ */
+type City = { cName: string };
+type Department = { dName: string };
+
+interface GenerateStoreURLParams {
+  city: City;
+  department: Department;
+  storeName: string;
+  idStore: string;
+  rootMainPath?: string;
+}
+
+export const generateStoreURL = ({
+  city,
+  department,
+  storeName,
+  idStore,
+  rootMainPath = 'delivery'
+}: GenerateStoreURLParams): string => {
+  // Validate all necessary fields
+  if (
+    !process.env.MAIN_URL_BASE ||
+      !city?.cName ||
+      !department?.dName ||
+      !storeName ||
+      !idStore
+  ) {
+    return '/' // Return '/' or any default case you'd prefer
+  }
+
+  const cityName = city.cName.toLocaleLowerCase()
+  const departmentName = department.dName.toLocaleLowerCase()
+
+  // Replace spaces in storeName with hyphens
+  const formattedStoreName = storeName.replace(/ /g, '-')
+
+  return `${process.env.MAIN_URL_BASE}/${rootMainPath}/${cityName}-${departmentName}/${formattedStoreName}/${idStore}`
+}

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

@@ -1,5 +1,5 @@
-import * as Excel from 'xlsx'
 import { saveAs } from 'file-saver'
+import * as Excel from 'xlsx'
 
 /**
  * Class to generate Excel reports.
@@ -11,19 +11,23 @@ export class GenerateReport {
    * @param {number} type - The type of report to generate.
    * @throws Will throw an error if data is not an array or type is not a valid number.
    */
-  GenExcelReport (data, type) {
+  GenExcelReport(data: object[], type: number): void {
     if (!Array.isArray(data)) {
-      throw new Error('Data must be an array of objects.')
+      throw new TypeError('Data must be an array of objects.')
     }
 
     if (typeof type !== 'number') {
-      throw new Error('Type must be a valid number.')
+      throw new TypeError('Type must be a valid number.')
     }
 
     const ws = Excel.utils.json_to_sheet(data)
 
     // Apply bold font to the header row
-    const range = Excel.utils.decode_range(ws['!ref'])
+    const ref = ws['!ref']
+    if (!ref) {
+      throw new TypeError('Worksheet reference is undefined.')
+    }
+    const range = Excel.utils.decode_range(ref)
     for (let C = range.s.c; C <= range.e.c; ++C) {
       const cell = ws[Excel.utils.encode_cell({ r: 0, c: C })]
       if (cell) {
@@ -40,10 +44,10 @@ export class GenerateReport {
     const excelBuffer = Excel.write(wb, { bookType: 'xlsx', type: 'array' })
     const blob = new Blob([excelBuffer], { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' })
     const fileName = this.GenExcelReportFileName(type)
-    if (fileName != null) {
+    if (fileName) {
       saveAs(blob, String(fileName))
     } else {
-      throw new Error('Invalid report type provided.')
+      throw new TypeError('Invalid report type provided.')
     }
   }
 
@@ -52,11 +56,11 @@ export class GenerateReport {
    * @param {number} type - The type of report.
    * @returns {string | null} The file name for the report, or null if type is invalid.
    */
-  GenExcelReportFileName (type) {
-    const fileNames = {
-      1: `report_${new Date().toISOString().replace(/[:.]/g, '-')}.xlsx`
+  GenExcelReportFileName(type: number): string | null {
+    const fileNames: { [key: number]: string } = {
+      1: `report_${new Date().toISOString().replace(':', '-').replace('.', '-')}.xlsx`
     }
 
-    return fileNames[type] ? fileNames[type] : null
+    return fileNames[type] ?? null
   }
 }

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

@@ -1,4 +1,4 @@
-export const getCardType = (cardNum) => {
+export const getCardType = (cardNum: string) => {
   let payCardType = ''
 
   if (cardNum.startsWith('4')) {

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

@@ -1,13 +1,13 @@
 import { jaccardSimilarity } from './helpers'
 
 /**
-   * Get categories that contain products with names similar to the given product name.
-   * Uses the Jaccard similarity coefficient for string comparison.
-   * @param {Array} data - The array of categories with product information.
-   * @param {string} productName - The name of the product to search for.
-   * @param {number} similarityThreshold - The minimum similarity threshold for products (0.0 to 1.0).
-   * @returns {Array} - An array of categories containing similar products.
-   */
+ * Get categories that contain products with names similar to the given product name.
+ * Uses the Jaccard similarity coefficient for string comparison.
+ * @param {Array} data - The array of categories with product information.
+ * @param {string} productName - The name of the product to search for.
+ * @param {number} similarityThreshold - The minimum similarity threshold for products (0.0 to 1.0).
+ * @returns {Array} - An array of categories containing similar products.
+ */
 export const getCategoriesWithProduct = (
   data = [],
   productName = '',

package/src/hooks/getGlobalSession/index.ts

@@ -0,0 +1,69 @@
+import crypto from 'node:crypto'
+
+/**
+ *
+ * @param password
+ * @param salt
+ */
+function generateEncryptionKey(password: string, salt: string): string {
+  return crypto
+    .pbkdf2Sync(password, salt, 100000, 32, 'sha256')
+    .toString('hex')
+    .slice(0, 32)
+}
+
+const ENCRYPTION_KEY = generateEncryptionKey(
+  'tu-contraseña',
+  'alguna-sal-segura'
+)
+const IV_LENGTH = 12 // Para AES-GCM, el IV recomendado es 12 bytes
+
+export const encryptSession = (text: string): string | null => {
+  try {
+    const iv = crypto.randomBytes(IV_LENGTH)
+    const cipher = crypto.createCipheriv(
+      'aes-256-gcm',
+      Buffer.from(ENCRYPTION_KEY),
+      iv
+    )
+    let encrypted = cipher.update(text, 'utf8')
+    encrypted = Buffer.concat([encrypted, cipher.final()])
+    const authTag = cipher.getAuthTag()
+    // Concatenar IV, AuthTag y el texto cifrado, separados por ':'
+    return [
+      iv.toString('hex'),
+      authTag.toString('hex'),
+      encrypted.toString('hex')
+    ].join(':')
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error('Error de encriptación:', error.message)
+    }
+    return null
+  }
+}
+
+export const decryptSession = (text: string): string | null => {
+  try {
+    if (!text) return null
+    const textParts = text.split(':')
+    if (textParts.length !== 3) return null
+    const iv = Buffer.from(textParts[0], 'hex')
+    const authTag = Buffer.from(textParts[1], 'hex')
+    const encryptedText = Buffer.from(textParts[2], 'hex')
+    const decipher = crypto.createDecipheriv(
+      'aes-256-gcm',
+      Buffer.from(ENCRYPTION_KEY),
+      iv
+    )
+    decipher.setAuthTag(authTag)
+    let decrypted = decipher.update(encryptedText)
+    decrypted = Buffer.concat([decrypted, decipher.final()])
+    return decrypted.toString('utf8')
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error('Error de desencriptación:', error.message)
+    }
+    return null
+  }
+}

package/src/hooks/getSession/index.ts

@@ -0,0 +1,72 @@
+import { Cookies } from '../../cookies'
+
+/**
+ * Decodes a JWT safely without verifying signature.
+ * Use ONLY for reading payload data.
+ *
+ * @param {string} token - JWT string
+ * @returns {Record<string, any> | null}
+ */
+const decodeJwtPayload = (token: string): Record<string, any> | null => {
+  try {
+    const [, payload] = token.split('.')
+    if (!payload) return null
+
+    const decoded = Buffer.from(payload, 'base64').toString('utf-8')
+    return JSON.parse(decoded)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Gets session data from cookie "session".
+ * Designed for Next.js 15 App Router (server-side).
+ *
+ * @returns {Promise<{
+ *   isSession: boolean
+ *   token?: string
+ *   user?: Record<string, any>
+ *   deviceid?: string
+ *   error?: string
+ * }>}
+ */
+export const getSession = async () => {
+  try {
+    const token = Cookies.get('session')
+    return new Promise((resolve) => {
+      if (!token) {
+        resolve({ isSession: false })
+        return
+      } 
+      const payload = decodeJwtPayload(token)
+      if (!payload) {
+        resolve({ isSession: false })
+        return
+      }
+      const { user, deviceid, exp } = payload
+      const currentTime = Math.floor(Date.now() / 1000)
+      if (exp && currentTime >= exp) {
+        resolve({ isSession: false })
+        return
+      }
+      resolve({
+        isSession: true,
+        token,
+        user,
+        deviceid
+      })
+    })
+  } catch (error) {
+    if (error instanceof Error) {
+      return {
+        isSession: false,
+        error: String(error.message)
+      }
+    }
+    return {
+      isSession: false,
+      error: 'Unexpected session error'
+    }
+  }
+}