@wix/headless-bookings 0.0.27 → 0.0.29

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

@@ -10,37 +10,11 @@ import { BookingServiceDefinition, ANY_STAFF_MEMBER_ID, } from '../booking/booki
 // ============================================================================
 // Helpers
 // ============================================================================
-function getDefaultEndDate() {
-    return new Date(Date.now() + 7 * 24 * 60 * 60 * 1000);
-}
 function getClientTimezone() {
     return typeof Intl !== 'undefined'
         ? Intl.DateTimeFormat().resolvedOptions().timeZone
         : undefined;
 }
-/**
- * Merges new grouped slots with existing ones
- * Slots with the same start time are merged
- */
-function mergeGroupedSlots(existing, newSlots) {
-    const mergedMap = new Map();
-    for (const slot of existing) {
-        mergedMap.set(slot.localStartDate, slot);
-    }
-    for (const newSlot of newSlots) {
-        const key = newSlot.localStartDate;
-        const existingSlot = mergedMap.get(key);
-        if (existingSlot) {
-            // Merge staffByLocation and originalSlots
-            existingSlot.staffByLocation.push(...newSlot.staffByLocation);
-            existingSlot.originalSlots.push(...newSlot.originalSlots);
-        }
-        else {
-            mergedMap.set(key, newSlot);
-        }
-    }
-    return Array.from(mergedMap.values());
-}
 // ============================================================================
 // Service Implementation
 // ============================================================================
@@ -48,18 +22,15 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
     // Get dependent services
     const signalsService = getService(SignalsServiceDefinition);
     const bookingService = getService(BookingServiceDefinition);
-    // Initialize default values
-    const currentDate = new Date();
     // Initialize Signals
     const timeSlotsSignal = signalsService.signal(config.timeSlots || []);
-    const selectionSignal = signalsService.signal(null);
     const isLoadingSignal = signalsService.signal(false);
     const errorSignal = signalsService.signal(null);
     const hasMoreSignal = signalsService.signal(false);
     // 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 startDateSignal = signalsService.signal(config.startDate);
+    const endDateSignal = signalsService.signal(config.endDate);
     const cursorSignal = signalsService.signal(undefined);
     /**
      * Helper: Get services from config or BookingService
@@ -110,16 +81,11 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
     };
     /**
      * Action: Select a time slot
-     * 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
+     * Writes selection directly into BookingService (TimeSlotList does not track selection state)
+     * - Always sets booking location from slot.location (one location per slot)
+     * - Auto-selects staff only when there is exactly one staff option in this slot
      */
     const selectSlot = (slot) => {
-        const currentSelection = selectionSignal.get();
-        if (currentSelection?.slot?.id === slot.id)
-            return;
         const timeSlot = {
             startDate: slot.localStartDate,
             endDate: slot.localEndDate,
@@ -128,93 +94,34 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
             scheduleId: slot.scheduleId ?? undefined,
             eventInfo: slot.eventInfo ?? undefined,
         };
-        const hasOneLocation = slot.staffByLocation.length === 1;
-        // 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 {
-            bookingService.actions.updateItem({
-                timeSlot,
-                resources: [],
-            });
-        }
-        selectionSignal.set({
-            slot,
-            locationId,
-            staffMemberId,
+        bookingService.actions.setLocation({
+            id: slot.location?._id,
+            name: slot.location?.name ?? undefined,
+        });
+        const staffMembersFromSlot = slot.availableResources[0].resources.map((r) => ({
+            id: r._id,
+            name: r.name,
+        }));
+        const resources = staffMembersFromSlot.length === 1 ? staffMembersFromSlot : [];
+        bookingService.actions.updateItem({
+            timeSlot,
+            resources,
         });
-    };
-    /**
-     * Action: Select a location for the current slot
-     * 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;
-        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
-     * 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)
+        const selectedBookingTimeSlot = bookingService.serviceSelections.get()[0]?.timeSlot;
+        if (!selectedBookingTimeSlot)
             return;
+        const findStaffName = (id) => {
+            const slots = timeSlotsSignal.get();
+            return (slots
+                .flatMap((slot) => slot.availableResources[0].resources)
+                .find((r) => r._id === id)?.name ?? undefined);
+        };
         if (staffMemberId === ANY_STAFF_MEMBER_ID) {
             bookingService.actions.updateItem({
                 resources: [
@@ -224,54 +131,24 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
                     },
                 ],
             });
-            selectionSignal.set({ ...currentSelections, staffMemberId });
             return;
         }
-        const slot = currentSelections.slot;
-        // 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,
+                    _id: staffMemberId,
+                    name: findStaffName(staffMemberId),
                 },
             ],
         });
-        // 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 });
-        }
     };
     /**
-     * Action: Clear preferences (location and staff) while keeping the slot selected
+     * Action: Clear staff selection while keeping the selected time slot
      */
-    const clearPreferences = () => {
-        const currentSelection = selectionSignal.get();
-        if (!currentSelection?.slot)
+    const clearStaffSelection = () => {
+        const selectedBookingTimeSlot = bookingService.serviceSelections.get()[0]?.timeSlot;
+        if (!selectedBookingTimeSlot)
             return;
-        // Keep the slot, but clear location and staff selections
-        selectionSignal.set({
-            slot: currentSelection.slot,
-            locationId: null,
-            staffMemberId: null,
-        });
-        // Clear selections in booking service
-        bookingService.actions.clearLocation();
         bookingService.actions.updateItem({
             resources: [],
         });
@@ -295,9 +172,10 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
                 viewMode: viewModeSignal.get(),
                 ...config.filters,
             });
-            // API returns grouped slots, merge with existing
-            const existing = timeSlotsSignal.get();
-            timeSlotsSignal.set(mergeGroupedSlots(existing, response.timeSlots));
+            timeSlotsSignal.set([
+                ...timeSlotsSignal.get(),
+                ...response.timeSlots,
+            ]);
             const nextCursor = response.cursorPagingMetadata?.cursors?.next ?? undefined;
             cursorSignal.set(nextCursor);
             hasMoreSignal.set(!!nextCursor);
@@ -345,7 +223,6 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
     return {
         // State Signals
         timeSlots: timeSlotsSignal,
-        selection: selectionSignal,
         isLoading: isLoadingSignal,
         error: errorSignal,
         hasMore: hasMoreSignal,
@@ -355,9 +232,8 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
         // Actions
         actions: {
             selectSlot,
-            selectLocation,
             selectStaffMember,
-            clearPreferences,
+            clearStaffSelection,
             loadMore,
             setDateRange,
         },
@@ -385,22 +261,17 @@ export const TimeSlotListService = implementService.withConfig()(TimeSlotListSer
  * ```
  */
 export async function loadTimeSlotListConfig(options) {
-    const now = new Date();
-    const startDate = options.startDate || now;
-    const endDate = options.endDate || getDefaultEndDate();
     try {
         const response = await fetchAvailability({
             services: options.services || [],
-            fromLocalDate: startDate,
-            toLocalDate: endDate,
+            fromLocalDate: options.startDate,
+            toLocalDate: options.endDate,
             timeZone: options.timezone ?? getClientTimezone(),
             ...options.filters,
         });
         const config = {
             ...options,
             timeSlots: response.timeSlots || [],
-            startDate,
-            endDate,
         };
         return { type: 'success', config };
     }

package/dist/__mocks__/booking.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Shared mock data for booking service tests
+ */
+import type { Resource } from '@wix/auto_sdk_bookings_availability-time-slots';
+import type { FormValues } from '@wix/form-public';
+import type { ServiceSelection, ServiceSelectionTimeSlot, Location, BookingServiceConfig } from '../services/booking/booking.js';
+/**
+ * Mock time slot data
+ */
+export declare const mockTimeSlot: ServiceSelectionTimeSlot;
+/**
+ * Mock time slot for afternoon
+ */
+export declare const mockTimeSlotAfternoon: ServiceSelectionTimeSlot;
+/**
+ * Mock resource (staff member)
+ */
+export declare const mockResource: Resource;
+/**
+ * Mock resource (another staff member)
+ */
+export declare const mockResourceTwo: Resource;
+/**
+ * Mock resource (room)
+ */
+export declare const mockResourceRoom: Resource;
+/**
+ * Mock service selection with all data
+ */
+export declare const mockServiceSelection: ServiceSelection;
+/**
+ * Mock service selection without time slot (incomplete)
+ */
+export declare const mockServiceSelectionWithoutTimeSlot: ServiceSelection;
+/**
+ * Mock service selection for class
+ */
+export declare const mockServiceSelectionClass: ServiceSelection;
+/**
+ * Mock location
+ */
+export declare const mockLocation: Location;
+/**
+ * Mock location (second)
+ */
+export declare const mockLocationTwo: Location;
+/**
+ * Mock form submission (contact info)
+ */
+export declare const mockFormSubmission: FormValues;
+/**
+ * Mock form submission (minimal)
+ */
+export declare const mockFormSubmissionMinimal: FormValues;
+/**
+ * Mock form submission with custom fields
+ */
+export declare const mockFormSubmissionWithCustomFields: FormValues;
+/**
+ * Default timezone for tests
+ */
+export declare const mockTimezone = "America/New_York";
+/**
+ * Mock booking service config (empty)
+ */
+export declare const mockEmptyBookingConfig: BookingServiceConfig;
+/**
+ * Mock booking service config with initial data
+ */
+export declare const mockBookingConfigWithData: BookingServiceConfig;
+/**
+ * Mock booking service config with multiple selections
+ */
+export declare const mockBookingConfigMultipleSelections: BookingServiceConfig;
+/**
+ * Helper to create a service selection with custom instanceId
+ */
+export declare function createMockServiceSelection(overrides?: Partial<ServiceSelection>): Omit<ServiceSelection, 'instanceId'>;
+/**
+ * Helper to create multiple service selections
+ */
+export declare function createMockServiceSelections(count: number): ServiceSelection[];

package/dist/__mocks__/booking.js

@@ -0,0 +1,163 @@
+/**
+ * Shared mock data for booking service tests
+ */
+import { mockService, mockServiceClass } from './services.js';
+/**
+ * Mock time slot data
+ */
+export const mockTimeSlot = {
+    startDate: '2024-03-15T10:00:00Z',
+    endDate: '2024-03-15T11:00:00Z',
+    totalCapacity: 10,
+    remainingCapacity: 5,
+    scheduleId: 'schedule-123',
+};
+/**
+ * Mock time slot for afternoon
+ */
+export const mockTimeSlotAfternoon = {
+    startDate: '2024-03-15T14:00:00Z',
+    endDate: '2024-03-15T15:00:00Z',
+    totalCapacity: 10,
+    remainingCapacity: 8,
+    scheduleId: 'schedule-456',
+};
+/**
+ * Mock resource (staff member)
+ */
+export const mockResource = {
+    _id: 'resource-1',
+    name: 'John Doe',
+    email: 'john.doe@example.com',
+    tag: 'STAFF',
+};
+/**
+ * Mock resource (another staff member)
+ */
+export const mockResourceTwo = {
+    _id: 'resource-2',
+    name: 'Jane Smith',
+    email: 'jane.smith@example.com',
+    tag: 'STAFF',
+};
+/**
+ * Mock resource (room)
+ */
+export const mockResourceRoom = {
+    _id: 'resource-room-1',
+    name: 'Conference Room A',
+    tag: 'RESOURCE',
+};
+/**
+ * Mock service selection with all data
+ */
+export const mockServiceSelection = {
+    instanceId: 'instance-1',
+    service: mockService,
+    resources: [mockResource],
+    timeSlot: mockTimeSlot,
+    totalParticipants: 1,
+};
+/**
+ * Mock service selection without time slot (incomplete)
+ */
+export const mockServiceSelectionWithoutTimeSlot = {
+    instanceId: 'instance-2',
+    service: mockService,
+    resources: [],
+    totalParticipants: 1,
+};
+/**
+ * Mock service selection for class
+ */
+export const mockServiceSelectionClass = {
+    instanceId: 'instance-3',
+    service: mockServiceClass,
+    resources: [mockResource],
+    timeSlot: mockTimeSlotAfternoon,
+    totalParticipants: 3,
+};
+/**
+ * Mock location
+ */
+export const mockLocation = {
+    id: 'location-1',
+    name: 'Main Office',
+};
+/**
+ * Mock location (second)
+ */
+export const mockLocationTwo = {
+    id: 'location-2',
+    name: 'Downtown Branch',
+};
+/**
+ * Mock form submission (contact info)
+ */
+export const mockFormSubmission = {
+    firstName: 'John',
+    lastName: 'Doe',
+    email: 'john.doe@example.com',
+    phone: '+1234567890',
+};
+/**
+ * Mock form submission (minimal)
+ */
+export const mockFormSubmissionMinimal = {
+    email: 'test@example.com',
+};
+/**
+ * Mock form submission with custom fields
+ */
+export const mockFormSubmissionWithCustomFields = {
+    firstName: 'Jane',
+    lastName: 'Smith',
+    email: 'jane.smith@example.com',
+    notes: 'Please call before the appointment',
+    customField1: 'Custom value 1',
+};
+/**
+ * Default timezone for tests
+ */
+export const mockTimezone = 'America/New_York';
+/**
+ * Mock booking service config (empty)
+ */
+export const mockEmptyBookingConfig = {};
+/**
+ * Mock booking service config with initial data
+ */
+export const mockBookingConfigWithData = {
+    serviceSelections: [mockServiceSelection],
+    location: mockLocation,
+    timezone: mockTimezone,
+    formSubmission: mockFormSubmission,
+};
+/**
+ * Mock booking service config with multiple selections
+ */
+export const mockBookingConfigMultipleSelections = {
+    serviceSelections: [mockServiceSelection, mockServiceSelectionClass],
+    location: mockLocation,
+    timezone: mockTimezone,
+    formSubmission: mockFormSubmission,
+};
+/**
+ * Helper to create a service selection with custom instanceId
+ */
+export function createMockServiceSelection(overrides = {}) {
+    const { instanceId: _, ...base } = mockServiceSelection;
+    return {
+        ...base,
+        ...overrides,
+    };
+}
+/**
+ * Helper to create multiple service selections
+ */
+export function createMockServiceSelections(count) {
+    return Array.from({ length: count }, (_, i) => ({
+        ...mockServiceSelection,
+        instanceId: `instance-${i + 1}`,
+    }));
+}

package/dist/api/fetch-availability/index.d.ts

@@ -2,9 +2,9 @@
  * Time Slot List API
  * Fetches available time slots for booking services from Wix Bookings
  */
-import { type CursorPaging, type CursorPagingMetadata } from '@wix/auto_sdk_bookings_availability-time-slots';
+import { type TimeSlot, type CursorPaging, type CursorPagingMetadata } from '@wix/auto_sdk_bookings_availability-time-slots';
 import { type Service } from '@wix/auto_sdk_bookings_services';
-import { ViewMode, type TimeSlot, type Location } from '../../services/time-slot-list/time-slot-list.def.js';
+import { ViewMode, type Location } from '../../services/time-slot-list/time-slot-list.def.js';
 export interface FetchAvailabilityOptions {
     services: Service[];
     fromLocalDate?: string | null;
@@ -28,14 +28,14 @@ export interface FetchAvailabilityOptions {
  * Response from fetchAvailability with grouped time slots
  */
 export interface FetchAvailabilityResponse {
-    /** Grouped time slots (one per unique time) */
+    /** time slots */
     timeSlots: TimeSlot[];
     /** Cursor pagination metadata for loading more results */
     cursorPagingMetadata?: CursorPagingMetadata;
 }
 /**
  * Main entry point for fetching availability
- * Detects flow type, calls appropriate API, and groups slots by time
+ * Detects flow type and calls appropriate API
  *
  * @param options - Fetch options including services, date range, timezone, and view mode
  * @returns Promise with grouped time slots

package/dist/api/fetch-availability/index.js

@@ -29,50 +29,6 @@ function toLocalDateString(date) {
     return format(date, pattern);
 }
 // ============================================================================
-// Grouping Functions
-// ============================================================================
-/**
- * Groups API time slots by their start time
- * Multiple slots for the same time (different locations) are merged into one
- */
-function groupTimeSlotsByTime(apiSlots) {
-    const groupedMap = new Map();
-    for (const apiSlot of apiSlots) {
-        const key = apiSlot.localStartDate;
-        if (!groupedMap.has(key)) {
-            // Create new grouped slot - omit location and availableResources
-            const { location: _location, availableResources: _availableResources, ...rest } = apiSlot;
-            groupedMap.set(key, {
-                ...rest,
-                staffByLocation: [],
-                originalSlots: [],
-                id: apiSlot.localStartDate,
-            });
-        }
-        const groupedSlot = groupedMap.get(key);
-        // Extract staff members with IDs and names from availableResources
-        const staffMembers = (apiSlot.availableResources || [])
-            .flatMap((resourceGroup) => resourceGroup.resources || [])
-            .filter((resource) => resource._id && resource.name)
-            .map((resource) => ({
-            id: resource._id,
-            name: resource.name,
-        }));
-        // Add this slot's location/staff info
-        const staffByLocation = {
-            location: {
-                id: apiSlot.location?._id,
-                name: apiSlot.location?.name,
-            },
-            staffMembers,
-        };
-        groupedSlot.staffByLocation.push(staffByLocation);
-        // Store original slot for booking service
-        groupedSlot.originalSlots.push(apiSlot);
-    }
-    return Array.from(groupedMap.values());
-}
-// ============================================================================
 // Internal Flow Detection
 // ============================================================================
 /**
@@ -98,7 +54,7 @@ function detectFlow(bookingServices, viewMode) {
 }
 /**
  * Main entry point for fetching availability
- * Detects flow type, calls appropriate API, and groups slots by time
+ * Detects flow type and calls appropriate API
  *
  * @param options - Fetch options including services, date range, timezone, and view mode
  * @returns Promise with grouped time slots
@@ -158,7 +114,7 @@ export async function fetchAvailability({ services: selectedServices, viewMode =
             timeSlotsPerDay,
         });
         return {
-            timeSlots: groupTimeSlotsByTime(response.timeSlots || []),
+            timeSlots: response.timeSlots || [],
             cursorPagingMetadata: response.cursorPagingMetadata,
         };
     }
@@ -188,7 +144,7 @@ export async function fetchAvailability({ services: selectedServices, viewMode =
             maxSlotsPerDay: timeSlotsPerDay,
         });
         return {
-            timeSlots: groupTimeSlotsByTime(response.timeSlots || []),
+            timeSlots: response.timeSlots || [],
             cursorPagingMetadata: response.pagingMetadata,
         };
     }