@revolugo/common 6.9.6 → 6.9.7-beta.1

package/src/utils/currency.ts

@@ -1,6 +1,8 @@
-import { CURRENCIES_MAP, type Currency } from '../constants/index.ts'
+import { CURRENCIES_MAP } from '../currencies/index.ts'
 
-export const getCurrencySymbol = (currency: Currency): string => {
+import type { Currency } from '../constants/currencies.ts'
+
+export function getCurrencySymbol(currency: Currency): string {
   const symbol = CURRENCIES_MAP[currency]?.symbol
 
   if (!symbol) {
@@ -10,16 +12,19 @@ export const getCurrencySymbol = (currency: Currency): string => {
   return symbol
 }
 
-export const isZeroDecimal = (currency: Currency): boolean =>
-  (CURRENCIES_MAP[currency] && CURRENCIES_MAP[currency].zeroDecimal) || false
+export function isZeroDecimal(currency: Currency): boolean {
+  return (
+    (CURRENCIES_MAP[currency] && CURRENCIES_MAP[currency].zeroDecimal) || false
+  )
+}
 
-export const normalizeAmount = ({
+export function normalizeAmount({
   amount,
   currency,
 }: {
   amount: number
   currency: Currency
-}): number => {
+}): number {
   if (isZeroDecimal(currency)) {
     return amount
   }
@@ -27,13 +32,13 @@ export const normalizeAmount = ({
   return amount * 100
 }
 
-export const denormalizeAmount = ({
+export function denormalizeAmount({
   amount,
   currency,
 }: {
   amount: number
   currency: Currency
-}): number => {
+}): number {
   if (isZeroDecimal(currency)) {
     return amount
   }
@@ -41,17 +46,17 @@ export const denormalizeAmount = ({
   return amount / 100
 }
 
-export const formatAmount = ({
+export function formatAmount({
   amount,
   currency,
   locale = 'en',
-  space = ' ',
+  space = '',
 }: {
   amount: number
   currency: string
   locale?: string
   space?: string
-}): string => {
+}): string {
   const fractionDigits = amount.toFixed(2).endsWith('.00') ? 0 : 2
 
   return (
@@ -70,6 +75,7 @@ export const formatAmount = ({
   )
 }
 
+/* @__PURE__ */
 export class MoneyCalculator {
   private amount: number
   private currency: Currency
@@ -142,6 +148,12 @@ export class MoneyCalculator {
     return this
   }
 
+  public round(): this {
+    this.amount = Math.round(this.amount)
+
+    return this
+  }
+
   public format(locale?: string, space?: string): string {
     return formatAmount({
       amount: this.amount,
@@ -166,16 +178,16 @@ export class MoneyCalculator {
       return this
     }
 
-    const { isNormalized } = this
+    const startingIsNormalized = this.isNormalized
 
-    if (isNormalized) {
+    if (startingIsNormalized) {
       this.denormalize()
     }
 
     this.amount *= exchangeRate
     this.currency = currency
 
-    if (isNormalized) {
+    if (startingIsNormalized) {
       this.normalize()
     }
 
@@ -183,13 +195,13 @@ export class MoneyCalculator {
   }
 }
 
-export const ceilNormalizedAmount = ({
+export function ceilNormalizedAmount({
   amount,
   currency,
 }: {
   amount: number
   currency: Currency
-}): number => {
+}): number {
   const denormalizedAmount = denormalizeAmount({
     amount,
     currency,
@@ -201,13 +213,13 @@ export const ceilNormalizedAmount = ({
   })
 }
 
-export const floorNormalizedAmount = ({
+export function floorNormalizedAmount({
   amount,
   currency,
 }: {
   amount: number
   currency: Currency
-}): number => {
+}): number {
   const denormalizedAmount = denormalizeAmount({
     amount,
     currency,

package/src/utils/dates.ts

@@ -1,5 +1,3 @@
-import { uniq } from 'lodash-es'
-
 import { DATE_STRING_FORMAT } from '../constants/index.ts'
 
 import { dayjs } from './dayjs.ts'
@@ -20,11 +18,11 @@ export function sortDates(dates: string[]): string[] {
   return validDates.sort((a, b) => (dayjs(a).isAfter(dayjs(b), 'day') ? 1 : -1))
 }
 
-export const getDateRange = (
+export function getDateRange(
   start: Date | string,
   end: Date | string,
   format: string = DATE_STRING_FORMAT,
-): string[] => {
+): string[] {
   const dates: string[] = []
   let current = dayjs(start)
 
@@ -41,7 +39,7 @@ export function sanitizeDateRange(
   dateA: string,
   dateB: string,
 ): [string, string] {
-  const sortedDates = uniq(sortDates([dateA, dateB]))
+  const sortedDates = [...new Set(sortDates([dateA, dateB]))]
 
   if (sortedDates.length === 2) {
     return sortedDates as [string, string]
@@ -80,11 +78,9 @@ export function generateDates(
   }
 
   const totalDays = end.diff(start, 'day') + 1
-  const dates = new Array<Date>(totalDays)
-
-  for (let i = 0; i < totalDays; i++) {
-    dates[i] = start.add(i, 'day').toDate()
-  }
+  const dates = Array.from({ length: totalDays }, (_, i) =>
+    start.add(i, 'day').toDate(),
+  )
 
   return dates
 }

package/src/utils/debounce.ts

@@ -46,7 +46,7 @@ export function debounce<Args extends any[], F extends (...args: Args) => any>(
     return waitMilliseconds
   }
 
-  const debouncedFunction = function debouncedFunction(
+  function debouncedFunction(
     this: ThisParameterType<F>,
     ...args: Parameters<F>
   ) {
@@ -54,7 +54,7 @@ export function debounce<Args extends any[], F extends (...args: Args) => any>(
     const context = this
     // eslint-disable-next-line consistent-return
     return new Promise<Awaited<ReturnType<F>>>((resolve, reject) => {
-      const invokeFunction = function invokeFunction() {
+      function invokeFunction() {
         timeoutId = undefined
         lastInvokeTime = Date.now()
         if (!isImmediate) {

package/src/utils/find-unique-keys.ts

@@ -1,6 +1,6 @@
-export const findUniqueKeys = (
+export function findUniqueKeys(
   objects: { [key: string]: unknown }[],
-): string[] => {
+): string[] {
   const objectKeys = objects.flatMap(Object.keys)
   return [...new Set(objectKeys)]
 }

package/src/utils/get-guest-count.ts

@@ -1,5 +1,6 @@
 import { parseChildren } from './children-tools.ts'
 
+/* @__PURE__ */
 export const CHILDREN_FREE_BREAKFAST_AGE_LIMIT = 4
 
 export function getGuestCount(

package/src/utils/index.ts

@@ -2,7 +2,6 @@ export * from './add-classes.ts'
 export * from './array-tools.ts'
 export * from './case-transformers.ts'
 export * from './colors.ts'
-export * from './countries.ts'
 export * from './currency.ts'
 export * from './dates.ts'
 export * from './dayjs.ts'
@@ -18,6 +17,7 @@ export * from './numbers.ts'
 export * from './object-tools.ts'
 export * from './poller.ts'
 export * from './promise-tools.ts'
+export * from './random.ts'
 export * from './range.ts'
 export * from './strings.ts'
 export * from './sum.ts'

package/src/utils/lang-default-fallbacks.ts

@@ -2,7 +2,7 @@ import { LOCALE_TO_LANG, Locale } from '../constants/locales.ts'
 
 import type { Lang } from '../constants/locales.ts'
 
-export const langDefaultFallbacks = (lang?: Locale): Lang[] => {
+export function langDefaultFallbacks(lang?: Locale): Lang[] {
   if (!lang || lang === Locale.en_US) {
     return [LOCALE_TO_LANG[Locale.en_US]]
   }

package/src/utils/math.ts

@@ -1,4 +1,4 @@
-export const weightedMean = (values: number[], weights: number[]): number => {
+export function weightedMean(values: number[], weights: number[]): number {
   const sum = values.reduce(
     (acc: number, val: number, i: number) => acc + val * weights[i],
     0,
@@ -8,11 +8,11 @@ export const weightedMean = (values: number[], weights: number[]): number => {
   return sum / sumWeights
 }
 
-export const amountFromPercentage = (
+export function amountFromPercentage(
   percentage: number,
   amount: number,
   roundingType: 'none' | 'round' | 'ceil' | 'floor' = 'none',
-): number => {
+): number {
   if (Number.isNaN(Number(percentage)) || Number.isNaN(Number(amount))) {
     throw new TypeError(`${percentage} || ${amount} is NaN`)
   }

package/src/utils/numbers.ts

@@ -1,4 +1,4 @@
-export const generateNumbersFromStr = (str: string): [number, number] => {
+export function generateNumbersFromStr(str: string): [number, number] {
   let hash = 5381
   for (let i = 0; i < str.length; i++) {
     // eslint-disable-next-line no-bitwise
@@ -14,13 +14,14 @@ export const generateNumbersFromStr = (str: string): [number, number] => {
   return [num1, num2]
 }
 
-export const randomInt = (min: number, max: number): number =>
-  Math.floor(Math.random() * (max - min + 1) + min)
+export function randomInt(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1) + min)
+}
 
-export const computeSellingPrice = (
+export function computeSellingPrice(
   buyingPrice: number | string | null = 0,
   rate: number | string | null = 0,
-): number => {
+): number {
   if (Number.isNaN(Number(buyingPrice)) || Number.isNaN(Number(rate))) {
     throw new TypeError('price or rate is NaN')
   }
@@ -30,10 +31,10 @@ export const computeSellingPrice = (
   return Math.ceil(Math.floor(sellingPrice * 100) / 100)
 }
 
-export const computeMarginRate = (
+export function computeMarginRate(
   buyingPrice: number | string,
   sellingPrice: number | string,
-): number => {
+): number {
   const buyingPriceNum = Number(buyingPrice)
   const sellingPriceNum = Number(sellingPrice)
 

package/src/utils/object-tools.ts

@@ -15,10 +15,10 @@ type Merge<T, S> = {
       : never
 }
 
-export const customMerge = <T extends object, S extends object>(
+export function customMerge<T extends object, S extends object>(
   target: T,
   source: S,
-): Merge<T, S> => {
+): Merge<T, S> {
   for (const key of Object.keys(source)) {
     const sourceValue = source[key as keyof S]
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -60,3 +60,61 @@ export function compactObject<T extends object>(obj: T): Partial<T> {
     Object.entries(obj).filter(([, value]) => !isNil(value)),
   ) as Partial<T>
 }
+
+/**
+ * Creates an object composed of keys generated from the results of running each element of collection through iteratee.
+ * The corresponding value of each key is the last element responsible for generating the key.
+ *
+ * @param collection - The collection to iterate over
+ * @param iteratee - The iteratee to transform keys. Can be a function or a property name
+ * @returns Returns the composed aggregate object
+ */
+export function keyBy<T>(
+  collection: T[],
+  iteratee: ((value: T) => string | number) | keyof T,
+): Record<string, T> {
+  return collection.reduce<Record<string, T>>((acc, item) => {
+    const key =
+      typeof iteratee === 'function' ? iteratee(item) : String(item[iteratee])
+    acc[key] = item
+    return acc
+  }, {})
+}
+
+/**
+ * Creates an object composed of the own enumerable properties of object that predicate doesn't return truthy for.
+ * The predicate is invoked with two arguments: (value, key).
+ * If predicate is a string, it omits the property with that key name.
+ *
+ * @param object - The source object
+ * @param predicate - The function invoked per property or a string key to omit
+ * @returns Returns the new object
+ */
+export function omitBy<T extends object>(
+  object: T,
+  predicate: ((value: T[keyof T], key: keyof T) => boolean) | string,
+): Partial<T> {
+  const result = {} as Partial<T>
+
+  for (const key in object) {
+    if (Object.hasOwn(object, key)) {
+      const value = object[key]
+
+      // If predicate is a string, check if key matches
+      if (typeof predicate === 'string') {
+        // eslint-disable-next-line max-depth
+        if (key !== predicate) {
+          result[key] = value
+        }
+      } else if (typeof predicate === 'function') {
+        // If predicate is a function, use it
+        // eslint-disable-next-line max-depth
+        if (!predicate(value, key)) {
+          result[key] = value
+        }
+      }
+    }
+  }
+
+  return result
+}

package/src/utils/poller.ts

@@ -21,6 +21,7 @@ export type TPollerEvents<V extends IPollerResponse = IPollerResponse> = {
   [k in TPollerEventName]: TPollerEventCallback<V>
 }
 
+/* @__PURE__ */
 const INTERVAL = 1500
 
 export interface IPollerOptions<U> {

package/src/utils/random.ts

@@ -0,0 +1,12 @@
+export function getRandomInt(min: number, max: number): number {
+  const roundedMin = Math.ceil(min)
+  const roundedMax = Math.floor(max)
+
+  return Math.floor(Math.random() * (roundedMax - roundedMin + 1)) + roundedMin
+}
+
+export function getRandomHexColor(): string {
+  const hex = Math.floor(Math.random() * 0xffffff).toString(16)
+
+  return hex.padStart(6, '0').toUpperCase()
+}

package/src/utils/strings.ts

@@ -1,6 +1,8 @@
-export const generatePseudoRandomString = (length: number): string =>
-  Array.from({ length }, () => Math.random().toString(36)[2]).join('')
+export function generatePseudoRandomString(length: number): string {
+  return Array.from({ length }, () => Math.random().toString(36)[2]).join('')
+}
 
+/* @__PURE__ */
 const TS_QUERY_SPECIAL_CHARS = new Set([
   '&',
   '|',
@@ -13,6 +15,7 @@ const TS_QUERY_SPECIAL_CHARS = new Set([
   '@',
 ])
 
+/* @__PURE__ */
 const REGEX_SPECIAL_CHARS = new Set(['|', '(', ')'])
 
 export function prepareTsQuery(query: string): string | null {

package/src/utils/validators.ts

@@ -1,3 +1,4 @@
+/* @__PURE__ */
 export const validators = {
   alpha: (value: string): boolean => /[a-zA-Z]/u.test(value),
   email: (value: string): boolean => /.+@.+\..+/u.test(value),

package/src/utils/countries.ts

@@ -1,4 +0,0 @@
-import { EU_COUNTRIES_ISO2_CODE } from '../constants/countries.ts'
-
-export const isInEu = (countryCode: string): boolean =>
-  EU_COUNTRIES_ISO2_CODE.has(countryCode)