npm-pkg-hook 1.12.4 → 1.12.8

package/src/utils/generateCode.ts

@@ -0,0 +1,222 @@
+// ticket-generator.ts
+/**
+ * Ticket generator for POS systems.
+ * - Provides numeric and alphanumeric strategies.
+ * - Supports prefix, timestamp embedding, synchronous generation and async uniqueness check.
+ *
+ * JSDoc comments are in English as requested.
+ */
+
+type Strategy = 'alphanumeric' | 'numeric';
+
+export interface TicketConfig {
+    /** Total length of the generated code excluding prefix. Minimum 4. */
+    length?: number;
+    /** Strategy: 'alphanumeric' | 'numeric' */
+    strategy?: Strategy;
+    /** Optional human-readable prefix (e.g. 'TKT-', 'POS1-') */
+    prefix?: string;
+    /** If true, embed a short timestamp chunk (base36) at start of payload */
+    timestamp?: boolean;
+    /** Maximum attempts for uniqueness check when using generateUniqueAsync */
+    maxAttempts?: number;
+    /** Padding char for numeric sequences (only used if `useSequential` provided) */
+    padChar?: string;
+}
+
+/**
+ * Result returned by generators.
+ */
+export type TicketResult =
+    | { success: true; code: string; error?: undefined }
+    | { success: false; error: string; code?: string };
+
+/**
+ * Async uniqueness checker signature.
+ * Implement with DB query that returns true if code is unique (not found).
+ */
+export type IsUniqueFn = (code: string) => Promise<boolean>;
+
+/* -------------------- Implementation -------------------- */
+
+/**
+ * Secure random integer in [0, max)
+ * @param max
+ * @returns random integer in [0, max)
+ */
+const secureRandomInt = (max: number): number => {
+  if (typeof crypto !== 'undefined' && typeof (crypto as any).getRandomValues === 'function') {
+    // browser
+    const arr = new Uint32Array(1);
+    (crypto as any).getRandomValues(arr)
+    return arr[0] % max
+  }
+  try {
+    // node
+     
+    const nodeCrypto = require('crypto')
+    const buf = nodeCrypto.randomBytes(4)
+    const val = buf.readUInt32BE(0)
+    return val % max
+  } catch {
+    // fallback (less secure)
+    return Math.floor(Math.random() * max)
+  }
+}
+
+/**
+ * Build a random string from charset.
+ * @param length
+ * @param charset
+ */
+const randomFromCharset = (length: number, charset: string): string => {
+  const out: string[] = []
+  const m = charset.length
+  for (let i = 0; i < length; i += 1) {
+    out.push(charset[secureRandomInt(m)])
+  }
+  return out.join('')
+}
+
+/**
+ * Short fixed-size timestamp chunk that respects strategy.
+ * - For 'numeric' returns decimal digits (zero-padded).
+ * - For 'alphanumeric' returns base36 chars.
+ *
+ * @param strategy generation strategy
+ * @param size chunk length (default 4)
+ * @returns timestamp chunk string of length `size`
+ */
+const timestampChunk = (strategy: Strategy, size = 4): string => {
+  const now = Date.now()
+  if (strategy === 'numeric') {
+    const mod = Math.pow(10, size)
+    const n = (now % mod).toString().padStart(size, '0')
+    return n
+  }
+  // alphanumeric: compact base36 slice (keeps letters & digits)
+  return now.toString(36).slice(-size).padStart(size, '0')
+}
+
+/**
+ * Validate config and return normalized defaults or error string.
+ * @param cfg
+ */
+const normalizeConfig = (cfg?: TicketConfig): { cfg?: Required<TicketConfig>; error?: string } => {
+  const defaultCfg: Required<TicketConfig> = {
+    length: 10,
+    strategy: 'alphanumeric',
+    prefix: '',
+    timestamp: false,
+    maxAttempts: 5,
+    padChar: '0'
+  }
+
+  if (!cfg) return { cfg: defaultCfg }
+
+  const merged = { ...defaultCfg, ...cfg }
+
+  if (!Number.isInteger(merged.length) || merged.length < 4) {
+    return { error: 'length must be an integer >= 4' }
+  }
+
+  if (!['alphanumeric', 'numeric'].includes(merged.strategy)) {
+    return { error: "strategy must be 'alphanumeric' or 'numeric'" }
+  }
+
+  if (typeof merged.prefix !== 'string' || /[^A-Za-z0-9-_]/.test(merged.prefix)) {
+    return { error: 'prefix must be alphanumeric, dash or underscore only' }
+  }
+
+  if (typeof merged.maxAttempts !== 'number' || merged.maxAttempts < 1) {
+    merged.maxAttempts = defaultCfg.maxAttempts
+  }
+
+  if (typeof merged.padChar !== 'string' || merged.padChar.length !== 1) {
+    merged.padChar = defaultCfg.padChar
+  }
+
+  return { cfg: merged }
+}
+
+/**
+ * Generate a ticket code (synchronous, no uniqueness guarantee).
+ * Use generateUniqueAsync if you need persistence-level uniqueness.
+ *
+ * @param config Ticket generation options
+ * @returns TicketResult with code or error
+ */
+export const generateTicket = (config?: TicketConfig): TicketResult => {
+  const normalized = normalizeConfig(config)
+  if (normalized.error) return { success: false, error: normalized.error }
+  const cfg = normalized.cfg!
+
+  const payloadLen = cfg.length
+  const prefix = cfg.prefix || ''
+
+  // decide charset
+  const numericCharset = '0123456789'
+  const alphaNumCharset = 'ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz0123456789' // removed O/0/l for readability
+  const charset = cfg.strategy === 'numeric' ? numericCharset : alphaNumCharset
+
+  // prepare timestamp chunk if requested (keep it short and strategy-aware)
+  const ts = cfg.timestamp ? timestampChunk(cfg.strategy, 4) : ''
+
+
+  // calc remaining length for random part
+  const remaining = payloadLen - ts.length
+  if (remaining < 1) return { success: false, error: 'length too small for timestamp embedding' }
+
+  const randomPart = randomFromCharset(remaining, charset)
+
+  const code = `${prefix}${ts}${randomPart}`
+  return { success: true, code }
+}
+
+/**
+ * Generate a ticket code with uniqueness guarantee using an async uniqueness checker.
+ * Tries up to config.maxAttempts times.
+ *
+ * @param isUnique Async function that returns true if code is unique (not present)
+ * @param config Ticket generation options
+ * @returns TicketResult with unique code or error
+ */
+export const generateUniqueAsync = async (isUnique: IsUniqueFn, config?: TicketConfig): Promise<TicketResult> => {
+  const normalized = normalizeConfig(config)
+  if (normalized.error) return { success: false, error: normalized.error }
+  const cfg = normalized.cfg!
+
+  for (let attempt = 1; attempt <= cfg.maxAttempts; attempt += 1) {
+    const candidateRes = generateTicket(cfg)
+    if (!candidateRes.success) return candidateRes
+
+    const candidate = candidateRes.code
+    try {
+      const unique = await isUnique(candidate)
+      if (unique) return { success: true, code: candidate }
+      // else collision -> retry
+    } catch (err) {
+      return { success: false, error: `isUnique function threw: ${(err as Error).message}` }
+    }
+  }
+
+  return { success: false, error: 'unable to generate unique ticket after max attempts' }
+}
+
+/* -------------------- Example usage -------------------- */
+
+/*
+Example (sync):
+const res = generateTicket({ length: 8, strategy: 'numeric', prefix: 'T-', timestamp: true });
+if (!res.success) console.error(res.error);
+else console.log('Ticket:', res.code);
+
+Example (async uniqueness check, e.g. DB):
+const isUniqueInDb = async (code: string) => {
+  // query DB to see if code exists; return true if NOT exist
+  return !(await db.exists({ ticketCode: code }));
+};
+const unique = await generateUniqueAsync(isUniqueInDb, { length: 10, strategy: 'alphanumeric', prefix: 'POS1-', timestamp: true });
+if (unique.success) console.log('Unique ticket:', unique.code);
+else console.error('Error generating unique:', unique.error);
+*/

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './UtilDateRange'
+export * from './utils'

package/src/utils/{index.js → utils.ts}

@@ -1,4 +1,4 @@
-import { randomBytes } from 'crypto'
+import { randomBytes } from 'node:crypto'
 
 /**
  * @description It takes an array of elements and returns an object with a submit hook for each element.
@@ -6,7 +6,7 @@ import { randomBytes } from 'crypto'
  * @param {array} elements elementos del formulario
  * @return {array} devuelve un array de booleanos con el nombre identificador para cada estado en react.
  */
-const validTypes = {
+const validTypes: Record<string, boolean> = {
   text: true,
   password: true,
   email: true,
@@ -29,17 +29,17 @@ export const statusProduct = {
   active: 1
 }
 
-export const validationSubmitHooks = elements => {
+export const validationSubmitHooks = (elements: Array<HTMLElement & { name?: string; type?: string; value?: any; dataset?: DOMStringMap }>) => {
   if (!elements || elements.length === 0) {
     return {}
   }
-  let errorForm = {}
+  let errorForm: Record<string, boolean> = {}
 
   for (const element of elements) {
     if (element.name) {
-      const elementType = element.type || element.tagName.toLowerCase()
+      const elementType = (element.type as string) || element.tagName.toLowerCase()
       if (validTypes[elementType]) {
-        if (element.dataset.required === 'true') {
+        if (element.dataset && element.dataset.required === 'true') {
           if (!element.value) {
             errorForm = { ...errorForm, [element.name]: true }
           } else {
@@ -55,10 +55,16 @@ export const validationSubmitHooks = elements => {
   return errorForm
 }
 
-export const getCurrentDomain = () => {
+export const getCurrentDomain = (): string | boolean => {
   return typeof window !== 'undefined' && window.location.hostname
 }
 
+
+interface RandomCodeOptions {
+  prefix?: string;
+  suffix?: string;
+}
+
 /**
  * Generates a cryptographically secure random string of given length.
  * @param length - Desired length of the generated code.
@@ -66,9 +72,9 @@ export const getCurrentDomain = () => {
  * @returns Random alphanumeric string with optional prefix and suffix.
  */
 export const RandomCode = (
-  length,
-  options
-) => {
+  length: number,
+  options: RandomCodeOptions = {}
+): string => {
   if (length <= 0) {
     throw new Error('Length must be greater than 0')
   }
@@ -93,10 +99,19 @@ export const RandomCode = (
  * @param {{ cache: object, query: object, nameFun: string, dataNew: object, type: number, id: string }} params Parámetros para actualizar el cachet de apollo
  * @returns {null} no hay retorno
  */
-export const updateCacheMod = async ({ cache, query, nameFun, dataNew, type, id }) => {
+export interface UpdateCacheModParams {
+  cache: any;
+  query: any;
+  nameFun: string;
+  dataNew?: any;
+  type: number;
+  id?: string;
+}
+
+export const updateCacheMod = async ({ cache, query, nameFun, dataNew, type, id }: UpdateCacheModParams): Promise<any> => {
   return cache.modify({
     fields: {
-      [nameFun] (dataOld = []) {
+      [nameFun](dataOld = []) {
         if (type === 1) return cache.writeQuery({ query, data: [...(dataOld || []), { ...(dataNew || {}) }] })
         if (type === 2) return cache.writeQuery({ query, data: { ...(dataOld || {}), ...(dataNew || {}) } })
         if (type === 3) return cache.writeQuery({ query, data: dataOld.filter(x => { return x === id }) })
@@ -111,7 +126,7 @@ export const updateCacheMod = async ({ cache, query, nameFun, dataNew, type, id
  * @param {string|number} value - El valor a formatear.
  * @returns {string} El valor formateado como número o el valor original si no es numérico.
  */
-export const numberFormat = value => {
+export const numberFormat = (value: string | number) => {
   // Verifica si el valor es nulo o indefinido, devolviendo el mismo valor.
   if (value === null || value === undefined) {
     return value
@@ -140,7 +155,7 @@ export const numberFormat = value => {
  * @param {boolean} dataFilter booleano para devolver los datos filtrados o no
  * @return {Object} devuelve un objeto con los datos filtrados
  */
-export const filterKeyObject = (data, filters, dataFilter) => {
+export const filterKeyObject = (data: Record<string, any>, filters: string[], dataFilter: boolean) => {
   let values = {}; let valuesFilter = {}
   for (const elem in data) {
     let coincidence = false
@@ -155,7 +170,8 @@ export const filterKeyObject = (data, filters, dataFilter) => {
   if (!dataFilter) return values
   if (dataFilter) return { values, valuesFilter }
 }
-export const MONTHS = [
+
+export const MONTHS: readonly string[] = [
   'January',
   'February',
   'March',
@@ -168,8 +184,9 @@ export const MONTHS = [
   'October',
   'November',
   'December'
-]
-export const SPANISH_MONTHS = {
+] as const
+
+export const SPANISH_MONTHS: Readonly<Record<number, string>> = {
   0: 'Enero',
   1: 'Febrero',
   2: 'Marzo',
@@ -182,9 +199,9 @@ export const SPANISH_MONTHS = {
   9: 'Octubre',
   10: 'Noviembre ',
   11: 'Diciembre'
-}
+} as const
 
-export const days = {
+export const days: Readonly<Record<number, string>> = {
   1: 'Lunes',
   2: 'Martes',
   3: 'Miércoles',
@@ -192,9 +209,9 @@ export const days = {
   5: 'Viernes',
   6: 'Sábado',
   0: 'Domingo'
-}
+} as const
 
-export const convertBase64 = file => {
+export const convertBase64 = (file: File): Promise<string | ArrayBuffer | null> => {
   return new Promise((resolve, reject) => {
     const reader = new FileReader()
     if (file) {
@@ -209,7 +226,7 @@ export const convertBase64 = file => {
   })
 }
 
-export const validationImg = file => { return (/\.(jpg|png|gif|jpeg)$/i).test(file.name) }
+export const validationImg = (file: File): boolean => { return (/\.(jpg|png|gif|jpeg)$/i).test(file.name) }
 
 export const SERVICES = Object.freeze({
   WEB_SOCKET_CHAT: 'web-socket-chat',
@@ -231,9 +248,26 @@ export const paymentMethodCards = [
 
 export const CATEGORY_EMPTY = 'NINGUNO'
 
-export * from './UtilDateRange'
 
-const cleanValue = ({ value, decimalSeparator, groupSeparator, allowDecimals, decimalsLimit, allowNegativeValue, disableAbbreviations }) => {
+interface CleanValueOptions {
+  value: string;
+  decimalSeparator?: string;
+  groupSeparator?: string;
+  allowDecimals?: boolean;
+  decimalsLimit?: number;
+  allowNegativeValue?: boolean;
+  disableAbbreviations?: boolean;
+}
+
+const cleanValue = ({
+  value,
+  decimalSeparator,
+  groupSeparator,
+  allowDecimals,
+  decimalsLimit,
+  allowNegativeValue,
+  disableAbbreviations
+}: CleanValueOptions): string | null => {
   if (typeof value !== 'string') return null
 
   // Remove currency symbols and whitespace
@@ -242,8 +276,9 @@ const cleanValue = ({ value, decimalSeparator, groupSeparator, allowDecimals, de
   // 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()]}` : ''
+      const multipliers: Record<string, number> = { k: 1e3, m: 1e6, b: 1e9 }
+      const key = match.toLowerCase()
+      return multipliers[key] ? `*${multipliers[key]}` : ''
     })
   }
 
@@ -261,7 +296,7 @@ const cleanValue = ({ value, decimalSeparator, groupSeparator, allowDecimals, de
   cleaned = cleaned.replace(/[^0-9.-]/g, '')
 
   // Limit decimals if specified
-  if (allowDecimals && decimalsLimit > 0) {
+  if (allowDecimals && typeof decimalsLimit === 'number' && decimalsLimit > 0) {
     const parts = cleaned.split('.')
     if (parts.length > 1) {
       parts[1] = parts[1].slice(0, decimalsLimit)
@@ -284,7 +319,7 @@ const cleanValue = ({ value, decimalSeparator, groupSeparator, allowDecimals, de
  * @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) {
+export function parseFormattedFloat(value: string): number {
   if (!value) return 0
   const options = {
     decimalSeparator: ',',
@@ -296,11 +331,14 @@ export function parseFormattedFloat (value) {
   }
   const cleaned = cleanValue({ value, ...options })
 
+  // If cleaned is null/undefined/empty, return 0 to avoid calling replace on null
+  if (cleaned === null || cleaned === undefined || cleaned === '') return 0
+
   const normalized = (typeof options.decimalSeparator === 'string' && options.decimalSeparator !== '')
-  // Replace the decimal separator with a dot for parsing
+    // Replace the decimal separator with a dot for parsing
     ? cleaned.replace(options.decimalSeparator, '.')
     : cleaned
 
-  const num = parseFloat(normalized)
-  return isNaN(num) ? 0 : num
+  const num = Number.parseFloat(normalized)
+  return Number.isNaN(num) ? 0 : num
 }

package/tsconfig.eslint.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.tsx",
+    "packages/**/*.ts",
+    "packages/**/*.tsx"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "build",
+    "**/*.config.*",
+    "eslint.config.*"
+  ]
+}

package/tsconfig.json

@@ -1,5 +1,21 @@
 {
   "compilerOptions": {
-    "lib": ["ES2021", "DOM", "Intl"]
-  }
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": ["ES2022", "DOM"],
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": false,
+    "outDir": "dist",
+    "strict": true,
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "jsx": "react-jsx",
+    "sourceMap": true,
+    "composite": false
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "example"]
 }

package/tsup.config.ts

@@ -0,0 +1,24 @@
+// tsup.config.ts
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+    entry: ["src/index.ts"],
+    format: ["cjs", "esm"],
+    dts: false,
+    outDir: "dist",
+    clean: true,
+    sourcemap: true,
+    target: "es2022",
+    external: [
+        "react",
+        "react-dom",
+        "next",
+        "@apollo/client",
+        "graphql",
+        "js-cookie"
+    ],
+    esbuildOptions: (ctx) => {
+        // Si necesitas tweaks extra a esbuild, los pones aquí
+        return ctx;
+    }
+});

package/.eslintrc.js

@@ -1,38 +0,0 @@
-module.exports = {
-  settings: {
-    react: {
-      version: 'detect'
-    }
-  },
-  env: {
-    browser: true,
-    es2021: true,
-    node: true
-  },
-  extends: [
-    'standard',
-    'plugin:react/recommended'
-  ],
-  overrides: [
-    {
-      env: {
-        node: true
-      },
-      files: [
-        '.eslintrc.{js,cjs}'
-      ],
-      parserOptions: {
-        sourceType: 'script'
-      }
-    }
-  ],
-  parserOptions: {
-    ecmaVersion: 'latest',
-    sourceType: 'module'
-  },
-  plugins: [
-    'react'
-  ],
-  rules: {
-  }
-}

package/.eslintrc.json

@@ -1,127 +0,0 @@
-{
-  "settings": {
-    "react": {
-      "version": "detect"
-    }
-  },
-    "env": {
-        "browser": true,
-        "es2021": true,
-        "node": true
-    },
-    "extends": "eslint:recommended",
-    "parserOptions": {
-        "ecmaVersion": "latest",
-        "sourceType": "module"
-    },
-    "rules": {
-        "import/no-anonymous-default-export": ["error", {
-          "allowArray": false,
-          "allowArrowFunction": false,
-          "allowAnonymousClass": false,
-          "allowAnonymousFunction": false,
-          "allowCallExpression": true, // The true value here is for backward compatibility
-          "allowLiteral": false,
-          "allowObject": true // anonymous-default-export
-        }],
-        // react hooks validations
-        "react-hooks/exhaustive-deps": "warn",
-        "react-hooks/rules-of-hooks": "error",
-        // allow jsx syntax in js files (for next.js project)
-        "react/jsx-filename-extension": [
-          1,
-          {
-            "extensions": [
-              ".js",
-              ".jsx",
-              ".ts",
-              ".tsx"
-            ]
-          }
-        ],
-        "quotes": [
-          2,
-          "single",
-          {
-            "avoidEscape": true,
-            "allowTemplateLiterals": true
-          }
-        ],
-        "consistent-return": 2,
-        "indent": [
-          2,
-          2,
-          {
-            "SwitchCase": 1
-          }
-        ],
-        "no-else-return": 1,
-        "semi": [
-          1,
-          "never"
-        ],
-        "space-unary-ops": 2,
-        "comma-dangle": [
-          "error",
-          {
-            "arrays": "never",
-            "objects": "never",
-            "imports": "never",
-            "exports": "never",
-            "functions": "never"
-          }
-        ],
-        "one-var": [
-          2,
-          "never"
-        ],
-        "no-var": "error",
-        "arrow-body-style": [
-          "error",
-          "always"
-        ],
-        "no-console": "error",
-        "no-multi-spaces": [
-          "error",
-          {
-            "exceptions": {
-              "BinaryExpression": true
-            }
-          }
-        ],
-        "no-multiple-empty-lines": [
-          "error",
-          {
-            "max": 2,
-            "maxBOF": 2
-          }
-        ],
-        "jsx-quotes": [
-          "error",
-          "prefer-single"
-        ],
-        "react/jsx-sort-props": [
-          "error",
-          {
-            "noSortAlphabetically": false
-          }
-        ],
-        "react/jsx-first-prop-new-line": [
-          "error",
-          "multiline"
-        ],
-        "react/jsx-max-props-per-line": [
-          "error",
-          {
-            "maximum": {
-              "single": 2,
-              "multi": 1
-            }
-          }
-        ],
-        "react/jsx-closing-bracket-location": [
-          "error",
-          "line-aligned"
-        ]
-      }
-}