@revolugo/common 6.10.6-beta.0 → 6.10.6-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revolugo/common",
-  "version": "6.10.6-beta.0",
+  "version": "6.10.6-beta.2",
   "private": false,
   "description": "Revolugo common",
   "author": "Revolugo",

package/src/cancellation-policies.ts

@@ -169,6 +169,7 @@ export function sanitizeCancellationPolicies({
 
   if (
     releaseDatetimeUTC &&
+    compactedCancellationPolicies[0] &&
     dayjs(releaseDatetimeUTC).isBetween(
       dayjs(bookingDatetimeUTC),
       dayjs(compactedCancellationPolicies[0].dateFrom),
@@ -184,7 +185,7 @@ export function sanitizeCancellationPolicies({
       },
       {
         dateFrom: releaseDatetimeUTC,
-        dateTo: compactedCancellationPolicies[0].dateFrom,
+        dateTo: compactedCancellationPolicies[0]!.dateFrom,
         penaltyPercentage: 100,
       },
     )
@@ -268,11 +269,14 @@ export function sanitizeCancellationPolicies({
       !dayjs(cp.dateFrom).isSameOrAfter(nextDayCheckInDateUTC),
   )
 
-  sanitizedCancellationPolicies[0].dateFrom = bookingDatetimeUTC
+  if (sanitizedCancellationPolicies[0]) {
+    sanitizedCancellationPolicies[0].dateFrom = bookingDatetimeUTC
+  }
 
-  sanitizedCancellationPolicies[
-    sanitizedCancellationPolicies.length - 1
-  ]!.dateTo = nextDayCheckInDateUTC
+  const lastIndex = sanitizedCancellationPolicies.length - 1
+  if (sanitizedCancellationPolicies[lastIndex]) {
+    sanitizedCancellationPolicies[lastIndex].dateTo = nextDayCheckInDateUTC
+  }
 
   return sanitizedCancellationPolicies
 }
@@ -340,10 +344,7 @@ export function getPenaltyPercentage({
     date: datetime,
   })
 
-  return (
-    matchingCancellationPolicies[0] &&
-    matchingCancellationPolicies[0].penaltyPercentage
-  )
+  return matchingCancellationPolicies[0]?.penaltyPercentage ?? 0
 }
 
 export function getCurrentPenaltyPercentage({
@@ -383,7 +384,7 @@ export function isBetterCancellationPolicies(
     return false
   }
 
-  if (!newVal[0].dateTo) {
+  if (!newVal[0]?.dateTo) {
     return oldVal.every(oldCancellationPolicy => {
       const relatedNewCancellationPolicy = newVal.find(newCancellationPolicy =>
         dayjs(oldCancellationPolicy.dateTo).isBetween(
@@ -470,11 +471,17 @@ export function getSanitizedCancellationPolicies({
 export function getCurrentCancellationPolicy(
   sanitizedCancellationPolicies: ICancellationPolicy[],
 ): ICancellationPolicy {
-  return (
-    sanitizedCancellationPolicies.find(policy =>
-      dayjs().isBetween(dayjs(policy.dateFrom), dayjs(policy.dateTo)),
-    ) || sanitizedCancellationPolicies[0]
+  const found = sanitizedCancellationPolicies.find(policy =>
+    dayjs().isBetween(dayjs(policy.dateFrom), dayjs(policy.dateTo)),
   )
+  if (found) {
+    return found
+  }
+  const first = sanitizedCancellationPolicies[0]
+  if (!first) {
+    throw new Error('No cancellation policies available')
+  }
+  return first
 }
 
 function adjustIfFullHour(date: string): Dayjs {

package/src/utils/array-tools.ts

@@ -7,14 +7,26 @@ export function chunk<T>(array: T[], size: number): T[][] {
 }
 
 export function getRandomElementFromArray<T>(array: readonly T[]): T {
-  return array[Math.floor(Math.random() * array.length)]
+  if (array.length === 0) {
+    throw new Error('Cannot get random element from empty array')
+  }
+  const element = array[Math.floor(Math.random() * array.length)]
+  if (element === undefined) {
+    throw new Error('Array element is undefined')
+  }
+  return element
 }
 
 export function shuffleArray<T>(array: T[]): T[] {
   const shuffled = [...array]
   for (let i = shuffled.length - 1; i > 0; i--) {
     const j = Math.floor(Math.random() * (i + 1))
-    ;[shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]]
+    const temp = shuffled[i]
+    const swap = shuffled[j]
+    if (temp !== undefined && swap !== undefined) {
+      shuffled[i] = swap
+      shuffled[j] = temp
+    }
   }
   return shuffled
 }
@@ -171,11 +183,11 @@ export function sortBy<T>(
       const valueA =
         typeof resolvedIteratee === 'function'
           ? resolvedIteratee(a)
-          : a[resolvedIteratee]
+          : a[resolvedIteratee as keyof T]
       const valueB =
         typeof resolvedIteratee === 'function'
           ? resolvedIteratee(b)
-          : b[resolvedIteratee]
+          : b[resolvedIteratee as keyof T]
 
       if (valueA === valueB) {
         if (i === normalizedIteratees.length - 1) {

package/src/utils/colors.ts

@@ -9,6 +9,9 @@ export function generateRandomColorFromString(
   const hueRange = 5
   const randomIndex = Math.floor(num1 * existingColors.length)
   const baseColor = existingColors[randomIndex]
+  if (!baseColor) {
+    throw new Error('Base color not found')
+  }
   // extract the hue value from the base color
   const baseHue = Number.parseInt(baseColor.slice(1, 3), 16)
   const minHue = Math.max(0, baseHue - hueRange)

package/src/utils/dates.ts

@@ -44,14 +44,22 @@ export function sanitizeDateRange(
   if (sortedDates.length === 2) {
     return sortedDates as [string, string]
   } else if (sortedDates.length === 1) {
-    if (sortedDates[0] === dayjs().format('YYYY-MM-DD')) {
+    const firstDate = sortedDates[0]
+    if (!firstDate) {
       return [
         dayjs().format('YYYY-MM-DD'),
         dayjs().add(1, 'day').format('YYYY-MM-DD'),
       ]
     }
 
-    return [dayjs().format('YYYY-MM-DD'), sortedDates[0]]
+    if (firstDate === dayjs().format('YYYY-MM-DD')) {
+      return [
+        dayjs().format('YYYY-MM-DD'),
+        dayjs().add(1, 'day').format('YYYY-MM-DD'),
+      ]
+    }
+
+    return [dayjs().format('YYYY-MM-DD'), firstDate]
   }
 
   return [

package/src/utils/math.ts

@@ -1,6 +1,6 @@
 export function weightedMean(values: number[], weights: number[]): number {
   const sum = values.reduce(
-    (acc: number, val: number, i: number) => acc + val * weights[i],
+    (acc: number, val: number, i: number) => acc + val * (weights[i] ?? 0),
     0,
   )
   const sumWeights = weights.reduce((acc: number, val: number) => acc + val, 0)