npm-pkg-hook 1.12.7 → 1.12.9

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/expire.json

@@ -0,0 +1 @@
+eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoiSmVzdXMgSnV2aW5hbyIsImVtYWlsIjoianV2aW5hb2plc3VzZEBnbWFpbC5jb20iLCJ1c2VybmFtZSI6Ikplc3VzIEp1dmluYW8iLCJyZXN0YXVyYW50Ijp7ImlkU3RvcmUiOiIwMTNlNTM4Ny0zNGExLTZhNzgtMzAzZC01MDk4ZjE3YmY2NDAiLCJpZCI6IjAxM2U1Mzg3LTM0YTEtNmE3OC0zMDNkLTUwOThmMTdiZjY0MCJ9LCJpZCI6IjAxM2U1Mzg3LTM0YTEtNmE3OC0zMDNkLTUwOThmMTdiZjY0MCIsImlhdCI6MTcwNjY3MTkwOCwiZXhwIjoxNzA3MDA1MjA4fQ.V---HeOaEMX9tow6Yh-33ehM6HV-h-1YQ8dmxJfVcyE

package/jsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "lib": [
+      "dom",
+      "dom.iterable"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": false,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.tsx"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/package.json

@@ -1,72 +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",
-    "next": "15.2.4",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "react-query": "^3.39.2",
-    "xlsx": "0.18.5"
-  },
-  "description": "description-pkg-hook",
-  "devDependencies": {
-    "@babel/preset-env": "^7.19.1",
-    "@babel/preset-react": "^7.18.6",
-    "@babel/preset-typescript": "^7.18.6",
-    "@types/jest": "^30.0.0",
-    "@types/js-cookie": "3.0.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",
-    "jest": "^30.2.0",
-    "ts-jest": "^29.4.6",
-    "tsup": "8.5.1",
-    "typesdefs": "1.0.6"
-  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
+      "import": "./dist/index.mjs",
       "require": "./dist/index.cjs",
       "types": "./dist/index.d.ts"
     }
   },
-  "files": [
-    "dist"
-  ],
-  "license": "ISC",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "name": "npm-pkg-hook",
-  "private": false,
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org/"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Jesus123780/pkg-hook"
-  },
   "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs",
+    "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": "jest",
-    "test:watch": "jest --watch"
+    "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"
   },
-  "type": "module",
-  "types": "./dist/index.d.ts",
-  "version": "1.12.7"
+  "version": "1.12.9",
+  "name": "npm-pkg-hook"
 }

package/script.txt

@@ -0,0 +1,7 @@
+// (function (params) {
+//     var ct =  document.createElement('link');
+//     ct.rel = 'stylesheet';
+//     ct.href = 'https://csswizardry.com/ct/ct.css';
+//     ct.classList.add('ct');
+//     document.head.appendChild(ct)
+// }());

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/config/client/index.ts

@@ -0,0 +1 @@
+export * from './errors'

package/src/config/content/en.json

@@ -0,0 +1,5 @@
+{
+    "SESSION_EXPIRED": "Token expired",
+    "BANNER_UPDATED": "Banner updated",
+    "BANNER_UPDATE_FAILED": "Banner update failed"
+}

package/src/config/content/es.json

@@ -0,0 +1,5 @@
+{
+    "SESSION_EXPIRED": "Token expired",
+    "BANNER_UPDATED": "Banner actualizado",
+    "BANNER_UPDATE_FAILED": "No se pudo actualizar el banner"
+}

package/src/config/content/index.ts

@@ -0,0 +1,16 @@
+// src/config/content/index.js
+
+import contentEn from './en.json'
+import contentEs from './es.json'
+
+const LANG = 'es'
+
+const CONTENT = {
+  en: contentEn,
+  es: contentEs
+}
+
+export const t = (key) => {
+  const content = CONTENT[LANG] || {}
+  return content[key] || key
+}

package/src/cookies/index.ts

@@ -0,0 +1,3 @@
+import Cookies from 'js-cookie'
+
+export { Cookies }

package/src/hooks/addTenMinutes/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Function that adds 10 to a given number representing minutes.
+ * @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: number) => {
+  if (num > 60) return ''
+  if (num >= 50) {
+    const newNum = num - 10
+    return `${newNum} - ${60} min`
+  } 
+  return `${num} - ${num + 10} min`
+  
+}

package/src/hooks/calculateLogLatHaversine/index.ts

@@ -0,0 +1,41 @@
+/**
+ *
+ * @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
+/**
+ *
+ * @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)
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
+  const distancia = radioTierra * c
+  return distancia
+}
+// 768px
+// Coordenadas del punto fijo
+const puntoFijo = { lat: 4.7984084, lon: -75.7338831 }
+
+// Array de coordenadas de ejemplo
+const coordenadas = [
+  { lat: 4.7954221, lon: -75.730596 }
+]
+
+// Calcular distancias entre cada punto y el punto fijo
+coordenadas.forEach((coordenada, index) => {
+  const distancia = calculateLogLatHaversine(puntoFijo.lat, puntoFijo.lon, coordenada.lat, coordenada.lon)
+  console.log(`La distancia entre el punto fijo y coordenada ${index + 1} es ${distancia.toFixed(2)} kilómetros`)
+})

package/src/hooks/completeSchedules/index.ts

@@ -0,0 +1,22 @@
+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']
+
+  // Mapear los horarios existentes para crear un mapa por día
+  const horariosPorDia = dataSchedules.reduce((mapa, horario) => {
+    const day = daysSemana[horario.schDay]
+    if (!mapa[day]) {
+      mapa[day] = []
+    }
+    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) => {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.ts

@@ -0,0 +1,66 @@
+import { saveAs } from 'file-saver'
+import * as Excel from 'xlsx'
+
+/**
+ * Class to generate Excel reports.
+ */
+export class GenerateReport {
+  /**
+   * Generates an Excel report from given data and type.
+   * @param {Array<object>} data - The data to be included in the Excel report.
+   * @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: object[], type: number): void {
+    if (!Array.isArray(data)) {
+      throw new TypeError('Data must be an array of objects.')
+    }
+
+    if (typeof type !== '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 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) {
+        cell.s = {
+          font: {
+            bold: true
+          }
+        }
+      }
+    }
+
+    const wb = Excel.utils.book_new()
+    Excel.utils.book_append_sheet(wb, ws, 'Hoja1')
+    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) {
+      saveAs(blob, String(fileName))
+    } else {
+      throw new TypeError('Invalid report type provided.')
+    }
+  }
+
+  /**
+   * Generates the file name for the Excel report based on the type.
+   * @param {number} type - The type of report.
+   * @returns {string | null} The file name for the report, or null if type is invalid.
+   */
+  GenExcelReportFileName(type: number): string | null {
+    const fileNames: { [key: number]: string } = {
+      1: `report_${new Date().toISOString().replace(':', '-').replace('.', '-')}.xlsx`
+    }
+
+    return fileNames[type] ?? null
+  }
+}

package/src/hooks/getCardType/index.ts

@@ -0,0 +1,24 @@
+export const getCardType = (cardNum: string) => {
+  let payCardType = ''
+
+  if (cardNum.startsWith('4')) {
+    payCardType = 'VISA'
+  } else if (cardNum.startsWith('5')) {
+    payCardType = 'MASTERCARD'
+  } else {
+    const regexMap = [
+      { regEx: /^4[0-9]{5}/gi, cardType: 'VISA' },
+      { regEx: /^5[1-5][0-9]{4}/gi, cardType: 'MASTERCARD' },
+      { regEx: /^(5[06-8]\d{4}|6\d{5})/gi, cardType: 'MAESTRO' }
+    ]
+
+    for (const { regEx, cardType } of regexMap) {
+      if (cardNum.match(regEx)) {
+        payCardType = cardType
+        break
+      }
+    }
+  }
+
+  return payCardType
+}

package/src/hooks/getCategoriesWithProduct/helpers/index.ts

@@ -0,0 +1,7 @@
+export const jaccardSimilarity = (s1, s2) => {
+  const set1 = new Set(s1)
+  const set2 = new Set(s2)
+  const intersection = new Set([...set1].filter(x => { return set2.has(x) }))
+  const union = new Set([...set1, ...set2])
+  return intersection.size / union.size
+}

package/src/hooks/getCategoriesWithProduct/index.ts

@@ -0,0 +1,62 @@
+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.
+ */
+export const getCategoriesWithProduct = (
+  data = [],
+  productName = '',
+  similarityThreshold = 0.0) => {
+  // Validate input data
+  if (!data || !Array.isArray(data)) {
+    return data || []
+  }
+
+  if (typeof productName !== 'string' || productName.trim() === '') {
+    return data
+  }
+
+  // Convert product name to lowercase for case-insensitive comparison
+  const productNameLower = productName.toLowerCase()
+
+  // Use a Set to store unique product names for better performance
+  const uniqueProductNames = new Set()
+
+  // Store unique product names in the Set
+  data.forEach(category => {
+    if (category?.productFoodsAll && Array.isArray(category.productFoodsAll)) {
+      category.productFoodsAll.forEach(product => {
+        const productLower = product.pName.toLowerCase()
+        uniqueProductNames.add(productLower)
+      })
+    }
+  })
+
+  // Filter categories that contain products with names similar to the given product name
+  const matchingCategories = data.filter(category => {
+    if (category?.productFoodsAll && Array.isArray(category.productFoodsAll)) {
+      const products = category.productFoodsAll.some(product => {
+        const productLower = product?.pName?.toLowerCase()
+        return jaccardSimilarity(productNameLower, productLower) >= similarityThreshold
+      })
+      return products
+    }
+    return false
+  })
+
+  // Find similar products in each matching category
+  const findProduct = matchingCategories?.map(categories => {
+    const similarProducts = categories.productFoodsAll.filter(product => {
+      const productLower = product?.pName?.toLowerCase()
+      return productLower.includes(productNameLower)
+    })
+    return similarProducts.length > 0 ? { ...categories, productFoodsAll: similarProducts } : null
+  }).filter(Boolean)
+
+  return findProduct
+}