npm-pkg-hook 1.12.7 → 1.12.8

package/src/hooks/useUser/queries.ts

@@ -0,0 +1,131 @@
+import { gql } from '@apollo/client'
+
+export const LOGIN = gql`
+mutation login($input: LoginInput){
+  login(input: $input){
+    token
+  }
+}
+`
+export const GET_USER_PROFILE = gql`
+query getOneUserProfile($id: ID) {
+  getOneUserProfile(id: $id){
+      upId
+      id
+      upPhone
+      upImage
+      upDateBir
+      upBloodG
+      upAddress
+      ctId
+      dId
+      upZipCode
+      cId
+      upLatitude
+      upLongitude
+      user {
+      id
+      name
+      username
+      lastName
+      email
+      avatar
+      uToken
+      uPhoNum
+      ULocation
+      upLat
+      uState
+      upLon
+      upIdeDoc
+      siteWeb
+      description
+      password
+      createAt
+
+      }
+  }
+}
+`
+
+export const GET_USER = gql`
+query getUser($id: ID, $email: String){
+getUser(id: $id email: $email){
+id
+name
+username
+lastName
+email
+avatar
+uToken
+uPhoNum
+ULocation
+upLat
+uState
+idRole
+upLon
+upIdeDoc
+siteWeb
+description
+associateStore
+  role {
+    name
+    permissions
+    description
+    createdAt
+    updatedAt
+    
+  }
+}
+}
+`
+export const GET_ALL_USER = gql`
+query getAllUser($search: String){
+  getAllUser(search: $search){
+    id
+    name
+    username
+    lastName
+    email
+    email
+    siteWeb
+    description
+    uPhoNum
+    upLat
+    upLon
+    createAt
+    avatar
+    latestMessage {
+      uuid
+      content
+      from
+      to
+    }
+  }
+}
+`
+export const UPDATE_AVATAR = gql`
+mutation updateAvatar($file: Upload){
+  UpdateAvatar(file: $file){
+    status
+    urlAvatar
+  }
+}
+`
+
+export const SET_USER_PROFILE = gql`
+    mutation setUserProfile($data: IUserProfile!) {
+        setUserProfile(input: $data){
+            upId
+            id
+            upPhone
+            upDateBir
+            upImage
+            upBloodG
+            cId
+            ctId
+            dId
+            upAddress
+            upZipCode
+        }
+    }
+`

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

@@ -0,0 +1,32 @@
+/**
+ * Fills missing weeks for the last 7 weeks, ensuring continuous data.
+ * If a week is missing, it fills it with totalOut: 0 and percentageChange: "N/A".
+ *
+ * @param {Array} data - Array of weekly stock movement objects.
+ * @returns {Array} - Filled data ensuring the last 7 weeks are covered.
+ */
+export const fillLast7Weeks = (data) => {
+  const today = new Date()
+  const last7Weeks = []
+
+  // Generar las últimas 7 semanas (cada lunes)
+  for (let i = 6; i >= 0; i--) {
+    const weekDate = new Date(today)
+    weekDate.setDate(today.getDate() - today.getDay() - (i * 7) + 1) // Ajustar para que sea lunes
+    const weekStart = weekDate.toISOString().split('T')[0] // Formato YYYY-MM-DD
+    last7Weeks.push(weekStart)
+  }
+
+  // Mapear los datos existentes para acceso rápido
+  const dataMap = new Map(data.map(item => {return [item.weekStart, item]}))
+
+  // Construir la nueva lista asegurando que todas las semanas estén presentes
+  return last7Weeks.map(weekStart => {return (
+    dataMap.get(weekStart) || {
+      weekStart,
+      totalOut: 0,
+      prevTotalOut: null,
+      percentageChange: 'N/A'
+    }
+  )})
+}

package/src/hooks/useWeeklyStockMovement/index.ts

@@ -0,0 +1,52 @@
+import { gql, useQuery } from '@apollo/client'
+
+import { fillLast7Weeks } from './helpers' // Asegúrate de importar el helper
+
+const GET_WEEKLY_STOCK_MOVEMENT = gql`
+  query GetStockMovementPercentageChange {
+    getStockMovementWeeklyComparison {
+      weekStart
+      totalOut
+      prevTotalOut
+      percentageChange
+    }
+  }
+`
+
+/**
+ * Custom hook to fetch and format weekly stock movement data.
+ * @returns {Object} - { data, loading, error, formattedData }
+ */
+export const useWeeklyStockMovement = () => {
+  const { data, loading, error } = useQuery(GET_WEEKLY_STOCK_MOVEMENT)
+
+  // Transform data and fill missing weeks
+  const rawData = data?.getStockMovementWeeklyComparison || []
+  const formattedData = fillLast7Weeks(
+    rawData.map(item => {return {
+      ...item,
+      percentageChange: formatPercentageChange(item.percentageChange)
+    }})
+  )
+
+  return [formattedData, { loading, error }]
+}
+
+/**
+ * Ensures percentageChange is a valid string percentage, clamping between -100% and 100%.
+ *
+ * @param {string | null} percentageChange - Raw percentage change value.
+ * @returns {string} - Formatted and clamped percentage change.
+ */
+const formatPercentageChange = (percentageChange) => {
+  if (percentageChange === null) return 'N/A'
+
+  // Convertir a número
+  let parsedValue = parseFloat(percentageChange)
+
+  // Clampear entre -100% y 100%
+  if (isNaN(parsedValue)) return 'N/A'
+  parsedValue = Math.max(-100, Math.min(100, parsedValue))
+
+  return `${parsedValue.toFixed(1)}`
+}

package/src/hooks/useWindowSize/index.ts

@@ -0,0 +1,45 @@
+import { useState, useEffect } from 'react'
+
+/**
+ * A custom React hook that provides the current window size.
+ * @returns An object containing the current window width and height
+ */
+export function useWindowSize () {
+  // Initialize state with undefined width/height so server and client renders match
+  // Learn more here: https://joshwcomeau.com/react/the-perils-of-rehydration/
+  const [windowSize, setWindowSize] = useState<{ width: number | undefined; height: number | undefined }>({
+    width: undefined,
+    height: undefined
+  })
+
+  useEffect(() => {
+    // Handler to call on window resize
+    /**
+     *
+     */
+    function handleResize () {
+      // Set window width/height to state
+      setWindowSize({
+        width: window.innerWidth,
+        height: window.innerHeight
+      })
+    }
+
+    // Add event listener
+    window.addEventListener('resize', handleResize)
+
+    // Call handler right away so state gets updated with initial window size
+    handleResize()
+
+    // Remove event listener on cleanup
+    return () => {return window.removeEventListener('resize', handleResize)}
+  }, []) // Empty array ensures that effect is only run on mount
+
+  return windowSize
+}
+// Como se usa
+
+// 1 -const size = useWindowSize();
+// 2  <div>
+// {size.width}px / {size.height}px
+// </div>

package/src/index.ts

@@ -0,0 +1,13 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const packageJson = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8')) as { version: string }
+
+export * from './hooks/index'
+export * from './utils'
+export * from './utils/generateCode'
+export * from './cookies'
+export * from './security'
+
+// version
+export const version = packageJson.version

package/src/mock/dessert/index.ts

@@ -0,0 +1,16 @@
+import { RandomCode } from '../../utils'
+
+export const MockData = {
+  lists: {
+    '01list': {
+      id: RandomCode(9),
+      title: 'Elige tu salsa favorita',
+      numberLimit: 0,
+      required: 0,
+      value: '',
+      cards: [
+      ]
+    }
+  },
+  listIds: ['01list']
+}

package/src/mock/index.ts

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

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'