npm-pkg-hook 1.3.8 → 1.4.0

package/src/security/index.ts

@@ -0,0 +1 @@
+export const future = null

package/src/services/index.ts

@@ -0,0 +1 @@
+export const serviceName = 'dummy'

package/src/utils/UtilDateRange.ts

@@ -0,0 +1,56 @@
+/**
+ * Returns an object containing the start and end of the day in local time (UTC-5 by default) for the given date.
+ * @returns {{ start: Date; end: Date }} An object with `start` and `end` Date properties.
+ */
+export class UtilDateRange {
+  private readonly date: Date
+
+  /**
+   * 
+   * @param date
+   * @returns UtilDateRange instance
+   */
+  constructor(date: Date | string | number = new Date()) {
+    this.date = new Date(date) // Asegura que sea un objeto Date
+  }
+
+  /**
+   *
+   * @param date
+   * @returns Date ajustada a la zona horaria local (UTC-5)
+   */
+  private toLocalTime(date: Date | string | number): Date {
+    const offset = -5 // UTC-5 (ajustar si es necesario)
+    const localDate = new Date(date)
+    localDate.setHours(localDate.getHours() + offset)
+    return localDate
+  }
+
+  /**
+   * @returns Date al inicio del día (00:00:00.000) en hora local
+   */
+  getStartOfDay(): Date {
+    const localDate = this.toLocalTime(this.date)
+    localDate.setHours(0, 0, 0, 0)
+    return localDate
+  }
+
+  /**
+   * @returns Date al final del día (23:59:59.999) en hora local
+   */
+  getEndOfDay(): Date {
+    const localDate = this.toLocalTime(this.date)
+    localDate.setHours(23, 59, 59, 999)
+    return localDate
+  }
+
+  /**
+   * @returns {{ start: Date; end: Date }} Objeto con las fechas de inicio y fin del día en hora local
+   */
+  getRange(): { start: Date; end: Date } {
+    return {
+      start: this.getStartOfDay(),
+      end: this.getEndOfDay()
+    }
+  }
+}

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/utils.ts

@@ -0,0 +1,344 @@
+import { randomBytes } from 'node:crypto'
+
+/**
+ * @description It takes an array of elements and returns an object with a submit hook for each element.
+ * @version 0.1.1
+ * @param {array} elements elementos del formulario
+ * @return {array} devuelve un array de booleanos con el nombre identificador para cada estado en react.
+ */
+const validTypes: Record<string, boolean> = {
+  text: true,
+  password: true,
+  email: true,
+  number: true,
+  hidden: true,
+  textarea: true
+}
+
+export const statusOrder = {
+  0: '',
+  1: 'ENTRANTE',
+  2: 'PROCESO',
+  3: 'LISTOS',
+  4: 'CONCLUIDOS',
+  5: 'REJECTED'
+}
+
+export const statusProduct = {
+  deleted: 0,
+  active: 1
+}
+
+export const validationSubmitHooks = (elements: Array<HTMLElement & { name?: string; type?: string; value?: any; dataset?: DOMStringMap }>) => {
+  if (!elements || elements.length === 0) {
+    return {}
+  }
+  let errorForm: Record<string, boolean> = {}
+
+  for (const element of elements) {
+    if (element.name) {
+      const elementType = (element.type as string) || element.tagName.toLowerCase()
+      if (validTypes[elementType]) {
+        if (element.dataset && element.dataset.required === 'true') {
+          if (!element.value) {
+            errorForm = { ...errorForm, [element.name]: true }
+          } else {
+            errorForm = { ...errorForm, [element.name]: false }
+          }
+        } else {
+          errorForm = { ...errorForm, [element.name]: false }
+        }
+      }
+    }
+  }
+
+  return errorForm
+}
+
+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.
+ * @param options - Optional prefix/suffix configuration.
+ * @returns Random alphanumeric string with optional prefix and suffix.
+ */
+export const RandomCode = (
+  length: number,
+  options: RandomCodeOptions = {}
+): string => {
+  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++) {
+    const index = randomBuffer[i] % charactersLength
+    code += characters.charAt(index)
+  }
+
+  return `${options?.prefix ?? ''}${code}${options?.suffix ?? ''}`
+}
+
+/**
+ * actualizar cache de apollo
+ * @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 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 = []) {
+        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 }) })
+      }
+    }
+  })
+}
+/**
+ * Formatea un valor como un número siguiendo el formato de Colombia.
+ * Si el valor no es un número válido, lo devuelve tal como está.
+ *
+ * @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: string | number) => {
+  // Verifica si el valor es nulo o indefinido, devolviendo el mismo valor.
+  if (value === null || value === undefined) {
+    return value
+  }
+
+  // Convierte el valor a string y elimina puntos.
+  const stringValue = `${value}`.replace(/\./g, '')
+
+  // Intenta convertir a número y formatear si es posible.
+  const numberValue = parseFloat(stringValue)
+  if (!isNaN(numberValue)) {
+    return new Intl.NumberFormat('es-CO', {
+      minimumFractionDigits: 2,
+      style: 'decimal',
+      maximumFractionDigits: 2
+    }).format(numberValue)
+  }
+
+  // Devuelve el valor original si no es un número.
+  return value
+}
+/**
+ *
+ * @param {Object} data objeto a filtrar
+ * @param {Array} filters array a comparar o claves del objeto a excluir
+ * @param {boolean} dataFilter booleano para devolver los datos filtrados o no
+ * @returns {Object} devuelve el objeto filtrado segun los parametros
+ */
+export const filterKeyObject = (data: Record<string, unknown>, filters: string[], dataFilter: boolean) => {
+  let values = {}; let valuesFilter = {}
+  for (const elem in data) {
+    let coincidence = false
+    for (let i = 0; i < filters.length; i++) {
+      if (elem === filters[i]) coincidence = true
+      else valuesFilter = filters[i]
+    }
+
+    if (!coincidence) values = { ...values, [elem]: data[elem] }
+    else valuesFilter = { ...valuesFilter, [elem]: data[elem] }
+  }
+  if (!dataFilter) return values
+  if (dataFilter) return { values, valuesFilter }
+}
+
+export const MONTHS: readonly string[] = [
+  'January',
+  'February',
+  'March',
+  'April',
+  'May',
+  'June',
+  'July',
+  'August',
+  'September',
+  'October',
+  'November',
+  'December'
+] as const
+
+export const SPANISH_MONTHS: Readonly<Record<number, string>> = {
+  0: 'Enero',
+  1: 'Febrero',
+  2: 'Marzo',
+  3: 'Abril',
+  4: 'Mayo',
+  5: 'Junio',
+  6: 'Julio',
+  7: 'Augosto',
+  8: 'Septiembre',
+  9: 'Octubre',
+  10: 'Noviembre ',
+  11: 'Diciembre'
+} as const
+
+export const days: Readonly<Record<number, string>> = {
+  1: 'Lunes',
+  2: 'Martes',
+  3: 'Miércoles',
+  4: 'Jueves',
+  5: 'Viernes',
+  6: 'Sábado',
+  0: 'Domingo'
+} as const
+
+export const convertBase64 = (file: File): Promise<string | ArrayBuffer | null> => {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader()
+    if (file) {
+      reader.readAsDataURL(file)
+    }
+    reader.onload = () => {
+      resolve(reader.result)
+    }
+    reader.onerror = error => {
+      reject(error)
+    }
+  })
+}
+
+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',
+  ADMIN_SERVER: 'admin-server',
+  ADMIN_STORE: 'admin-store',
+  MAIN: 'main'
+})
+
+export const paymentMethodCards = [
+  {
+    name: 'Visa',
+    icon: 'IconVisa'
+  },
+  {
+    name: 'MasterCard',
+    icon: 'IconMasterCard'
+  }
+]
+
+export const CATEGORY_EMPTY = 'NINGUNO'
+
+
+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
+  let cleaned = value.replace(/[$€£¥]/g, '').trim()
+
+  // Handle abbreviations like K, M, B
+  if (!disableAbbreviations) {
+    cleaned = cleaned.replace(/([kmb])\b/i, (match) => {
+      const multipliers: Record<string, number> = { k: 1e3, m: 1e6, b: 1e9 }
+      const key = match.toLowerCase()
+      return multipliers[key] ? `*${multipliers[key]}` : ''
+    })
+  }
+
+  // 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 && typeof decimalsLimit === 'number' && 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: string): number {
+  if (!value) return 0
+  const options = {
+    decimalSeparator: ',',
+    groupSeparator: '.',
+    allowDecimals: true,
+    decimalsLimit: 20,
+    allowNegativeValue: true,
+    disableAbbreviations: false
+  }
+  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
+    ? cleaned.replace(options.decimalSeparator, '.')
+    : cleaned
+
+  const num = Number.parseFloat(normalized)
+  return Number.isNaN(num) ? 0 : num
+}

package/tsconfig.eslint.json

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

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "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;
+    }
+});