@revolugo/common 7.12.1 → 7.13.0-rc.0

package/package.json

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

package/src/cancellation-policies.test.ts

@@ -5,6 +5,7 @@ import { describe, expect, test } from 'vitest'
 import {
   getCurrentPenaltyPercentage,
   getPenaltyPercentage,
+  isFreelyCancellableUntilHoursBeforeCheckIn,
   sanitizeCancellationPolicies,
 } from './cancellation-policies.ts'
 import { type Dayjs, dayjs } from './utils/dayjs.ts'
@@ -1044,3 +1045,162 @@ describe('getCurrentPenaltyPercentage', () => {
     ).to.equal(PP_4)
   })
 })
+
+describe('isFreelyCancellableUntilHoursBeforeCheckIn', () => {
+  // Check-in is at the hotel's local midnight; policy dates are anchored to it.
+  const cancelTimezone = 'Europe/Paris'
+  const checkInDate = '2025-09-18'
+  const freeFrom = '2025-08-01T00:00:00Z'
+  // Local midnight of check-in in Paris (UTC+2 in September) expressed in UTC.
+  const checkInInstant = dayjs.tz(checkInDate, cancelTimezone)
+
+  function freeUntil(dateTo: string): ICancellationPolicy[] {
+    return [{ dateFrom: freeFrom, dateTo, penaltyPercentage: 0 }]
+  }
+
+  test('offers Flex when there are no policies', () => {
+    expect(
+      isFreelyCancellableUntilHoursBeforeCheckIn({
+        cancellationPolicies: [],
+        checkInDate,
+        hoursBeforeCheckIn: 48,
+        timezone: cancelTimezone,
+      }),
+    ).toBe(false)
+  })
+
+  test('offers Flex when the booking is non-refundable from the start', () => {
+    expect(
+      isFreelyCancellableUntilHoursBeforeCheckIn({
+        cancellationPolicies: [
+          { dateFrom: freeFrom, dateTo: checkInDate, penaltyPercentage: 100 },
+        ],
+        checkInDate,
+        hoursBeforeCheckIn: 48,
+        timezone: cancelTimezone,
+      }),
+    ).toBe(false)
+  })
+
+  test('offers Flex when the free window stops short of the 48h mark', () => {
+    // Free only until 7 days before check-in → Flex extends the free window.
+    const dateTo = checkInInstant.subtract(7, 'days').format()
+    expect(
+      isFreelyCancellableUntilHoursBeforeCheckIn({
+        cancellationPolicies: freeUntil(dateTo),
+        checkInDate,
+        hoursBeforeCheckIn: 48,
+        timezone: cancelTimezone,
+      }),
+    ).toBe(false)
+  })
+
+  test('suppresses Flex when free continuously until exactly the 48h mark', () => {
+    const dateTo = checkInInstant.subtract(48, 'hours').format()
+    expect(
+      isFreelyCancellableUntilHoursBeforeCheckIn({
+        cancellationPolicies: freeUntil(dateTo),
+        checkInDate,
+        hoursBeforeCheckIn: 48,
+        timezone: cancelTimezone,
+      }),
+    ).toBe(true)
+  })
+
+  test('suppresses Flex when the free window reaches closer to check-in than 48h', () => {
+    const dateTo = checkInInstant.subtract(24, 'hours').format()
+    expect(
+      isFreelyCancellableUntilHoursBeforeCheckIn({
+        cancellationPolicies: freeUntil(dateTo),
+        checkInDate,
+        hoursBeforeCheckIn: 48,
+        timezone: cancelTimezone,
+      }),
+    ).toBe(true)
+  })
+
+  test('offers Flex when a penalty head start precedes the free window', () => {
+    // 50% early then free in the middle: Flex refunds that early period in full,
+    // so it is strictly better and must be offered.
+    expect(
+      isFreelyCancellableUntilHoursBeforeCheckIn({
+        cancellationPolicies: [
+          {
+            dateFrom: '2026-06-04T00:00:00+00:00',
+            dateTo: '2026-06-15T00:00:00+00:00',
+            penaltyPercentage: 50,
+          },
+          {
+            dateFrom: '2026-06-15T00:00:00+00:00',
+            dateTo: '2026-06-16T00:00:00+00:00',
+            penaltyPercentage: 0,
+          },
+          {
+            dateFrom: '2026-06-16T00:00:00+00:00',
+            dateTo: '2026-06-18T00:00:00+00:00',
+            penaltyPercentage: 100,
+          },
+        ],
+        checkInDate: '2026-06-18',
+        hoursBeforeCheckIn: 48,
+        timezone: 'UTC',
+      }),
+    ).toBe(false)
+  })
+
+  test('suppresses Flex across two contiguous free windows reaching the 48h mark', () => {
+    expect(
+      isFreelyCancellableUntilHoursBeforeCheckIn({
+        cancellationPolicies: [
+          {
+            dateFrom: '2026-06-04T00:00:00+00:00',
+            dateTo: '2026-06-10T00:00:00+00:00',
+            penaltyPercentage: 0,
+          },
+          {
+            dateFrom: '2026-06-10T00:00:00+00:00',
+            dateTo: '2026-06-16T00:00:00+00:00',
+            penaltyPercentage: 0,
+          },
+          {
+            dateFrom: '2026-06-16T00:00:00+00:00',
+            dateTo: '2026-06-18T00:00:00+00:00',
+            penaltyPercentage: 100,
+          },
+        ],
+        checkInDate: '2026-06-18',
+        hoursBeforeCheckIn: 48,
+        timezone: 'UTC',
+      }),
+    ).toBe(true)
+  })
+
+  test('suppresses Flex for a UTC+2 policy free until local midnight 48h before check-in', () => {
+    // Real-world data: free window ends at 22:00Z = local midnight (UTC+2),
+    // exactly 48h before a check-in stored as a bare date.
+    expect(
+      isFreelyCancellableUntilHoursBeforeCheckIn({
+        cancellationPolicies: [
+          {
+            dateFrom: '2026-06-04T12:47:07+00:00',
+            dateTo: '2026-06-15T22:00:00+00:00',
+            penaltyPercentage: 0,
+          },
+          {
+            dateFrom: '2026-06-15T22:00:00+00:00',
+            dateTo: '2026-06-16T22:00:00+00:00',
+            penaltyPercentage: 50,
+          },
+          {
+            dateFrom: '2026-06-16T22:00:00+00:00',
+            dateTo: '2026-06-17T22:00:00+00:00',
+            penaltyPercentage: 100,
+          },
+        ],
+        checkInDate: '2026-06-18',
+        hoursBeforeCheckIn: 48,
+        timezone: cancelTimezone,
+      }),
+    ).toBe(true)
+  })
+})

package/src/cancellation-policies.ts

@@ -1,3 +1,4 @@
+// oxlint-disable max-lines
 import { compact } from './utils/compact.ts'
 import { type Dayjs, dayjs } from './utils/dayjs.ts'
 import { isEmpty } from './utils/is-empty.ts'
@@ -523,6 +524,67 @@ export function adjustForCustomers(
   }))
 }
 
+/**
+ * Whether the native cancellation policy is at least as good as Revolugo Flex
+ * (Meetch): the booking can be cancelled for free continuously from booking time
+ * until `hoursBeforeCheckIn` before check-in. When it can, Flex — which only
+ * guarantees a full refund up to that same window — brings no extra benefit and
+ * must not be offered as an addon.
+ *
+ * Flex IS better (and must be offered) as soon as the native policy charges any
+ * penalty inside that window — e.g. a non-refundable/penalty head start before a
+ * free window, a gap in coverage, or a free window that stops short of the 48h
+ * mark.
+ *
+ * `checkInDate` is interpreted at the start of day in `timezone` so the
+ * threshold shares the same time base as the policy dates (which are anchored to
+ * the hotel's local midnight). Without this, a date-only check-in parsed as UTC
+ * drifts by the hotel's UTC offset and the comparison misses by a few hours.
+ */
+export function isFreelyCancellableUntilHoursBeforeCheckIn({
+  cancellationPolicies,
+  checkInDate,
+  hoursBeforeCheckIn,
+  timezone,
+}: {
+  cancellationPolicies: ICancellationPolicy[]
+  checkInDate: string
+  hoursBeforeCheckIn: number
+  timezone: string
+}): boolean {
+  const threshold = dayjs
+    .tz(checkInDate, timezone)
+    .subtract(hoursBeforeCheckIn, 'hours')
+
+  const sanitizedPolicies = getSanitizedCancellationPolicies({
+    cancellationPolicies,
+    checkInDate,
+    timezone,
+  })
+
+  // Walk the policies from booking time, following an unbroken chain of free
+  // (0% penalty) windows. The first penalty or gap stops the chain.
+  let freeUntil: Dayjs | null = null
+  for (const policy of sanitizedPolicies) {
+    if (policy.penaltyPercentage !== 0) {
+      break
+    }
+    if (freeUntil && dayjs(policy.dateFrom).isAfter(freeUntil)) {
+      break
+    }
+
+    const dateTo = dayjs(policy.dateTo)
+    if (!freeUntil || dateTo.isAfter(freeUntil)) {
+      freeUntil = dateTo
+    }
+    if (freeUntil.isSameOrAfter(threshold)) {
+      return true
+    }
+  }
+
+  return false
+}
+
 export function isFreeCancellable(cps: ICancellationPolicy[]): boolean {
   const freeCp = cps.find(cp => cp.penaltyPercentage === 0)
   return (

package/src/constants/insurance.ts

@@ -1,2 +1,50 @@
 export const MEETCH_INSURANCE_TYPE_NAME = 'Meetch Insurance'
 export const MEETCH_INSURANCE_TYPE_SLUG = 'meetch-insurance'
+
+/**
+ * Single source of truth for the Revolugo Flex (Meetch) cancellation window:
+ * hours before check-in until which a claim is eligible. Consumed both by the
+ * frontend (to derive coverage state) and by the backend Meetch contract
+ * (`MEETCH_FLEX_CONTRACT.cancellationUntilHoursBeforeDeparture`).
+ */
+export const MEETCH_FLEX_CANCELLATION_HOURS_BEFORE_CHECK_IN = 48
+
+/**
+ * Persisted lifecycle status of an insurance subscription/claim. Shared so the
+ * frontend can derive cancellation UI from the same values the backend emits;
+ * re-exported from `@revolugo/node/constants` for server-side consumers.
+ */
+export enum InsuranceStatus {
+  Active = 'active',
+  Archived = 'archived',
+  Claimed = 'claimed',
+  Incomplete = 'incomplete',
+  Open = 'open',
+  WaitingPayment = 'waiting_payment',
+}
+
+/**
+ * Insurance statuses for which a Meetch/Flex claim is considered "in progress":
+ * the claim has been opened or settled on the insurer side, so the booking
+ * manager swaps to the claim-status UI instead of offering the cancel CTA.
+ */
+export const MEETCH_CLAIM_IN_PROGRESS_STATUSES: InsuranceStatus[] = [
+  InsuranceStatus.Open,
+  InsuranceStatus.Claimed,
+]
+
+/**
+ * UI-level lifecycle state of a Meetch/Flex insured booking, used to pick which
+ * cancellation UI to render. Derived from {@link InsuranceStatus} plus the
+ * coverage window; `none` means the booking is not Flex-insured and the
+ * standard cancellation policy applies.
+ */
+export const MEETCH_INSURANCE_STATE = {
+  ClaimInProgress: 'claim-in-progress',
+  Expired: 'expired',
+  None: 'none',
+  Valid: 'valid',
+} as const
+
+export type MeetchInsuranceStateType =
+  (typeof MEETCH_INSURANCE_STATE)[keyof typeof MEETCH_INSURANCE_STATE]

package/src/constants/legal.ts

@@ -3,3 +3,6 @@ export const CGV_URL =
 
 export const MEETCH_CGU_URL =
   'https://revolugo.refund.preprod.embedcover.com/en/cgu'
+
+export const MEETCH_CLAIM_URL =
+  'https://revolugo.refund.preprod.embedcover.com/en/signin'

package/src/currencies/utils.ts

@@ -193,7 +193,7 @@ export class MoneyCalculator {
   }
 
   public removeMarkup(percentage: number): this {
-    this.amount *= 1 - percentage
+    this.amount -= this.amount * percentage
 
     return this
   }

package/src/icons/index.ts

@@ -16,6 +16,7 @@ export const ICONS_NAME = Object.freeze({
   bookOpen: 'ph:book-open',
   bowlingBall: 'ph:bowling-ball',
   building: 'ph:building',
+  buildingOffice: 'ph:building-office',
   buildings: 'ph:buildings',
   bus: 'ph:bus',
   cake: 'ph:cake',

package/src/schemas/payment-methods.ts

@@ -1,11 +1,7 @@
 /* eslint-disable camelcase */
 import { z } from 'zod'
 
-import {
-  BookingStatusEnum,
-  PayLaterStatusEnum,
-  PaymentMethodNameEnum,
-} from '../types/index.ts'
+import { PayLaterStatusEnum, PaymentMethodNameEnum } from '../types/index.ts'
 import { isEqual } from '../utils/is-equal.ts'
 
 const allowedPaymentMethodCombinations = [
@@ -110,7 +106,8 @@ export const PAYMENT_METHOD_RESPONSE_SCHEMA = z
 export const PAYMENT_METHODS_RESPONSE_SCHEMA = z
   .array(PAYMENT_METHOD_RESPONSE_SCHEMA)
   .openapi('paymentMethodsApi', {
-    description: `List of preferred payment methods to be used along with their respective payload (when applicable) in order to fulfill the booking.\n\n⚠️ This field is only returned when **booking.status = ${BookingStatusEnum.Created}**`,
+    description:
+      'List of preferred payment methods to be used along with their respective payload (when applicable) in order to fulfill the order',
   })
   .optional()
 

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

@@ -20,7 +20,7 @@ export type PaymentMethod =
   | PaymentMethodPayLater
 
 export interface BasePaymentMethodCreditCard extends BasePaymentMethod {
-  name: 'CREDIT_CARD'
+  name: PaymentMethodNameEnum.CreditCard
 }
 
 export interface PaymentMethodCreditCard extends BasePaymentMethodCreditCard {
@@ -32,7 +32,7 @@ export interface PaymentMethodCreditCard extends BasePaymentMethodCreditCard {
 }
 
 export interface BasePaymentMethodCoupon extends BasePaymentMethod {
-  name: 'COUPON'
+  name: PaymentMethodNameEnum.Coupon
 }
 
 export interface PaymentMethodCoupon extends BasePaymentMethodCoupon {
@@ -43,7 +43,7 @@ export interface PaymentMethodCoupon extends BasePaymentMethodCoupon {
 }
 
 export interface BasePaymentMethodDepositAccount extends BasePaymentMethod {
-  name: 'DEPOSIT_ACCOUNT'
+  name: PaymentMethodNameEnum.DepositAccount
 }
 
 export interface PaymentMethodDepositAccount extends BasePaymentMethodDepositAccount {
@@ -54,7 +54,7 @@ export interface PaymentMethodDepositAccount extends BasePaymentMethodDepositAcc
 }
 
 export interface BasePaymentMethodPayLater extends BasePaymentMethod {
-  name: 'PAY_LATER'
+  name: PaymentMethodNameEnum.PayLater
 }
 
 export interface PayloadPayLater {

package/src/types/insurance.ts

@@ -1,4 +1,4 @@
-import type { CurrencyCode } from '../constants/index.ts'
+import type { CurrencyCode, InsuranceStatus } from '../constants/index.ts'
 
 export interface InsuranceSummary {
   currency: CurrencyCode
@@ -7,3 +7,20 @@ export interface InsuranceSummary {
   price: number
   taxIncludedPrice: number
 }
+
+/**
+ * View-model describing an in-progress Meetch/Flex insurance claim, surfaced in
+ * the booking manager cancel modal. Populated from booking-api claim data once
+ * that is exposed; while absent, the "claim in progress" state never renders.
+ */
+export interface MeetchClaimViewModel {
+  currency: CurrencyCode
+  email: string
+  reference: string
+  /** Expected refund amount in minor units, in {@link MeetchClaimViewModel.currency}. */
+  refundAmount: number
+  /** Persisted claim status; the UI maps it to a localized label + tag severity. */
+  status: InsuranceStatus
+  /** ISO datetime the claim was submitted — rendered as "Claim submitted {date}". */
+  submittedAt: string
+}