@revolugo/common 7.2.4-alpha.20 → 7.2.4-alpha.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revolugo/common",
-  "version": "7.2.4-alpha.20",
+  "version": "7.2.4-alpha.22",
   "private": false,
   "description": "Revolugo common",
   "author": "Revolugo",

package/src/constants/locales.ts

@@ -19,7 +19,7 @@ export enum Lang {
   PT = 'pt',
 }
 
-export type ExtendedLocale = Locale | Lang
+export type ExtendedLocale = Lang | Locale
 
 export function langFromString(langStr: string): Lang | undefined {
   return Object.entries(Lang).find(entry => {

package/src/types/elements/allowed-payment-method.ts

@@ -7,10 +7,10 @@ import type {
 } from './payment-method.ts'
 
 export type AllowedPaymentMethod =
+  | AllowedPaymentMethodPayLater
   | BasePaymentMethodCoupon
   | BasePaymentMethodCreditCard
   | BasePaymentMethodDepositAccount
-  | AllowedPaymentMethodPayLater
 
 export interface AllowedPaymentMethodPayLater extends BasePaymentMethodPayLater {
   payload: PayloadPayLater

package/src/utils/amount-from-percentage.ts

@@ -1,7 +1,7 @@
 export function amountFromPercentage(
   percentage: number,
   amount: number,
-  roundingType: 'none' | 'round' | 'ceil' | 'floor' = 'none',
+  roundingType: 'ceil' | 'floor' | 'none' | 'round' = 'none',
 ): number {
   if (Number.isNaN(Number(percentage)) || Number.isNaN(Number(amount))) {
     throw new TypeError(`${percentage} || ${amount} is NaN`)

package/src/utils/case-transformers.ts

@@ -32,7 +32,7 @@ export const CASE_TRANSFORMERS_MAPPING = {
   [CaseTransformer.Snake]: snakeCase,
 }
 
-export function changeCase<T extends string | string[]>(
+export function changeCase<T extends string[] | string>(
   input: T,
   toCase: CaseTransformer,
 ): T extends string ? string : string[] {
@@ -47,7 +47,7 @@ export function changeCase<T extends string | string[]>(
     : string[]
 }
 
-function matches(patterns: (string | RegExp)[], value: string) {
+function matches(patterns: (RegExp | string)[], value: string) {
   return patterns.some(pattern =>
     typeof pattern === 'string' ? pattern === value : pattern.test(value),
   )
@@ -62,14 +62,14 @@ export function keysChangeCase<T = any>(
   obj: any[],
   toCase: CaseTransformer,
 
-  options?: { deep?: boolean; exclude?: (string | RegExp)[] },
+  options?: { deep?: boolean; exclude?: (RegExp | string)[] },
 ): T[]
 
 // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
 export function keysChangeCase<T = any>(
   obj: unknown,
   toCase: CaseTransformer,
-  options?: { deep?: boolean; exclude?: (string | RegExp)[] },
+  options?: { deep?: boolean; exclude?: (RegExp | string)[] },
 ): T
 
 export function keysChangeCase<T>(
@@ -77,7 +77,7 @@ export function keysChangeCase<T>(
   obj: any,
   toCase: CaseTransformer,
 
-  options: { deep?: boolean; exclude?: (string | RegExp)[] } = { deep: true },
+  options: { deep?: boolean; exclude?: (RegExp | string)[] } = { deep: true },
 ): unknown {
   if (isObject(obj) && !(obj instanceof Date)) {
     return Object.keys(obj).reduce<any>((result, key) => {

package/src/utils/create-composite-key.ts

@@ -16,7 +16,7 @@ type CompositeKeyOptions<T> =
   NonNullable<T> extends (infer U)[]
     ? CompositeKeyOptions<U>
     : CompositeLeafAttributes & {
-        attributes: CompositeOmitAttributes<T> | CompositeAttributesType
+        attributes: CompositeAttributesType | CompositeOmitAttributes<T>
         children?: {
           [K in keyof T]?: NonNullable<T[K]> extends object
             ? CompositeKeyOptions<NonNullable<T[K]>>

package/src/utils/dates.ts

@@ -72,7 +72,7 @@ export function isDate(value: unknown): value is Date {
   return value instanceof Date && !isNaN(value.getTime())
 }
 
-export type DateInput = string | Date
+export type DateInput = Date | string
 
 export function generateDates(
   startDate: DateInput,

package/src/utils/group-by.ts

@@ -4,9 +4,9 @@
  * @param keyOrGetter The key to group by or a function that returns the key.
  * @returns An object where keys are the group identifiers and values are arrays of items.
  */
-function groupBy<T, K extends string | number>(
+function groupBy<T, K extends number | string>(
   array: T[],
-  keyOrGetter: keyof T | ((item: T) => K | undefined),
+  keyOrGetter: ((item: T) => K | undefined) | keyof T,
 ): Record<K, T[]> {
   return array.reduce(
     (acc, item) => {

package/src/utils/images.ts

@@ -26,7 +26,7 @@ export function generateImageUrls(
   )
 }
 
-type ImageSize = 'xs' | 's' | 'm' | 'l' | 'xl'
+type ImageSize = 'l' | 'm' | 's' | 'xl' | 'xs'
 
 function selectBestSize(
   hotelImage: HotelImage,

package/src/utils/key-by.ts

@@ -8,7 +8,7 @@
  */
 export function keyBy<T>(
   collection: T[] | null | undefined,
-  iteratee: ((value: T) => string | number) | keyof T,
+  iteratee: ((value: T) => number | string) | keyof T,
 ): Record<string, T> {
   return (
     collection?.reduce<Record<string, T>>((acc, item) => {

package/src/utils/map-keys.ts

@@ -4,8 +4,8 @@
  */
 export const mapKeys = <
   TValue,
-  TKey extends string | number | symbol,
-  TNewKey extends string | number | symbol,
+  TKey extends number | string | symbol,
+  TNewKey extends number | string | symbol,
 >(
   obj: Record<TKey, TValue>,
   mapFunc: (key: TKey, value: TValue) => TNewKey,

package/src/utils/map-values.ts

@@ -3,7 +3,7 @@
  */
 export const mapValues = <
   TValue,
-  TKey extends string | number | symbol,
+  TKey extends number | string | symbol,
   TNewValue,
 >(
   obj: Record<TKey, TValue>,

package/src/utils/omit-by.ts

@@ -9,7 +9,7 @@
  */
 export function omitBy<T extends object>(
   object: T,
-  predicate: ((value: T[keyof T], key: keyof T) => boolean) | string,
+  predicate: string | ((value: T[keyof T], key: keyof T) => boolean),
 ): Partial<T> {
   const result = {} as Partial<T>
 

package/src/utils/omit.ts

@@ -6,7 +6,7 @@
 // eslint-disable-next-line no-restricted-syntax
 export function omit<T extends object, K extends keyof T>(
   object: T | null | undefined,
-  keys: readonly K[] | K,
+  keys: K | readonly K[],
   // eslint-disable-next-line no-restricted-syntax
 ): Omit<T, K> {
   if (object === null || object === undefined) {

package/src/utils/poller.ts

@@ -6,7 +6,7 @@ import { CaseTransformer, keysChangeCase } from './case-transformers.ts'
 export interface IPollerResponse<T = any> {
   data?: T
   meta?: {
-    status: 'IN_PROGRESS' | 'COMPLETE'
+    status: 'COMPLETE' | 'IN_PROGRESS'
   }
 }
 
@@ -14,7 +14,7 @@ export type TPollerRequestCallback<V> = () => Promise<V>
 export type TPollerEventCallbackArg<
   V extends IPollerResponse = IPollerResponse,
 > = V | Error
-export type TPollerEventName = 'data' | 'error' | 'complete'
+export type TPollerEventName = 'complete' | 'data' | 'error'
 export type TPollerEventCallback<V extends IPollerResponse = IPollerResponse> =
   (arg?: TPollerEventCallbackArg<V>) => void
 export type TPollerEvents<V extends IPollerResponse = IPollerResponse> = {
@@ -233,7 +233,7 @@ export function pollRequest<R extends IPollerResponse>(
   request: TRequest<R>,
   options: TOptions<R>,
   pollerCallback?: TPollerCallback<R>,
-): Promise<PollerReturn<R> | R | undefined> | PollerReturn<R> | R | undefined {
+): PollerReturn<R> | Promise<PollerReturn<R> | R | undefined> | R | undefined {
   const poller: Poller<R> = Poller.getInstance()
 
   poller.poll(request, options)

package/src/utils/sort-by.ts

@@ -2,7 +2,7 @@ type Iteratee<T> = ((item: T) => unknown) | keyof T
 type SortOrder = 'asc' | 'desc'
 
 export function sortBy<T>(
-  collection: T[] | Record<string, T> | null | undefined,
+  collection: Record<string, T> | T[] | null | undefined,
   iteratees?: Iteratee<T> | Iteratee<T>[] | string,
   order?: SortOrder | SortOrder[],
 ): T[] {

package/src/utils/sum.ts

@@ -1,11 +1,11 @@
 export function sum(arr: number[]): number
 export function sum<T>(
   arr: T[],
-  keyOrFunc: keyof T | ((item: T) => number),
+  keyOrFunc: ((item: T) => number) | keyof T,
 ): number
 export function sum<T>(
   arr: T[],
-  keyOrFunc?: keyof T | ((item: T) => number),
+  keyOrFunc?: ((item: T) => number) | keyof T,
 ): number {
   if (arr.length === 0) {
     return 0

package/src/utils/to-lang.ts

@@ -4,22 +4,22 @@ import type { ExtendedLocale } from '../constants/locales.ts'
 
 export function toLang(localeOrLang: ExtendedLocale): Lang {
   switch (localeOrLang) {
-    case Lang.EN:
-    case Locale.en_US: {
-      return Lang.EN
-    }
-    case Lang.FR:
-    case Locale.fr_FR: {
-      return Lang.FR
-    }
     case Lang.DE:
     case Locale.de_DE: {
       return Lang.DE
     }
+    case Lang.EN:
+    case Locale.en_US: {
+      return Lang.EN
+    }
     case Lang.ES:
     case Locale.es_ES: {
       return Lang.ES
     }
+    case Lang.FR:
+    case Locale.fr_FR: {
+      return Lang.FR
+    }
     case Lang.IT:
     case Locale.it_IT: {
       return Lang.IT

package/src/utils/to-locale.ts

@@ -4,22 +4,22 @@ import type { ExtendedLocale } from '../constants/locales.ts'
 
 export function toLocale(localeOrLang: ExtendedLocale): Locale {
   switch (localeOrLang) {
-    case Lang.EN:
-    case Locale.en_US: {
-      return Locale.en_US
-    }
-    case Lang.FR:
-    case Locale.fr_FR: {
-      return Locale.fr_FR
-    }
     case Lang.DE:
     case Locale.de_DE: {
       return Locale.de_DE
     }
+    case Lang.EN:
+    case Locale.en_US: {
+      return Locale.en_US
+    }
     case Lang.ES:
     case Locale.es_ES: {
       return Locale.es_ES
     }
+    case Lang.FR:
+    case Locale.fr_FR: {
+      return Locale.fr_FR
+    }
     case Lang.IT:
     case Locale.it_IT: {
       return Locale.it_IT

package/src/utils/uniq-by.ts

@@ -1,6 +1,6 @@
 export function uniqBy<T>(
-  array: T[] | undefined | null,
-  iteratee: keyof T | ((item: T) => unknown),
+  array: T[] | null | undefined,
+  iteratee: ((item: T) => unknown) | keyof T,
 ): T[] {
   const seen = new Set()
   return (

package/src/utils/uniq.ts

@@ -6,11 +6,11 @@
  */
 export function uniq<T>(
   array: readonly T[],
-  toKey?: (item: T) => string | number | symbol,
+  toKey?: (item: T) => number | string | symbol,
 ): T[] {
-  const valueMap = array.reduce<Record<string | number | symbol, T>>(
+  const valueMap = array.reduce<Record<number | string | symbol, T>>(
     (acc, item) => {
-      const key = toKey ? toKey(item) : (item as string | number | symbol)
+      const key = toKey ? toKey(item) : (item as number | string | symbol)
       if (acc[key]) {
         return acc
       }