@revolugo/common 7.13.0 → 7.13.1-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revolugo/common",
-  "version": "7.13.0",
+  "version": "7.13.1-alpha.0",
   "private": false,
   "description": "Revolugo common",
   "author": "Revolugo",

package/src/types/elements/elements-events.ts

@@ -50,11 +50,9 @@ export enum ElementsEvent {
 export interface ElementsEventCallbacks {
   [ElementsEvent.BookingCreated]: Booking
   [ElementsEvent.BookingFlowStepUpdated]: BookingState
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  [ElementsEvent.BookingManagerNewBooking]: any
+  [ElementsEvent.BookingManagerNewBooking]: undefined
   [ElementsEvent.BookingManagerRetrieve]: Booking
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  [ElementsEvent.BookingManagerRetrieveFail]: any
+  [ElementsEvent.BookingManagerRetrieveFail]: undefined
   [ElementsEvent.BookingPolicyCreated]: BookingPolicies
   [ElementsEvent.CancellationPoliciesUpdated]: CancellationPolicy[]
   [ElementsEvent.CurrencyUpdated]: CurrencyType
@@ -67,8 +65,7 @@ export interface ElementsEventCallbacks {
   [ElementsEvent.HotelOffersItemClick]: HotelOffer | [HotelOffer, number]
   [ElementsEvent.HotelOffersMarkerClick]: HotelOffer | [HotelOffer, number]
   [ElementsEvent.HotelOffersOpenInNewTabClick]: string
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  [ElementsEvent.HotelOffersPollingStarted]: any
+  [ElementsEvent.HotelOffersPollingStarted]: undefined
   [ElementsEvent.HotelOffersRetrieved]: HotelOffer[]
   [ElementsEvent.HotelRetrieved]: Hotel
   [ElementsEvent.HotelRoomOfferItemVisible]: [HotelRoomOffer, number]

package/src/types/elements/hotel-room-offer.ts

@@ -1,5 +1,6 @@
 import type { CancellationPolicy } from './cancellation-policy.ts'
 import type { CurrencyType } from './currency.ts'
+import type { Event } from './event.ts'
 import type { HotelRoomOfferPackageType } from './hotel-room-offer-package-type.ts'
 import type { HotelRoomOfferType } from './hotel-room-offer-type.ts'
 import type { HotelRoom } from './hotel-room.ts'
@@ -219,11 +220,10 @@ export interface HotelRoomOffersResponse {
   data: HotelRoomOffersDataResponse
   /**
    *
-   * @type {any}
+   * @type {Event}
    * @memberof HotelRoomOffersApiResponse
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  event?: any | null
+  event?: Event | null
   /**
    *
    * @type {MetaApiPollingResponse}

package/src/utils/case-transformers.ts

@@ -53,34 +53,37 @@ function matches(patterns: (RegExp | string)[], value: string) {
   )
 }
 
-function isObject(o: unknown): boolean {
-  return o === Object(o) && !Array.isArray(o) && typeof o !== 'function'
+type PlainObject = Record<string, unknown>
+
+function isPlainObject(value: unknown): value is PlainObject {
+  return (
+    value === Object(value) &&
+    !Array.isArray(value) &&
+    typeof value !== 'function'
+  )
 }
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export function keysChangeCase<T = any>(
-  obj: any[],
+/** Infer `T` from input, or set `T` explicitly when output type differs (e.g. fixture → domain). */
+export function keysChangeCase<T extends object | readonly unknown[]>(
+  obj: T | object | readonly unknown[],
   toCase: CaseTransformer,
-
   options?: { deep?: boolean; exclude?: (RegExp | string)[] },
-): T[]
+): T
 
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
-export function keysChangeCase<T = any>(
+/** Unknown input — `Record<string, unknown>` / `unknown[]` instead of `unknown`. */
+export function keysChangeCase(
   obj: unknown,
   toCase: CaseTransformer,
   options?: { deep?: boolean; exclude?: (RegExp | string)[] },
-): T
+): PlainObject | unknown[]
 
-export function keysChangeCase<T>(
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  obj: any,
+export function keysChangeCase(
+  obj: unknown,
   toCase: CaseTransformer,
-
   options: { deep?: boolean; exclude?: (RegExp | string)[] } = { deep: true },
-): unknown {
-  if (isObject(obj) && !(obj instanceof Date)) {
-    return Object.keys(obj).reduce<any>((result, key) => {
+): PlainObject | unknown[] | unknown {
+  if (isPlainObject(obj) && !(obj instanceof Date)) {
+    return Object.keys(obj).reduce<PlainObject>((result, key) => {
       // Check if key should be excluded from the transformation
       const transformedKey =
         options?.exclude && matches(options.exclude, key)
@@ -94,12 +97,11 @@ export function keysChangeCase<T>(
       return result
     }, {})
   } else if (Array.isArray(obj)) {
-    return obj.map(item => keysChangeCase(item, toCase, options)) as T[]
+    return obj.map(item => keysChangeCase(item, toCase, options))
   }
 
   return obj
 }
-/* eslint-enable @typescript-eslint/no-explicit-any */
 
 export function capitalize(value: string): string {
   return value.replace(/^\w/u, c => c.toUpperCase())

package/src/utils/debounce.ts

@@ -1,18 +1,11 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 interface Options<Result> {
   isImmediate?: boolean
   maxWait?: number
   callback?: (data: Result) => void
 }
 
-export interface DebouncedFunction<
-  Args extends any[],
-  F extends (...args: Args) => any,
-> {
-  (
-    this: ThisParameterType<F>,
-    ...args: Args & Parameters<F>
-  ): Promise<Awaited<ReturnType<F>>>
+export interface DebouncedFunction<Args extends unknown[], Return> {
+  (...args: Args): Promise<Awaited<Return>>
   cancel: (reason?: unknown) => void
 }
 
@@ -21,18 +14,18 @@ interface DebouncedPromise<FunctionReturn> {
   resolve: (result: FunctionReturn) => void
 }
 
-export function debounce<Args extends any[], F extends (...args: Args) => any>(
-  func: F,
+export function debounce<Args extends unknown[], Return>(
+  func: (...args: Args) => Return,
   waitMilliseconds = 50,
-  options: Options<Awaited<ReturnType<F>>> = {},
-): DebouncedFunction<Args, F> {
+  options: Options<Awaited<Return>> = {},
+): DebouncedFunction<Args, Return> {
   let timeoutId: ReturnType<typeof setTimeout> | undefined = undefined
   const isImmediate = options.isImmediate ?? false
   const callback = options.callback ?? false
   const { maxWait } = options
   let lastInvokeTime = Date.now()
 
-  let promises: DebouncedPromise<ReturnType<F>>[] = []
+  let promises: DebouncedPromise<Awaited<Return>>[] = []
 
   function nextInvokeTimeout() {
     if (maxWait !== undefined) {
@@ -46,22 +39,19 @@ export function debounce<Args extends any[], F extends (...args: Args) => any>(
     return waitMilliseconds
   }
 
-  function debouncedFunction(
-    this: ThisParameterType<F>,
-    ...args: Parameters<F>
-  ) {
-    // eslint-disable-next-line consistent-this, @typescript-eslint/no-this-alias
-    const context = this
+  function debouncedFunction(...args: Args) {
     // eslint-disable-next-line consistent-return
-    return new Promise<Awaited<ReturnType<F>>>((resolve, reject) => {
+    return new Promise<Awaited<Return>>((resolve, reject) => {
       function invokeFunction() {
         timeoutId = undefined
         lastInvokeTime = Date.now()
         if (!isImmediate) {
-          const result = func.apply(context, args)
+          const result = func(...args)
           // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-          callback && callback(result)
-          promises.forEach(({ resolve: resolveLoop }) => resolveLoop(result))
+          callback && callback(result as Awaited<Return>)
+          promises.forEach(({ resolve: resolveLoop }) =>
+            resolveLoop(result as Awaited<Return>),
+          )
           promises = []
         }
       }
@@ -75,11 +65,11 @@ export function debounce<Args extends any[], F extends (...args: Args) => any>(
       timeoutId = setTimeout(invokeFunction, nextInvokeTimeout())
 
       if (shouldCallNow) {
-        const result = func.apply(context, args)
+        const result = func(...args)
         // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-        callback && callback(result)
+        callback && callback(result as Awaited<Return>)
         // eslint-disable-next-line no-promise-executor-return
-        return resolve(result)
+        return resolve(result as Awaited<Return>)
       }
       promises.push({ reject, resolve })
     })
@@ -95,4 +85,3 @@ export function debounce<Args extends any[], F extends (...args: Args) => any>(
 
   return debouncedFunction
 }
-/* eslint-enable @typescript-eslint/no-explicit-any */

package/src/utils/defaults-deep.ts

@@ -11,26 +11,22 @@
  * - Avoids infinite recursion for circular source structures.
  */
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-type AnyObject = Record<string, any>
+type PlainObject = Record<string, unknown>
 
-function isObject(value: any): value is AnyObject {
+function isObject(value: unknown): value is PlainObject {
   return value !== null && typeof value === 'object'
 }
 
-export function defaultsDeep<T>(
-  object: T,
-  ...sources: any[]
-): T extends AnyObject ? T : any {
+export function defaultsDeep<T>(object: T, ...sources: unknown[]): T {
   // Ensure we always return an object reference we can mutate (lodash creates/uses {} when target is falsy)
-  const target: AnyObject = (
+  const target: PlainObject = (
     object === null || object === undefined ? {} : object
-  ) as AnyObject
+  ) as PlainObject
 
   // WeakMap to track already-cloned source objects so circular refs won't blow the stack
   const seen = new WeakMap<object, object>()
 
-  function applyDefaults(dst: AnyObject, src: any) {
+  function applyDefaults(dst: PlainObject, src: PlainObject) {
     // Only iterate string-keyed enumerable properties (own + inherited) => for...in
     for (const key in src) {
       if (Object.hasOwn(src, key)) {
@@ -49,12 +45,12 @@ export function defaultsDeep<T>(
               // Prepare new container (array vs object)
               const created = Array.isArray(srcVal)
                 ? ([] as unknown[])
-                : ({} as AnyObject)
+                : ({} as PlainObject)
               // remember mapping to handle circular refs
               seen.set(srcVal, created)
 
               // Recursively fill created from srcVal
-              applyDefaults(created, srcVal)
+              applyDefaults(created as PlainObject, srcVal)
 
               // assign the created clone as the default
               dst[key] = created
@@ -75,11 +71,11 @@ export function defaultsDeep<T>(
   }
 
   for (const src of sources) {
-    if (src !== null && src !== undefined) {
+    if (isObject(src)) {
       // If source itself has been seen (unlikely across top-level sources), we still traverse it
       applyDefaults(target, src)
     }
   }
 
-  return target as any
+  return target as T
 }

package/src/utils/omit.ts

@@ -10,8 +10,8 @@ export function omit<T extends object, K extends keyof T>(
   // eslint-disable-next-line no-restricted-syntax
 ): Omit<T, K> {
   if (object === null || object === undefined) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return {} as any
+    // eslint-disable-next-line no-restricted-syntax
+    return {} as Omit<T, K>
   }
 
   const keysArray = (
@@ -24,16 +24,15 @@ export function omit<T extends object, K extends keyof T>(
   // Copy string/number keys
   for (const key in object) {
     if (Object.hasOwn(object, key) && !keysSet.has(key as keyof T)) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ;(result as any)[key] = object[key as keyof T]
+      result[key as keyof T] = object[key as keyof T]
     }
   }
 
   // Copy symbol keys
+  const record = object as T & Record<PropertyKey, T[keyof T]>
   for (const sym of Object.getOwnPropertySymbols(object)) {
     if (!keysSet.has(sym as keyof T)) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ;(result as any)[sym as unknown as keyof T] = (object as any)[sym]
+      result[sym as keyof T] = record[sym]
     }
   }
 

package/src/utils/poller.ts

@@ -2,8 +2,7 @@ import { v4 as uuidv4 } from 'uuid'
 
 import { CaseTransformer, keysChangeCase } from './case-transformers.ts'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface IPollerResponse<T = any> {
+export interface IPollerResponse<T = unknown> {
   data?: T
   meta?: {
     status: 'COMPLETE' | 'IN_PROGRESS'
@@ -23,6 +22,20 @@ export type TPollerEvents<V extends IPollerResponse = IPollerResponse> = {
 
 const INTERVAL = 1500
 
+function omitUndefined<T extends object>(obj: T): Partial<T> {
+  const out: Partial<T> = {}
+
+  for (const key of Object.keys(obj) as (keyof T)[]) {
+    const value = obj[key]
+
+    if (value !== undefined) {
+      out[key] = value
+    }
+  }
+
+  return out
+}
+
 export interface IPollerOptions<U> {
   callCount?: number
   interval?: number
@@ -76,7 +89,10 @@ export class Poller<V extends IPollerResponse> {
       request()
         .then(result => this.onRequest(result, request, buildedOptions))
         .catch((error: unknown) => {
-          this.dispatch('error', error as TPollerEventCallbackArg<V>)
+          const payload =
+            error instanceof Error ? error : new Error(String(error))
+
+          this.dispatch('error', payload)
         })
     }
 
@@ -91,21 +107,9 @@ export class Poller<V extends IPollerResponse> {
   }
 
   private buildPollerOptions(options: TOptions<V>): TOptions<V> {
-    const compactedOptions = Object.entries(options).reduce<
-      Record<string, unknown>
-    >((acc, [key, value]) => {
-      if (value !== undefined) {
-        const tKey = key as keyof TOptions<V>
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        acc[tKey] = value as any
-      }
-
-      return acc
-    }, {}) as TOptions<V>
-
     return {
       ...this.defaultOptions,
-      ...compactedOptions,
+      ...omitUndefined(options),
     }
   }
 
@@ -142,7 +146,7 @@ export class Poller<V extends IPollerResponse> {
     request: TRequest<V>,
     options: TOptions<V>,
   ): Promise<void> {
-    const resultFormatted = keysChangeCase(result ?? {}, CaseTransformer.Camel)
+    const resultFormatted = keysChangeCase<V>(result, CaseTransformer.Camel)
 
     if (!this.isActivePoller(options)) {
       return
@@ -161,8 +165,10 @@ export class Poller<V extends IPollerResponse> {
     ) {
       // If not in progress but still need to meet minimum call count, set status to in progress
       if (!this.isInProgress(resultFormatted)) {
-        resultFormatted.meta = resultFormatted.meta || {}
-        resultFormatted.meta.status = 'IN_PROGRESS'
+        resultFormatted.meta = {
+          ...resultFormatted.meta,
+          status: 'IN_PROGRESS',
+        }
       }
 
       // Increment call count and dispatch data
@@ -180,8 +186,10 @@ export class Poller<V extends IPollerResponse> {
       // Handle the case when polling should complete
     } else if (this.isInProgress(resultFormatted)) {
       // Mark as complete if it was in progress
-      resultFormatted.meta = resultFormatted.meta || {}
-      resultFormatted.meta.status = 'COMPLETE'
+      resultFormatted.meta = {
+        ...resultFormatted.meta,
+        status: 'COMPLETE',
+      }
       this.onComplete(resultFormatted, options)
       // Handle the case when already complete
     } else {
@@ -221,8 +229,8 @@ export type TPollerCallback<T extends IPollerResponse = IPollerResponse> = (
 export function pollRequest<R extends IPollerResponse>(
   request: TRequest<R>,
   options: TOptions<R>,
-  pollerCallback: TPollerCallback,
-): Promise<PollerReturn>
+  pollerCallback: TPollerCallback<R>,
+): Promise<PollerReturn<R>>
 
 export function pollRequest<R extends IPollerResponse>(
   request: TRequest<R>,

package/src/utils/shake.ts

@@ -4,21 +4,24 @@
  * by custom evaluation.
  */
 // eslint-disable-next-line no-restricted-syntax
-export function shake<RemovedKeys extends string, T>(
+export function shake<RemovedKeys extends string, T extends object>(
   obj: T,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  filter: (value: any) => boolean = x => x === undefined,
+  filter: (value: unknown) => boolean = x => x === undefined,
   // eslint-disable-next-line no-restricted-syntax
 ): Omit<T, RemovedKeys> {
   if (!obj) {
-    return {} as T
+    // eslint-disable-next-line no-restricted-syntax
+    return {} as Omit<T, RemovedKeys>
   }
-  const keys = Object.keys(obj) as (keyof T)[]
-  return keys.reduce((acc, key) => {
-    if (filter(obj[key])) {
-      return acc
+
+  const result: Partial<T> = {}
+
+  for (const key of Object.keys(obj) as (keyof T)[]) {
+    if (!filter(obj[key])) {
+      result[key] = obj[key]
     }
-    acc[key] = obj[key]
-    return acc
-  }, {} as T)
+  }
+
+  // eslint-disable-next-line no-restricted-syntax
+  return result as Omit<T, RemovedKeys>
 }