@wix/headless-bookings 1.0.16 → 1.0.18

package/cjs/dist/services/payment/payment.js

@@ -14,6 +14,7 @@ const auto_sdk_bookings_pricing_1 = require("@wix/auto_sdk_bookings_pricing");
 const booking_js_1 = require("../booking/booking.js");
 const auto_sdk_bookings_services_1 = require("@wix/auto_sdk_bookings_services");
 const payment_def_js_1 = require("./payment.def.js");
+const servicePayment_js_1 = require("../servicePayment.js");
 const guid_js_1 = require("../../utils/guid.js");
 var payment_def_js_2 = require("./payment.def.js");
 Object.defineProperty(exports, "PaymentServiceDefinition", { enumerable: true, get: function () { return payment_def_js_2.PaymentServiceDefinition; } });
@@ -25,14 +26,13 @@ const DEFAULT_SERVICE_OPTIONS = {
     isOnline: false,
     isInPerson: false,
     isDeposit: false,
+    canPayFullUpfront: false,
 };
 /**
  * Derives static service payment options from the first service's configuration.
  *
- * Note on `isDeposit`: this reflects whether the service is *configured* with a
- * deposit (i.e. `payment.fixed.deposit.value > 0`), consistent with how
- * `buildLineItem` determines `hasDeposit`. Only `FIXED` rate type is checked;
- * `VARIED` pricing is not currently supported for deposit detection here.
+ * Note on `isDeposit`: reflects whether the service *takes* a deposit, not
+ * whether an amount is configured — see `requiresDeposit`.
  *
  * This is distinct from the runtime `isDeposit` flag in `CorePayment.Data`, which
  * is computed dynamically from the ecom API result (`payNow.amount < total.amount`).
@@ -42,12 +42,11 @@ const DEFAULT_SERVICE_OPTIONS = {
 function deriveServiceOptions(pricingServiceSelections) {
     const service = pricingServiceSelections[0]?.service;
     const options = service?.payment?.options;
-    const depositValue = service?.payment?.fixed?.deposit?.value;
-    const hasDeposit = !!depositValue && Number(depositValue) > 0;
     return {
         isOnline: !!options?.online,
         isInPerson: !!options?.inPerson,
-        isDeposit: hasDeposit,
+        isDeposit: (0, servicePayment_js_1.requiresDeposit)(service),
+        canPayFullUpfront: (0, servicePayment_js_1.isFullUpfrontPaymentAllowed)(service),
     };
 }
 function getAdditionalInfo(service, lineItemId) {
@@ -60,52 +59,77 @@ function getAdditionalInfo(service, lineItemId) {
 /**
  * Resolves the line item's `paymentOption`.
  *
- * Precedence: explicit consumer choice (`selectedPaymentOption`) wins over the
- * service-config heuristic so the preview always agrees with what `book()`
- * will send. When unset, the existing heuristic is preserved for backward
- * compat.
+ * Precedence: an explicit `selectedPaymentOption` wins over the service-config
+ * heuristic. `depositSelected` then picks deposit-vs-full within the online
+ * branches only — the offline branches ignore it.
+ *
+ * Note: `online && inPerson` resolves OFFLINE here but ONLINE in
+ * `buildBookingRequest`'s heuristic. Pre-existing; the two aren't derived from a
+ * shared rule.
  */
-function getPaymentOption(service, hasDeposit, selectedPaymentOption) {
+function getPaymentOption(service, hasDeposit, selectedPaymentOption, depositSelected) {
+    // Only an explicit `false` (pay in full) cancels the deposit split. `undefined`
+    // means the visitor never chose, and must keep charging the deposit — that is
+    // what every deposit service did before this field existed.
+    const chargeDeposit = hasDeposit && depositSelected !== false;
     if (selectedPaymentOption === 'OFFLINE') {
         return 'FULL_PAYMENT_OFFLINE';
     }
     if (selectedPaymentOption === 'ONLINE') {
-        return hasDeposit ? 'DEPOSIT_ONLINE' : 'FULL_PAYMENT_ONLINE';
+        return chargeDeposit ? 'DEPOSIT_ONLINE' : 'FULL_PAYMENT_ONLINE';
     }
     const options = service.payment?.options;
     if (options?.inPerson) {
         return 'FULL_PAYMENT_OFFLINE';
     }
     // If deposit is configured, use DEPOSIT_ONLINE to get correct payNow/payLater split
-    if (hasDeposit) {
+    if (chargeDeposit) {
         return 'DEPOSIT_ONLINE';
     }
     return 'FULL_PAYMENT_ONLINE';
 }
-function buildLineItem(service, totalParticipants, lineItemId, selectedPaymentOption) {
-    // Get fixed price from service
-    const servicePrice = service.payment?.fixed?.price?.value;
-    const price = Number(servicePrice || 0) * totalParticipants;
-    // Get deposit if configured
-    const depositValue = service.payment?.fixed?.deposit?.value;
-    const hasDeposit = !!depositValue && Number(depositValue) > 0;
-    const deposit = hasDeposit
-        ? Number(depositValue) * totalParticipants
-        : undefined;
-    // Get payment option from service configuration (pass hasDeposit for correct API behavior)
-    const paymentOption = getPaymentOption(service, hasDeposit, selectedPaymentOption);
+/**
+ * Assembles the eCom line item. Both pricing paths go through here so the
+ * `depositAmount` rule — eCom rejects it unless the option is `DEPOSIT_ONLINE` —
+ * lives in one place.
+ */
+function toLineItem(args) {
+    const { lineItemId, serviceId, price, deposit, paymentOption } = args;
     return {
         _id: lineItemId,
         catalogReference: {
-            catalogItemId: service._id || '',
+            catalogItemId: serviceId || '',
             appId: constants_js_1.BOOKING_APP_ID,
         },
         price: String(price),
-        ...(deposit ? { depositAmount: String(deposit) } : {}),
+        ...(deposit && paymentOption === 'DEPOSIT_ONLINE'
+            ? { depositAmount: String(deposit) }
+            : {}),
         quantity: 1,
         paymentOption,
     };
 }
+function buildLineItem(service, totalParticipants, lineItemId, selectedPaymentOption, depositSelected) {
+    // VARIED-rate services carry price and deposit under `varied`, not `fixed`.
+    const servicePrice = service.payment?.fixed?.price?.value ??
+        service.payment?.varied?.defaultPrice?.value;
+    const price = Number(servicePrice || 0) * totalParticipants;
+    // Charge a deposit only if the service takes one and we know the amount.
+    const depositValue = (0, servicePayment_js_1.getDepositValue)(service);
+    const hasDeposit = (0, servicePayment_js_1.requiresDeposit)(service) && (0, servicePayment_js_1.hasDeposit)(service);
+    const deposit = hasDeposit
+        ? Number(depositValue) * totalParticipants
+        : undefined;
+    // Get payment option from service configuration (pass hasDeposit for correct API behavior)
+    const paymentOption = getPaymentOption(service, hasDeposit, selectedPaymentOption, depositSelected);
+    return toLineItem({
+        lineItemId,
+        serviceId: service._id,
+        price,
+        deposit,
+        paymentOption,
+    });
+}
 // durationRange is an @internal field on AvailabilityConstraints (bookings services SDK v1.0.226+).
 // It signals that the service uses flexible duration pricing (hourly/daily rentals),
 // where the correct price must be fetched via previewPrice() rather than the fixed unit price.
@@ -124,7 +148,7 @@ async function getPreviewedPrice(bookingLineItems) {
         deposit: result.priceInfo?.deposit ?? null,
     };
 }
-async function buildLineItemWithPreview(item, totalParticipants, selectedPaymentOption) {
+async function buildLineItemWithPreview(item, totalParticipants, selectedPaymentOption, depositSelected) {
     const slots = item.rangeTimeSlots && item.rangeTimeSlots.length > 0
         ? item.rangeTimeSlots.map((s) => ({
             localStartDate: s.startDate,
@@ -138,7 +162,12 @@ async function buildLineItemWithPreview(item, totalParticipants, selectedPayment
                 },
             ]
             : [];
-    if (item.service._id && slots.length && getDurationRange(item.service)) {
+    // A deposit with no configured amount is a percentage — only the server knows
+    // the figure, and guessing it risks charging something else.
+    const needsServerResolvedDeposit = (0, servicePayment_js_1.requiresDeposit)(item.service) && !(0, servicePayment_js_1.hasDeposit)(item.service);
+    if (item.service._id &&
+        slots.length &&
+        (getDurationRange(item.service) || needsServerResolvedDeposit)) {
         const bookingLineItems = slots.map((slot) => ({
             serviceId: item.service._id,
             localStartDate: slot.localStartDate,
@@ -148,37 +177,34 @@ async function buildLineItemWithPreview(item, totalParticipants, selectedPayment
         }));
         const previewedPrice = await getPreviewedPrice(bookingLineItems).catch(() => null);
         if (previewedPrice != null) {
-            const depositValue = item.service.payment?.fixed?.deposit?.value;
+            const depositValue = (0, servicePayment_js_1.getDepositValue)(item.service);
             const previewedDeposit = previewedPrice.deposit;
-            const hasDeposit = previewedDeposit != null
-                ? previewedDeposit > 0
-                : !!depositValue && Number(depositValue) > 0;
+            const hasDeposit = (0, servicePayment_js_1.requiresDeposit)(item.service) &&
+                (previewedDeposit != null
+                    ? previewedDeposit > 0
+                    : (0, servicePayment_js_1.hasDeposit)(item.service));
             const deposit = hasDeposit
                 ? previewedDeposit != null
                     ? previewedDeposit
                     : Number(depositValue) * totalParticipants
                 : undefined;
-            return {
-                _id: item.lineItemId,
-                catalogReference: {
-                    catalogItemId: item.service._id || '',
-                    appId: constants_js_1.BOOKING_APP_ID,
-                },
-                price: String(previewedPrice.price),
-                ...(deposit ? { depositAmount: String(deposit) } : {}),
-                quantity: 1,
-                paymentOption: getPaymentOption(item.service, hasDeposit, selectedPaymentOption),
-            };
+            return toLineItem({
+                lineItemId: item.lineItemId,
+                serviceId: item.service._id,
+                price: previewedPrice.price,
+                deposit,
+                paymentOption: getPaymentOption(item.service, hasDeposit, selectedPaymentOption, depositSelected),
+            });
         }
     }
-    return buildLineItem(item.service, totalParticipants, item.lineItemId, selectedPaymentOption);
+    return buildLineItem(item.service, totalParticipants, item.lineItemId, selectedPaymentOption, depositSelected);
 }
-async function calculatePaymentDetails(pricingServiceSelections, totalParticipants, selectedPaymentOption) {
+async function calculatePaymentDetails(pricingServiceSelections, totalParticipants, selectedPaymentOption, depositSelected) {
     const data = pricingServiceSelections.map((selection) => ({
         ...selection,
         lineItemId: selection.lineItemId || (0, guid_js_1.generateLineItemId)(),
     }));
-    const lineItems = await Promise.all(data.map((item) => buildLineItemWithPreview(item, totalParticipants, selectedPaymentOption)));
+    const lineItems = await Promise.all(data.map((item) => buildLineItemWithPreview(item, totalParticipants, selectedPaymentOption, depositSelected)));
     const response = await (0, auto_sdk_ecom_totals_calculator_1.calculateTotals)({
         lineItems,
     });
@@ -209,7 +235,7 @@ exports.PaymentService = services_definitions_1.implementService.withConfig()(pa
     const errorSignal = signalsService.signal(null);
     const serviceOptionsSignal = signalsService.signal(config.serviceOptions || DEFAULT_SERVICE_OPTIONS);
     // Internal calculate function
-    const calculate = async (pricingServiceSelections, totalParticipants, selectedPaymentOption) => {
+    const calculate = async (pricingServiceSelections, totalParticipants, selectedPaymentOption, depositSelected) => {
         if (!pricingServiceSelections.length) {
             paymentDetailsSignal.set(null);
             return;
@@ -217,7 +243,7 @@ exports.PaymentService = services_definitions_1.implementService.withConfig()(pa
         isLoadingSignal.set(true);
         errorSignal.set(null);
         try {
-            const paymentDetails = await calculatePaymentDetails(pricingServiceSelections, totalParticipants, selectedPaymentOption);
+            const paymentDetails = await calculatePaymentDetails(pricingServiceSelections, totalParticipants, selectedPaymentOption, depositSelected);
             paymentDetailsSignal.set(paymentDetails);
         }
         catch (error) {
@@ -245,16 +271,17 @@ exports.PaymentService = services_definitions_1.implementService.withConfig()(pa
     // Mode 2: Lazy loading - pricingServiceSelections provided via internal config
     else if (config.pricingServiceSelections?.length) {
         serviceOptionsSignal.set(deriveServiceOptions(config.pricingServiceSelections));
-        void calculate(config.pricingServiceSelections, config.totalParticipants ?? 1, config.selectedPaymentOption);
+        void calculate(config.pricingServiceSelections, config.totalParticipants ?? 1, config.selectedPaymentOption, config.depositSelected);
     }
     // Mode 3: Reactive - observe BookingService signals (client-side only)
     else if (typeof window !== 'undefined' && bookingService) {
-        // Computed signal that changes when services, selected time slots, or
-        // the consumer-selected payment option change (not participants).
+        // Computed signal that changes when services, selected time slots, or the
+        // consumer's payment choices change (not participants).
         const servicesKey = signalsService.computed(() => {
             const selections = bookingService?.serviceSelections.get() || [];
             const timezone = bookingService?.timezone.get();
             const selectedPaymentOption = bookingService?.selectedPaymentOption.get();
+            const depositSelected = bookingService?.depositSelected.get();
             return JSON.stringify({
                 selections: selections.map((s) => ({
                     serviceId: s.service._id,
@@ -264,16 +291,18 @@ exports.PaymentService = services_definitions_1.implementService.withConfig()(pa
                 })),
                 timezone,
                 selectedPaymentOption,
+                depositSelected,
             });
         });
         signalsService.effect(() => {
-            // Subscribe to servicesKey to trigger effect when service, time
-            // slot, or selected payment option changes.
+            // Subscribe to servicesKey to trigger effect when service, time slot,
+            // or payment choices change.
             servicesKey.get();
             // Read current selections without subscribing (peek)
             const selections = bookingService?.serviceSelections.peek() || [];
             const timezone = bookingService?.timezone.peek();
             const selectedPaymentOption = bookingService?.selectedPaymentOption.peek();
+            const depositSelected = bookingService?.depositSelected.peek();
             // For single service mode, take the first selection
             const firstSelection = selections[0];
             const numParticipants = firstSelection?.totalParticipants || 1;
@@ -288,7 +317,7 @@ exports.PaymentService = services_definitions_1.implementService.withConfig()(pa
             if (pricingServiceSelections.length) {
                 serviceOptionsSignal.set(deriveServiceOptions(pricingServiceSelections));
             }
-            void calculate(pricingServiceSelections, numParticipants, selectedPaymentOption);
+            void calculate(pricingServiceSelections, numParticipants, selectedPaymentOption, depositSelected);
         });
     }
     return {
@@ -306,10 +335,12 @@ exports.PaymentService = services_definitions_1.implementService.withConfig()(pa
  * @param params.totalParticipants - Number of participants (default: 1)
  * @param params.selectedPaymentOption - Optional consumer-selected payment option;
  *   overrides the service-config heuristic on each line item's `paymentOption`.
+ * @param params.depositSelected - Optional deposit-vs-full-upfront choice; `false`
+ *   resolves a deposit service to full payment. Omit to keep the deposit default.
  */
 async function loadPaymentConfig(params) {
     try {
-        const { pricingServiceSelections, totalParticipants = 1, selectedPaymentOption, } = params;
+        const { pricingServiceSelections, totalParticipants = 1, selectedPaymentOption, depositSelected, } = params;
         if (!pricingServiceSelections.length) {
             return {
                 type: 'success',
@@ -319,7 +350,7 @@ async function loadPaymentConfig(params) {
                 },
             };
         }
-        const paymentDetails = await calculatePaymentDetails(pricingServiceSelections, totalParticipants, selectedPaymentOption);
+        const paymentDetails = await calculatePaymentDetails(pricingServiceSelections, totalParticipants, selectedPaymentOption, depositSelected);
         return {
             type: 'success',
             config: {

package/cjs/dist/services/service/service.js

@@ -90,7 +90,7 @@ exports.ServiceService = services_definitions_1.implementService.withConfig()(ex
         const initialService = config.service || {};
         serviceSignal = signalsService.signal(initialService);
     }
-    const isLoadingSignal = signalsService.signal(!!config.serviceId);
+    const isLoadingSignal = signalsService.signal(!config.service && (!!config.serviceId || !!config.serviceSlug));
     const errorSignal = signalsService.signal(null);
     // Default appId to BOOKING_APP_ID if not provided
     const appId = config.appId ?? constants_js_1.BOOKING_APP_ID;

package/cjs/dist/services/servicePayment.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Shared helpers for reading payment configuration off a Service entity.
+ *
+ * `payment.fixed` / `varied` / `custom` are a `@oneof` in the services SDK, so
+ * only one is ever populated — reading `fixed` then `varied` covers both FIXED
+ * and VARIED rate types.
+ *
+ * A percentage deposit stores no amount anywhere on the entity; the server
+ * resolves it when the customer books. Hence the split between
+ * {@link requiresDeposit} ("takes a deposit?") and {@link hasDeposit} ("has an
+ * amount?") — a percentage deposit answers `true` and `false` respectively.
+ *
+ * @module Services/ServicePayment
+ */
+import type { Service } from '@wix/auto_sdk_bookings_services';
+/**
+ * Whether the service takes a deposit. An explicit `options.deposit` wins; when
+ * the flag is absent a configured amount still counts, so a service that sets one
+ * without the flag keeps reporting a deposit.
+ */
+export declare function requiresDeposit(service?: Service): boolean;
+/** The deposit amount, if one is configured as a fixed amount. */
+export declare function getDepositValue(service?: Service): string | undefined;
+export declare function hasDeposit(service?: Service): boolean;
+/** Meaningful only alongside `hasDeposit`. */
+export declare function isFullUpfrontPaymentAllowed(service?: Service): boolean;

package/cjs/dist/services/servicePayment.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Shared helpers for reading payment configuration off a Service entity.
+ *
+ * `payment.fixed` / `varied` / `custom` are a `@oneof` in the services SDK, so
+ * only one is ever populated — reading `fixed` then `varied` covers both FIXED
+ * and VARIED rate types.
+ *
+ * A percentage deposit stores no amount anywhere on the entity; the server
+ * resolves it when the customer books. Hence the split between
+ * {@link requiresDeposit} ("takes a deposit?") and {@link hasDeposit} ("has an
+ * amount?") — a percentage deposit answers `true` and `false` respectively.
+ *
+ * @module Services/ServicePayment
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requiresDeposit = requiresDeposit;
+exports.getDepositValue = getDepositValue;
+exports.hasDeposit = hasDeposit;
+exports.isFullUpfrontPaymentAllowed = isFullUpfrontPaymentAllowed;
+/**
+ * Whether the service takes a deposit. An explicit `options.deposit` wins; when
+ * the flag is absent a configured amount still counts, so a service that sets one
+ * without the flag keeps reporting a deposit.
+ */
+function requiresDeposit(service) {
+    return service?.payment?.options?.deposit ?? hasDeposit(service);
+}
+/** The deposit amount, if one is configured as a fixed amount. */
+function getDepositValue(service) {
+    const payment = service?.payment;
+    return (payment?.fixed?.deposit?.value ??
+        payment?.varied?.deposit?.value ??
+        payment?.fixed?.depositDetails?.amount?.value ??
+        payment?.varied?.depositDetails?.amount?.value);
+}
+function hasDeposit(service) {
+    const value = getDepositValue(service);
+    return !!value && Number(value) > 0;
+}
+/** Meaningful only alongside `hasDeposit`. */
+function isFullUpfrontPaymentAllowed(service) {
+    const payment = service?.payment;
+    return !!(payment?.fixed?.fullUpfrontPaymentAllowed ??
+        payment?.varied?.fullUpfrontPaymentAllowed);
+}

package/cjs/dist/utils/money.d.ts

@@ -5,13 +5,19 @@ import type { MoneyData } from '@wix/headless-components/react';
 /**
  * Converts SDK Money format to MoneyData format
  *
+ * The original SDK value is validated as a whole (values that are not fully
+ * numeric and finite, like `"12.34xyz"`, return `null`) but kept as-is, so
+ * string amounts reach `Money` with full decimal precision instead of being
+ * routed through floating point. Compare amounts numerically with
+ * `Number(money.amount)`.
+ *
  * @param sdkMoney - The SDK money object with value, currency, and optional formattedValue
  * @returns MoneyData object with amount and currency, or null if conversion fails
  *
  * @example
  * ```ts
  * const money = convertToMoneyData({ value: "25.50", currency: "USD" });
- * // Returns: { amount: 25.50, currency: "USD" }
+ * // Returns: { amount: "25.50", currency: "USD" }
  * ```
  */
 export declare function convertToMoneyData(sdkMoney: {
@@ -21,7 +27,11 @@ export declare function convertToMoneyData(sdkMoney: {
 } | undefined): MoneyData | null;
 /**
  * Converts ecom MultiCurrencyPrice format to MoneyData format
- * MultiCurrencyPrice uses 'amount' as string, while MoneyData uses 'amount' as number
+ *
+ * The string amount is validated as a whole (values that are not fully
+ * numeric and finite, like `"12.34xyz"`, return `null`) but kept as-is, so
+ * it reaches `Money` with full decimal precision. Compare amounts
+ * numerically with `Number(money.amount)`.
  *
  * @param price - The MultiCurrencyPrice object with amount as string
  * @param currency - The currency code (from response level)

package/cjs/dist/utils/money.js

@@ -5,16 +5,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertToMoneyData = convertToMoneyData;
 exports.convertMultiCurrencyPriceToMoneyData = convertMultiCurrencyPriceToMoneyData;
+// Number() (unlike parseFloat) rejects strings with trailing garbage like
+// "12.34xyz", but treats empty/whitespace-only strings as 0 — reject those
+// separately so invalid values return null instead of reaching the formatter.
+function toNumericAmount(value) {
+    if (typeof value === 'string') {
+        return value.trim() === '' ? NaN : Number(value);
+    }
+    return value;
+}
 /**
  * Converts SDK Money format to MoneyData format
  *
+ * The original SDK value is validated as a whole (values that are not fully
+ * numeric and finite, like `"12.34xyz"`, return `null`) but kept as-is, so
+ * string amounts reach `Money` with full decimal precision instead of being
+ * routed through floating point. Compare amounts numerically with
+ * `Number(money.amount)`.
+ *
  * @param sdkMoney - The SDK money object with value, currency, and optional formattedValue
  * @returns MoneyData object with amount and currency, or null if conversion fails
  *
  * @example
  * ```ts
  * const money = convertToMoneyData({ value: "25.50", currency: "USD" });
- * // Returns: { amount: 25.50, currency: "USD" }
+ * // Returns: { amount: "25.50", currency: "USD" }
  * ```
  */
 function convertToMoneyData(sdkMoney) {
@@ -22,23 +37,20 @@ function convertToMoneyData(sdkMoney) {
         return null;
     const priceValue = sdkMoney.value;
     const currency = sdkMoney.currency || 'USD';
-    // Convert price value to number
-    let amount = undefined;
-    if (typeof priceValue === 'string') {
-        const parsed = parseFloat(priceValue);
-        amount = !isNaN(parsed) ? parsed : undefined;
-    }
-    else if (typeof priceValue === 'number') {
-        amount = priceValue;
-    }
-    if (amount !== undefined && !isNaN(amount) && amount >= 0) {
-        return { amount, currency };
-    }
-    return null;
+    if (priceValue === undefined)
+        return null;
+    const parsed = toNumericAmount(priceValue);
+    if (!Number.isFinite(parsed) || parsed < 0)
+        return null;
+    return { amount: priceValue, currency };
 }
 /**
  * Converts ecom MultiCurrencyPrice format to MoneyData format
- * MultiCurrencyPrice uses 'amount' as string, while MoneyData uses 'amount' as number
+ *
+ * The string amount is validated as a whole (values that are not fully
+ * numeric and finite, like `"12.34xyz"`, return `null`) but kept as-is, so
+ * it reaches `Money` with full decimal precision. Compare amounts
+ * numerically with `Number(money.amount)`.
  *
  * @param price - The MultiCurrencyPrice object with amount as string
  * @param currency - The currency code (from response level)
@@ -47,8 +59,8 @@ function convertToMoneyData(sdkMoney) {
 function convertMultiCurrencyPriceToMoneyData(price, currency) {
     if (!price?.amount)
         return null;
-    const parsed = parseFloat(price.amount);
-    if (isNaN(parsed) || parsed < 0)
+    const parsed = toNumericAmount(price.amount);
+    if (!Number.isFinite(parsed) || parsed < 0)
         return null;
-    return { amount: parsed, currency };
+    return { amount: price.amount, currency };
 }

package/dist/__mocks__/booking/booking-client-service.js

@@ -24,18 +24,20 @@ export function createMockSignalsService() {
     };
 }
 export function createMockBookingService(config = {}) {
-    const { serviceSelections = [], location = null, timezone = 'UTC', formSubmission = null, selectedPaymentOption, } = config;
+    const { serviceSelections = [], location = null, timezone = 'UTC', formSubmission = null, selectedPaymentOption, depositSelected, } = config;
     const serviceSelectionsSignal = mockSignal(serviceSelections);
     const locationSignal = mockSignal(location);
     const timezoneSignal = mockSignal(timezone);
     const formSubmissionSignal = mockSignal(formSubmission);
     const selectedPaymentOptionSignal = mockSignal(selectedPaymentOption);
+    const depositSelectedSignal = mockSignal(depositSelected);
     return {
         serviceSelections: serviceSelectionsSignal,
         location: locationSignal,
         timezone: timezoneSignal,
         formSubmission: formSubmissionSignal,
         selectedPaymentOption: selectedPaymentOptionSignal,
+        depositSelected: depositSelectedSignal,
         actions: {
             updateItem: vi.fn(),
             setItem: vi.fn(),
@@ -51,6 +53,7 @@ export function createMockBookingService(config = {}) {
             setFormSubmission: vi.fn(),
             clearFormSubmission: vi.fn(),
             setSelectedPaymentOption: vi.fn(),
+            setDepositSelected: vi.fn(),
             setAllDay: vi.fn(),
             clearAll: vi.fn(),
             book: vi.fn(),

package/dist/__mocks__/services/services-mocks.d.ts

@@ -158,6 +158,19 @@ export declare function createLargeStaffMemberList(count: number): StaffMember[]
  * Mock service with deposit configured
  */
 export declare const mockServiceWithDeposit: Service;
+/** Deposit set as a fixed amount under `depositDetails`, the newer field. */
+export declare const mockServiceDepositDetailsAmount: Service;
+/** Percentage deposit: `options.deposit` set, no amount anywhere on the entity. */
+export declare const mockServicePercentageDeposit: Service;
+/**
+ * Mock service with a deposit that may also be paid in full upfront — the only
+ * configuration where `booking.depositSelected` may be `false`.
+ */
+export declare const mockServiceWithDepositFullUpfront: Service;
+/**
+ * Mock VARIED-rate service with a deposit (both under `payment.varied`).
+ */
+export declare const mockServiceVariedWithDeposit: Service;
 /**
  * Mock service with in-person payment option
  */

package/dist/__mocks__/services/services-mocks.js

@@ -535,6 +535,97 @@ export const mockServiceWithDeposit = {
         },
     },
 };
+/** Deposit set as a fixed amount under `depositDetails`, the newer field. */
+export const mockServiceDepositDetailsAmount = {
+    ...mockService,
+    _id: 'test-service-deposit-details-amount',
+    name: 'Deposit Details Amount Service',
+    payment: {
+        rateType: RateType.FIXED,
+        fixed: {
+            price: {
+                value: '100.00',
+                currency: 'USD',
+            },
+            depositDetails: {
+                amount: {
+                    value: '25.00',
+                    currency: 'USD',
+                },
+            },
+        },
+        options: {
+            online: true,
+            deposit: true,
+        },
+    },
+};
+/** Percentage deposit: `options.deposit` set, no amount anywhere on the entity. */
+export const mockServicePercentageDeposit = {
+    ...mockService,
+    _id: 'test-service-percentage-deposit',
+    name: 'Percentage Deposit Service',
+    payment: {
+        rateType: RateType.FIXED,
+        fixed: {
+            price: {
+                value: '10',
+                currency: 'USD',
+            },
+            fullUpfrontPaymentAllowed: true,
+        },
+        options: {
+            online: true,
+            inPerson: false,
+            deposit: true,
+        },
+    },
+};
+/**
+ * Mock service with a deposit that may also be paid in full upfront — the only
+ * configuration where `booking.depositSelected` may be `false`.
+ */
+export const mockServiceWithDepositFullUpfront = {
+    ...mockService,
+    _id: 'test-service-deposit-full-upfront',
+    name: 'Service with Deposit and Full Upfront Allowed',
+    payment: {
+        rateType: RateType.FIXED,
+        fixed: {
+            price: {
+                value: '100.00',
+                currency: 'USD',
+            },
+            deposit: {
+                value: '30.00',
+                currency: 'USD',
+            },
+            fullUpfrontPaymentAllowed: true,
+        },
+    },
+};
+/**
+ * Mock VARIED-rate service with a deposit (both under `payment.varied`).
+ */
+export const mockServiceVariedWithDeposit = {
+    ...mockService,
+    _id: 'test-service-varied-deposit',
+    name: 'Varied Service with Deposit',
+    payment: {
+        rateType: RateType.VARIED,
+        varied: {
+            defaultPrice: {
+                value: '80.00',
+                currency: 'USD',
+            },
+            deposit: {
+                value: '20.00',
+                currency: 'USD',
+            },
+            fullUpfrontPaymentAllowed: true,
+        },
+    },
+};
 /**
  * Mock service with in-person payment option
  */