@wix/headless-bookings 0.0.14 → 0.0.16

package/dist/services/booking/booking.js

@@ -9,7 +9,7 @@ import { SignalsServiceDefinition, } from '@wix/services-definitions/core-servic
 // Types
 // ============================================================================
 /**
- * Generates a unique instance ID for service selections
+ * Generates a unique instance ID for booking items
  */
 function generateInstanceId() {
     return crypto.randomUUID();
@@ -39,8 +39,8 @@ export const BookingServiceDefinition = defineService('booking');
  *
  * // In any page - access booking data
  * <Booking.Data>
- *   {({ services, timeSlot, location, formValues, actions }) => (
- *     <div>{services.map(s => s.service.name).join(', ')}</div>
+ *   {({ bookingItems, location, formValues, actions }) => (
+ *     <div>{bookingItems.map(item => item.service.name).join(', ')}</div>
  *   )}
  * </Booking.Data>
  * ```
@@ -48,67 +48,93 @@ export const BookingServiceDefinition = defineService('booking');
 export const BookingService = implementService.withConfig()(BookingServiceDefinition, ({ getService, config }) => {
     const signalsService = getService(SignalsServiceDefinition);
     // Initialize signals with config values
-    // Ensure all initial booking selections have instanceIds
-    const initialSelectionsWithIds = (config.initialBookingSelections || []).map((s) => ({
-        ...s,
-        instanceId: s.instanceId || generateInstanceId(),
+    // Ensure all initial booking items have instanceIds
+    const initialItemsWithIds = (config.bookingItems || []).map((item) => ({
+        ...item,
+        instanceId: item.instanceId || generateInstanceId(),
     }));
-    const bookingSelectionsSignal = signalsService.signal(initialSelectionsWithIds);
-    const timeSlotSignal = signalsService.signal(config.initialTimeSlot || null);
-    // Location is derived internally - initialize as null
-    const locationSignal = signalsService.signal(null);
-    const formValuesSignal = signalsService.signal(config.initialFormValues || null);
+    const bookingItemsSignal = signalsService.signal(initialItemsWithIds);
+    const locationSignal = signalsService.signal(config.location || null);
+    const formValuesSignal = signalsService.signal(config.formValues || null);
+    const numberOfParticipantsSignal = signalsService.signal(config.numberOfParticipants ?? 1);
     // ========================================================================
     // Actions Implementation
     // ========================================================================
     const actions = {
-        // Services actions
-        setService(service) {
+        // Item management actions
+        setItem(item) {
             const instanceId = generateInstanceId();
-            const newSelection = {
-                ...service,
+            const newItem = {
+                ...item,
                 instanceId,
             };
-            bookingSelectionsSignal.set([newSelection]);
+            bookingItemsSignal.set([newItem]);
             return instanceId;
         },
-        addService(service) {
+        addItem(item) {
             const instanceId = generateInstanceId();
-            const current = bookingSelectionsSignal.get();
-            const newSelection = {
-                ...service,
+            const current = bookingItemsSignal.get();
+            const newItem = {
+                ...item,
                 instanceId,
             };
-            bookingSelectionsSignal.set([...current, newSelection]);
+            bookingItemsSignal.set([...current, newItem]);
             return instanceId;
         },
-        updateBookingSelection(updates, instanceId) {
-            const current = bookingSelectionsSignal.get();
-            // If no instanceId provided, update the first selection (index 0)
+        updateItem(updates, instanceId) {
+            const current = bookingItemsSignal.get();
+            // If no instanceId provided, update the first item (index 0)
             const targetId = instanceId ?? current[0]?.instanceId;
-            const updated = current.map((s) => s.instanceId === targetId ? { ...s, ...updates } : s);
-            bookingSelectionsSignal.set(updated);
+            const updated = current.map((item) => item.instanceId === targetId ? { ...item, ...updates } : item);
+            bookingItemsSignal.set(updated);
         },
-        removeBookingSelection(instanceId) {
-            const current = bookingSelectionsSignal.get();
+        removeItem(instanceId) {
+            const current = bookingItemsSignal.get();
             if (!instanceId) {
-                // Remove first selection if no instanceId provided
-                bookingSelectionsSignal.set(current.slice(1));
+                // Remove first item if no instanceId provided
+                bookingItemsSignal.set(current.slice(1));
             }
             else {
-                const filtered = current.filter((s) => s.instanceId !== instanceId);
-                bookingSelectionsSignal.set(filtered);
+                const filtered = current.filter((item) => item.instanceId !== instanceId);
+                bookingItemsSignal.set(filtered);
             }
         },
-        clearServices() {
-            bookingSelectionsSignal.set([]);
+        clearItems() {
+            bookingItemsSignal.set([]);
         },
-        // Time Slot actions
-        setTimeSlot(slot) {
-            timeSlotSignal.set(slot);
+        // Resource helpers
+        setResourceById(resourceId, resource, instanceId) {
+            const current = bookingItemsSignal.get();
+            // If no instanceId provided, use the first item
+            const targetId = instanceId ?? current[0]?.instanceId;
+            if (!targetId)
+                return;
+            const updated = current.map((item) => {
+                if (item.instanceId !== targetId)
+                    return item;
+                // Find and replace resource by ID, or add if not found
+                const existingIndex = item.resources.findIndex((r) => r._id === resourceId);
+                const newResources = [...item.resources];
+                if (existingIndex >= 0) {
+                    newResources[existingIndex] = resource;
+                }
+                else {
+                    newResources.push(resource);
+                }
+                return { ...item, resources: newResources };
+            });
+            bookingItemsSignal.set(updated);
         },
-        clearTimeSlot() {
-            timeSlotSignal.set(null);
+        getResourceById(resourceId, instanceId) {
+            const current = bookingItemsSignal.get();
+            // If no instanceId provided, use the first item
+            const targetId = instanceId ?? current[0]?.instanceId;
+            if (!targetId)
+                return undefined;
+            const targetItem = current.find((item) => item.instanceId === targetId);
+            if (!targetItem)
+                return undefined;
+            return targetItem.resources.find((r) => r._id === resourceId);
         },
         // Location actions
         setLocation(location) {
@@ -124,19 +150,23 @@ export const BookingService = implementService.withConfig()(BookingServiceDefini
         clearFormValues() {
             formValuesSignal.set(null);
         },
+        // Number of Participants actions
+        setNumberOfParticipants(count) {
+            numberOfParticipantsSignal.set(count);
+        },
         // Clear all
         clearAll() {
-            bookingSelectionsSignal.set([]);
-            timeSlotSignal.set(null);
+            bookingItemsSignal.set([]);
             locationSignal.set(null);
             formValuesSignal.set(null);
+            numberOfParticipantsSignal.set(1);
         },
     };
     return {
-        bookingSelections: bookingSelectionsSignal,
-        timeSlot: timeSlotSignal,
+        bookingItems: bookingItemsSignal,
         location: locationSignal,
         formValues: formValuesSignal,
+        numberOfParticipants: numberOfParticipantsSignal,
         actions,
     };
 });

package/dist/services/index.d.ts

@@ -3,6 +3,6 @@
  * Main export file for all service definitions and implementations
  */
 export { ServiceService, ServiceServiceDefinition, type ServiceServiceAPI, type ServiceServiceConfig, type ServiceActions, type ServicePaymentData, loadServiceServiceInitialData, type SuccessServiceServiceConfigResult, type NotFoundServiceServiceConfigResult, } from './service/service.js';
-export { BookingService, BookingServiceDefinition, type BookingServiceConfig, type BookingSelection, type Location, type BookingServiceActions, } from './booking/booking.js';
+export { BookingService, BookingServiceDefinition, type BookingServiceConfig, type Location, type BookingServiceActions, } from './booking/booking.js';
 export { TimeSlotListService, TimeSlotListServiceDefinition, ViewMode, loadTimeSlotListConfig, type TimeSlotListServiceAPI, type TimeSlotListServiceActions, type TimeSlotListServiceConfig, type SlotSelection, type LoadTimeSlotListConfigOptions, type LoadTimeSlotListConfigResult, } from './time-slot-list/index.js';
 export { ServiceListService, ServiceListServiceDefinition, type ServiceListServiceAPI, type ServiceListServiceConfig, type ServiceListActions, type QueryOptions, loadServiceListServiceInitialData, type SuccessServiceListServiceConfigResult, type ErrorServiceListServiceConfigResult, } from './service-list/service-list.js';

package/dist/services/service/service.js

@@ -81,8 +81,8 @@ export const ServiceService = implementService.withConfig()(ServiceServiceDefini
         const currentService = serviceSignal.get();
         if (!currentService._id)
             return false;
-        const selections = bookingService.bookingSelections.get();
-        return selections.some((selection) => selection.service._id === currentService._id);
+        const bookingItems = bookingService.bookingItems.get();
+        return bookingItems.some(({ service }) => service._id === currentService._id);
     });
     // requiresAvailability signal - true for APPOINTMENT and CLASS types
     const requiresAvailabilitySignal = signalsService.computed(() => {
@@ -185,25 +185,28 @@ export const ServiceService = implementService.withConfig()(ServiceServiceDefini
             if (!bookableSignal.get() || !bookingService)
                 return;
             const currentService = serviceSignal.get();
-            bookingService.actions.setService({ service: currentService });
+            bookingService.actions.updateItem({ service: currentService });
         },
         add: () => {
             if (!bookableSignal.get() || !bookingService)
                 return;
             const currentService = serviceSignal.get();
-            bookingService.actions.addService({ service: currentService });
+            bookingService.actions.addItem({
+                service: currentService,
+                resources: [],
+            });
         },
         remove: () => {
             if (!bookableSignal.get() || !bookingService)
                 return;
             const currentService = serviceSignal.get();
             // Remove all instances of this service (by serviceId)
-            const selections = bookingService.bookingSelections.get();
-            const instancesToRemove = selections
+            const bookingItems = bookingService.bookingItems.get();
+            const instancesToRemove = bookingItems
                 .filter((s) => s.service._id === currentService._id)
                 .map((s) => s.instanceId);
             instancesToRemove.forEach((instanceId) => {
-                bookingService.actions.removeBookingSelection(instanceId);
+                bookingService.actions.removeItem(instanceId);
             });
         },
     };

package/dist/services/time-slot-list/time-slot-list.js

@@ -6,7 +6,7 @@ import { implementService } from '@wix/services-definitions';
 import { SignalsServiceDefinition } from '@wix/services-definitions/core-services/signals';
 import { TimeSlotListServiceDefinition, ViewMode, } from './time-slot-list.def.js';
 import { fetchAvailability } from '../../api/time-slot-list/index.js';
-import { BookingServiceDefinition } from '../booking/booking.js';
+import { BookingServiceDefinition, } from '../booking/booking.js';
 // ============================================================================
 // Helpers
 // ============================================================================
@@ -79,7 +79,7 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
     const getServices = () => {
         if (config.services?.length)
             return config.services;
-        return bookingService.bookingSelections.get().map((s) => s.service);
+        return bookingService.bookingItems.get().map((s) => s.service);
     };
     /**
      * Fetch time slots from API
@@ -115,82 +115,139 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
     };
     /**
      * Action: Select a time slot
-     * Only updates booking service if there's exactly one location and one resource
-     * Otherwise, user must select location/resource before booking
+     * Auto-selects location/staff based on availability:
+     * - One location + one staff → auto-select both
+     * - One location + many staff → auto-select location only
+     * - Many locations + one staff → auto-select staff only
+     * - Many locations + many staff → don't auto-select anything
      */
     const selectSlot = (slot) => {
         const currentSelection = selectionSignal.get();
         if (currentSelection?.slot?.id === slot.id)
             return;
+        const timeSlot = {
+            startDate: slot.localStartDate,
+            endDate: slot.localEndDate,
+            totalCapacity: slot.totalCapacity ?? undefined,
+            remainingCapacity: slot.remainingCapacity ?? undefined,
+            scheduleId: slot.scheduleId ?? undefined,
+            eventInfo: slot.eventInfo ?? undefined,
+        };
         const hasOneLocation = slot.staffByLocation.length === 1;
-        const hasOneResource = hasOneLocation && slot.staffByLocation[0].staffMembers.length === 1;
-        if (hasOneLocation && hasOneResource) {
-            const originalSlot = slot.originalSlots[0];
-            const { location, staffMembers } = slot.staffByLocation[0];
-            const staffMemberId = staffMembers[0].id;
-            selectionSignal.set({
-                slot,
-                locationId: location.id,
-                staffMemberId,
-            });
-            bookingService.actions.setTimeSlot(originalSlot);
-            bookingService.actions.setLocation({
-                id: location.id,
-                name: location.name,
-            });
-            bookingService.actions.updateBookingSelection({
-                staff: {
-                    _id: staffMemberId,
-                    name: staffMembers[0].name,
-                },
+        // Collect all unique staff members across all locations
+        const allStaffMembers = slot.staffByLocation.flatMap((loc) => loc.staffMembers);
+        const uniqueStaffIds = new Set(allStaffMembers.map((s) => s.id));
+        const hasOneStaff = uniqueStaffIds.size === 1;
+        // Determine what to auto-select
+        let locationId = null;
+        let staffMemberId = null;
+        if (hasOneLocation) {
+            const { location } = slot.staffByLocation[0];
+            locationId = location.id;
+            bookingService.actions.setLocation(location);
+        }
+        else {
+            bookingService.actions.clearLocation();
+        }
+        if (hasOneStaff) {
+            const staffMember = allStaffMembers[0];
+            staffMemberId = staffMember.id;
+            bookingService.actions.updateItem({
+                timeSlot,
+                resources: [
+                    {
+                        _id: staffMemberId,
+                        name: staffMember.name,
+                    },
+                ],
             });
         }
         else {
-            selectionSignal.set({
-                slot,
-                locationId: null,
-                staffMemberId: null,
+            bookingService.actions.updateItem({
+                timeSlot,
+                resources: [],
             });
         }
+        selectionSignal.set({
+            slot,
+            locationId,
+            staffMemberId,
+        });
     };
     /**
      * Action: Select a location for the current slot
-     * Updates the booking service with the correct original slot for this location
+     * Updates the booking service with the location
+     * If the location has only one staff member, auto-selects that staff member too
      */
     const selectLocation = (locationId) => {
         const currentSelections = selectionSignal.get();
         if (!currentSelections?.slot)
             return;
-        selectionSignal.set({ ...currentSelections, locationId });
-        const location = currentSelections.slot.originalSlots.find((s) => s.location?._id === locationId)?.location;
-        if (location) {
-            bookingService.actions.setLocation({
-                id: location._id,
-                name: location.name,
+        const slot = currentSelections.slot;
+        const locationEntry = slot.staffByLocation.find((loc) => loc.location.id === locationId);
+        if (!locationEntry)
+            return;
+        const { location, staffMembers } = locationEntry;
+        bookingService.actions.setLocation(location);
+        // If this location has only one staff member, auto-select them
+        const hasOneStaff = staffMembers.length === 1;
+        if (hasOneStaff) {
+            const staffMember = staffMembers[0];
+            selectionSignal.set({
+                ...currentSelections,
+                locationId,
+                staffMemberId: staffMember.id,
             });
+            bookingService.actions.updateItem({
+                resources: [
+                    {
+                        _id: staffMember.id,
+                        name: staffMember.name,
+                    },
+                ],
+            });
+        }
+        else {
+            selectionSignal.set({ ...currentSelections, locationId });
         }
     };
     /**
      * Action: Select a staff member for the current slot
-     * Updates the booking service with the selected resource for the slot's service
+     * Updates the booking service with the selected resource
+     * If the staff member is only available at one location, auto-selects that location too
      */
     const selectStaffMember = (staffMemberId) => {
         const currentSelections = selectionSignal.get();
         if (!currentSelections?.slot)
             return;
-        selectionSignal.set({ ...currentSelections, staffMemberId });
         const slot = currentSelections.slot;
-        // Find the resource info from original slots
-        for (const originalSlot of slot.originalSlots) {
-            for (const resourceGroup of originalSlot.availableResources || []) {
-                const staff = resourceGroup.resources?.find((r) => r._id === staffMemberId);
-                if (staff) {
-                    bookingService.actions.updateBookingSelection({
-                        staff,
-                    });
-                    return;
-                }
-            }
+        // Find all locations that have this staff member
+        const locationsWithThisStaff = slot.staffByLocation.filter((loc) => loc.staffMembers.some((s) => s.id === staffMemberId));
+        // Find the staff member info
+        const staffMember = locationsWithThisStaff[0]?.staffMembers.find((s) => s.id === staffMemberId);
+        if (!staffMember)
+            return;
+        bookingService.actions.updateItem({
+            resources: [
+                {
+                    _id: staffMember.id,
+                    name: staffMember.name,
+                },
+            ],
+        });
+        // If this staff member is only at one location, auto-select that location
+        const hasOneLocation = locationsWithThisStaff.length === 1;
+        if (hasOneLocation) {
+            const location = locationsWithThisStaff[0].location;
+            selectionSignal.set({
+                ...currentSelections,
+                staffMemberId,
+                locationId: location.id,
+            });
+            bookingService.actions.setLocation(location);
+        }
+        else {
+            selectionSignal.set({ ...currentSelections, staffMemberId });
         }
     };
     /**
@@ -206,15 +263,11 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
             locationId: null,
             staffMemberId: null,
         });
-        // Clear location in booking service
+        // Clear selections in booking service
         bookingService.actions.clearLocation();
-        // Clear resources (staff) in booking service
-        const serviceId = currentSelection.slot.serviceId;
-        if (serviceId) {
-            bookingService.actions.updateBookingSelection({
-                staff: undefined,
-            });
-        }
+        bookingService.actions.updateItem({
+            resources: [],
+        });
     };
     /**
      * Action: Load more slots (pagination)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/headless-bookings",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -68,5 +68,5 @@
       "groupId": "com.wixpress.headless-components"
     }
   },
-  "falconPackageHash": "e3681a6dd045861d1cb7cefbdc04f1ad9e3eb62094bb6a8970b90cd2"
+  "falconPackageHash": "9e70aba1e4a39f28a7d02fca86dcf92c71014635fbfc9208bf1569f4"
 }