@wix/headless-bookings 0.0.15 → 0.0.17

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
 // ============================================================================
@@ -68,7 +68,8 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
     const isLoadingSignal = signalsService.signal(false);
     const errorSignal = signalsService.signal(null);
     const hasMoreSignal = signalsService.signal(false);
-    const viewModeSignal = signalsService.signal(config.viewMode || ViewMode.CLASSIC);
+    // Internal only - viewMode is auto-detected based on service types
+    const viewModeSignal = signalsService.signal(ViewMode.CLASSIC);
     const startDateSignal = signalsService.signal(config.startDate || currentDate);
     const endDateSignal = signalsService.signal(config.endDate || getDefaultEndDate());
     const timezoneSignal = signalsService.signal(config.timezone ?? getClientTimezone());
@@ -79,7 +80,29 @@ 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);
+    };
+    /**
+     * Helper: Get filters from config or BookingService
+     */
+    const getFilters = () => {
+        // Get BookingService selections (these take priority)
+        const location = bookingService.location.get();
+        const selections = bookingService.bookingItems.get();
+        const selectedStaffMemberIds = selections
+            .map(({ resources }) => resources.map((r) => r._id))
+            .flat();
+        const selectedLocation = location ? { _id: location.id } : null;
+        // Merge config filters with BookingService selections (selections win)
+        return {
+            ...config.filters,
+            locations: selectedLocation
+                ? [selectedLocation]
+                : config.filters?.locations,
+            staffMemberIds: selectedStaffMemberIds.length
+                ? selectedStaffMemberIds
+                : config.filters?.staffMemberIds,
+        };
     };
     /**
      * Fetch time slots from API
@@ -87,6 +110,7 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
      */
     const fetchTimeSlots = async () => {
         const selectedServices = getServices();
+        const filters = getFilters();
         isLoadingSignal.set(true);
         errorSignal.set(null);
         cursorSignal.set(undefined);
@@ -97,6 +121,7 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
                 toLocalDate: toLocalDateString(endDateSignal.get()),
                 timeZone: timezoneSignal.get(),
                 viewMode: viewModeSignal.get(),
+                ...filters,
             });
             timeSlotsSignal.set(response.timeSlots);
             const nextCursor = response.cursorPagingMetadata?.cursors?.next ?? undefined;
@@ -115,82 +140,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 +288,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)
@@ -226,6 +304,7 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
         const selectedServices = getServices();
         if (selectedServices.length === 0)
             return;
+        const filters = getFilters();
         isLoadingSignal.set(true);
         try {
             const response = await fetchAvailability({
@@ -235,6 +314,7 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
                 timeZone: timezoneSignal.get(),
                 cursorPaging: { cursor },
                 viewMode: viewModeSignal.get(),
+                ...filters,
             });
             // API returns grouped slots, merge with existing
             const existing = timeSlotsSignal.get();
@@ -257,6 +337,12 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
      * Action: Update date range and refetch slots
      */
     const setDateRange = (newStartDate, newEndDate) => {
+        const currentStartDate = startDateSignal.get();
+        const currentEndDate = endDateSignal.get();
+        if (currentStartDate.getTime() === newStartDate.getTime() &&
+            currentEndDate.getTime() === newEndDate.getTime()) {
+            return;
+        }
         startDateSignal.set(newStartDate);
         endDateSignal.set(newEndDate);
         fetchTimeSlots();
@@ -280,8 +366,7 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
         isLoading: isLoadingSignal,
         error: errorSignal,
         hasMore: hasMoreSignal,
-        // Configuration Signals
-        viewMode: viewModeSignal,
+        // Configuration Signals (viewMode is internal only)
         startDate: startDateSignal,
         endDate: endDateSignal,
         timezone: timezoneSignal,
@@ -322,23 +407,19 @@ export async function loadTimeSlotListConfig(options) {
     const now = new Date();
     const startDate = options.startDate || now;
     const endDate = options.endDate || getDefaultEndDate();
-    const viewMode = options.viewMode || ViewMode.CLASSIC;
-    // check for location and staff in config
     try {
         const response = await fetchAvailability({
             services: options.services || [],
             fromLocalDate: toLocalDateString(startDate),
             toLocalDate: toLocalDateString(endDate),
             timeZone: options.timezone ?? getClientTimezone(),
-            viewMode,
+            ...options.filters,
         });
         const config = {
-            services: options.services,
+            ...options,
             timeSlots: response.timeSlots || [],
             startDate,
             endDate,
-            timezone: options.timezone,
-            viewMode,
         };
         return { type: 'success', config };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/headless-bookings",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -33,6 +33,7 @@
     }
   },
   "dependencies": {
+    "@wix/auto_sdk_bookings_event-time-slots": "^1.0.64",
     "@wix/bookings": "^1.0.122",
     "@wix/form-public": "^0.64.0",
     "@wix/headless-media": "0.0.18",
@@ -68,5 +69,5 @@
       "groupId": "com.wixpress.headless-components"
     }
   },
-  "falconPackageHash": "d56b9bfa88501c3f0e6edec7314578de67940d2a7e425c0c34fa3c3c"
+  "falconPackageHash": "8c910b633cde19227cb0209fec691701a57a7e53b577ee76971bfa2a"
 }