@wix/headless-bookings 0.0.12 → 0.0.14

package/cjs/dist/api/index.d.ts

@@ -5,6 +5,7 @@
  * @module API
  */
 export { getServiceById, getServiceBySlug, queryServices, type PagingMetadata, type ServiceListFilters, type QueryServicesRequest, } from './query-services/index.js';
+export { fetchAvailability } from './time-slot-list/index.js';
 /**
  * PagingMetadata includes:
  * - limit: Number of items per page

package/cjs/dist/api/index.js

@@ -5,6 +5,7 @@
  * @module API
  */
 export { getServiceById, getServiceBySlug, queryServices, } from './query-services/index.js';
+export { fetchAvailability } from './time-slot-list/index.js';
 /**
  * PagingMetadata includes:
  * - limit: Number of items per page

package/cjs/dist/api/query-services/index.d.ts

@@ -2,13 +2,12 @@
  * Query Services API
  * Fetches single or multiple services with pagination and sorting
  */
-import { services } from '@wix/bookings';
-import type { services as servicesTypes } from '@wix/bookings';
+import { type Service, type Paging, type Sorting } from '@wix/auto_sdk_bookings_services';
 /**
  * Paging metadata from query services response.
  * Extends the SDK's Paging type with hasNext flag to indicate if more services are available.
  */
-export type PagingMetadata = services.Paging & {
+export type PagingMetadata = Paging & {
     /** Number of items returned in the current page */
     count?: number;
     /** Whether there are more services available to load */
@@ -31,7 +30,7 @@ export interface QueryServicesRequest {
     appId: string;
     filters?: ServiceListFilters;
     pagingMetadata?: PagingMetadata;
-    sort?: services.Sorting[];
+    sort?: Sorting[];
 }
 /**
  * Fetches a service by its ID
@@ -40,7 +39,7 @@ export interface QueryServicesRequest {
  * @returns Object containing the service or null if not found
  */
 export declare const getServiceById: (id: string, appId?: string) => Promise<{
-    service: servicesTypes.Service | null;
+    service: Service | null;
 }>;
 /**
  * Fetches a service by its slug
@@ -49,7 +48,7 @@ export declare const getServiceById: (id: string, appId?: string) => Promise<{
  * @returns Object containing the service or null if not found
  */
 export declare const getServiceBySlug: (slug: string, appId?: string) => Promise<{
-    service: servicesTypes.Service | null;
+    service: Service | null;
 }>;
 /**
  * Query services with pagination and sorting.
@@ -73,6 +72,6 @@ export declare const getServiceBySlug: (slug: string, appId?: string) => Promise
  * ```
  */
 export declare function queryServices({ appId, filters, pagingMetadata, sort, }: QueryServicesRequest): Promise<{
-    services: servicesTypes.Service[];
+    services: Service[];
     pagingMetadata: PagingMetadata;
 }>;

package/cjs/dist/api/query-services/index.js

@@ -2,7 +2,7 @@
  * Query Services API
  * Fetches single or multiple services with pagination and sorting
  */
-import { services } from '@wix/bookings';
+import { queryServices as queryServicesApi, } from '@wix/auto_sdk_bookings_services';
 /**
  * Booking app ID constant
  */
@@ -17,7 +17,7 @@ export const getServiceById = async (id, appId) => {
     try {
         const finalAppId = appId ?? BOOKING_APP_ID;
         // Query services where _id equals the provided id and appId matches
-        const query = services.queryServices({
+        const query = queryServicesApi({
             conditionalFields: ['STAFF_MEMBER_DETAILS'],
         });
         const result = await query
@@ -44,7 +44,7 @@ export const getServiceBySlug = async (slug, appId) => {
     try {
         const finalAppId = appId ?? BOOKING_APP_ID;
         // Query services where mainSlug.name equals the provided slug and appId matches
-        const query = services.queryServices({
+        const query = queryServicesApi({
             conditionalFields: ['STAFF_MEMBER_DETAILS'],
         });
         const result = await query
@@ -115,7 +115,7 @@ export async function queryServices({ appId, filters, pagingMetadata, sort, }) {
             sort,
         });
         // Call queryServices with QueryServicesRequest and execute the query
-        const result = await services.queryServices(queryRequest).find();
+        const result = await queryServicesApi(queryRequest).find();
         // Construct PagingMetadata from result properties
         // Includes count (number of items returned) and hasNext (whether more items are available)
         const resultPagingMetadata = {

package/cjs/dist/api/time-slot-list/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Time Slot List API
+ * Fetches available time slots for booking services from Wix Bookings
+ */
+import { type Location, 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 } from '../../services/time-slot-list/time-slot-list.def.js';
+export interface FetchAvailabilityOptions {
+    services: Service[];
+    fromLocalDate?: string | null;
+    toLocalDate?: string | null;
+    timeZone?: string | null;
+    locations?: Location[];
+    cursorPaging?: CursorPaging;
+    viewMode?: ViewMode;
+}
+/**
+ * Response from fetchAvailability with grouped time slots
+ */
+export interface FetchAvailabilityResponse {
+    /** Grouped time slots (one per unique time) */
+    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
+ *
+ * @param options - Fetch options including services, date range, timezone, and view mode
+ * @returns Promise with grouped time slots
+ *
+ * @example
+ * ```typescript
+ * const response = await fetchAvailability({
+ *   services: [service],
+ *   fromLocalDate: '2024-01-15T00:00:00',
+ *   toLocalDate: '2024-01-22T00:00:00',
+ *   timeZone: 'America/New_York',
+ *   viewMode: ViewMode.CLASSIC,
+ * });
+ * // response.timeSlots are grouped by time
+ * ```
+ */
+export declare function fetchAvailability({ services: selectedServices, viewMode, fromLocalDate, toLocalDate, timeZone, locations, cursorPaging, }: {
+    services: Service[];
+    fromLocalDate: string;
+    toLocalDate: string;
+    timeZone?: string;
+    locations?: Location[];
+    cursorPaging?: CursorPaging;
+    viewMode?: ViewMode;
+}): Promise<FetchAvailabilityResponse>;

package/cjs/dist/api/time-slot-list/index.js

@@ -0,0 +1,133 @@
+/**
+ * Time Slot List API
+ * Fetches available time slots for booking services from Wix Bookings
+ */
+import { listAvailabilityTimeSlots, } from '@wix/auto_sdk_bookings_availability-time-slots';
+import { ServiceType } from '@wix/auto_sdk_bookings_services';
+import { ViewMode, } from '../../services/time-slot-list/time-slot-list.def.js';
+// ============================================================================
+// Internal Types
+// ============================================================================
+var FlowType;
+(function (FlowType) {
+    FlowType["SINGLE_SERVICE"] = "single_service";
+    FlowType["MULTI_SERVICE"] = "multi_service";
+    FlowType["CLASS"] = "class";
+})(FlowType || (FlowType = {}));
+// ============================================================================
+// 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
+// ============================================================================
+/**
+ * Detects the booking flow type based on services and view mode
+ */
+function detectFlow(bookingServices, viewMode) {
+    if (bookingServices.length === 0) {
+        if (viewMode === ViewMode.AGENDA) {
+            return FlowType.CLASS; // AGENDA can fetch all classes without specifying services
+        }
+        throw new Error('Services required for classic view mode');
+    }
+    const allAppointments = bookingServices.every((s) => s.type === ServiceType.APPOINTMENT);
+    const allClasses = bookingServices.every((s) => s.type === ServiceType.CLASS);
+    if (!allAppointments && !allClasses) {
+        throw new Error('All services must be either appointments or classes');
+    }
+    if (allClasses)
+        return FlowType.CLASS;
+    if (bookingServices.length === 1)
+        return FlowType.SINGLE_SERVICE;
+    return FlowType.MULTI_SERVICE;
+}
+/**
+ * Main entry point for fetching availability
+ * Detects flow type, calls appropriate API, and groups slots by time
+ *
+ * @param options - Fetch options including services, date range, timezone, and view mode
+ * @returns Promise with grouped time slots
+ *
+ * @example
+ * ```typescript
+ * const response = await fetchAvailability({
+ *   services: [service],
+ *   fromLocalDate: '2024-01-15T00:00:00',
+ *   toLocalDate: '2024-01-22T00:00:00',
+ *   timeZone: 'America/New_York',
+ *   viewMode: ViewMode.CLASSIC,
+ * });
+ * // response.timeSlots are grouped by time
+ * ```
+ */
+export async function fetchAvailability({ services: selectedServices, viewMode = ViewMode.CLASSIC, fromLocalDate, toLocalDate, timeZone, locations, cursorPaging, }) {
+    const flow = detectFlow(selectedServices, viewMode);
+    if (flow === FlowType.SINGLE_SERVICE) {
+        const serviceId = selectedServices[0]?._id;
+        if (!serviceId) {
+            throw new Error('Service ID is required');
+        }
+        const response = await listAvailabilityTimeSlots({
+            serviceId,
+            fromLocalDate,
+            toLocalDate,
+            timeZone,
+            locations,
+            cursorPaging,
+        });
+        return {
+            timeSlots: groupTimeSlotsByTime(response.timeSlots || []),
+            cursorPagingMetadata: response.cursorPagingMetadata,
+        };
+    }
+    if (flow === FlowType.MULTI_SERVICE) {
+        // Phase 2: Multi-service support
+        throw new Error('Multi-service appointments not yet supported');
+    }
+    if (flow === FlowType.CLASS) {
+        // Phase 2: Class support
+        throw new Error('Class bookings not yet supported');
+    }
+    throw new Error(`Unknown flow type: ${flow}`);
+}

package/cjs/dist/react/core/booking/Booking.d.ts

@@ -4,7 +4,7 @@
  */
 import React from 'react';
 import { type BookingServiceConfig, type BookingSelection } from '../../../services/booking/booking.js';
-import type { availabilityTimeSlots } from '@wix/bookings';
+import type { TimeSlot } from '@wix/auto_sdk_bookings_availability-time-slots';
 /**
  * Props for Booking.Root component
  */
@@ -34,7 +34,7 @@ export declare function Root(props: RootProps): React.ReactNode;
 export interface DataProps {
     children: (data: {
         bookingSelections: BookingSelection[];
-        selectedTimeSlot: availabilityTimeSlots.TimeSlot | null;
+        selectedTimeSlot: TimeSlot | null;
     }) => React.ReactNode;
 }
 /**

package/cjs/dist/react/core/location/Location.d.ts

@@ -4,7 +4,7 @@
  * Converts location data to Address component format
  */
 import React from 'react';
-import { services } from '@wix/bookings';
+import { LocationType, type Service } from '@wix/auto_sdk_bookings_services';
 import type { AddressData as AddressDataType } from '@wix/headless-components/react';
 /**
  * Re-export AddressData type from Address component for convenience
@@ -14,14 +14,14 @@ export type AddressData = AddressDataType;
  * Location render props passed to children
  */
 export interface LocationRenderProps {
-    locationType: services.LocationType;
+    locationType: LocationType;
     address: AddressData | null;
 }
 /**
  * Props for the core Location component
  */
 export interface LocationProps {
-    location: NonNullable<services.Service['locations']>[number];
+    location: NonNullable<Service['locations']>[number];
     children: (props: LocationRenderProps) => React.ReactNode;
 }
 /**

package/cjs/dist/react/core/location/Location.js

@@ -3,13 +3,13 @@
  * Handles business, custom, and customer location types
  * Converts location data to Address component format
  */
-import { services } from '@wix/bookings';
+import { LocationType } from '@wix/auto_sdk_bookings_services';
 /**
  * Parses location data into Address component format
  */
 function parseLocationAddress(location, locationType) {
     // Handle customer location specially
-    if (locationType === services.LocationType.CUSTOMER) {
+    if (locationType === LocationType.CUSTOMER) {
         // For customer location, return an AddressData object with Customer's Place
         return {
             address: {

package/cjs/dist/react/core/service/Service.d.ts

@@ -4,7 +4,7 @@
  */
 import React from 'react';
 import { type ServiceServiceConfig } from '../../../services/service/service.js';
-import { services } from '@wix/bookings';
+import type { Service, Payment, BookingPolicy, Schedule } from '@wix/auto_sdk_bookings_services';
 import type { MoneyData } from '@wix/headless-components/react';
 /**
  * Props for Service.Root component
@@ -22,7 +22,7 @@ export declare function Root(props: RootProps): React.ReactNode;
  */
 export interface ServiceProps {
     children: (data: {
-        service: services.Service;
+        service: Service;
         isLoading: boolean;
         error: string | null;
     }) => React.ReactNode;
@@ -55,7 +55,7 @@ export interface InfoProps {
             name?: string;
             _id?: string;
         };
-        locations?: Array<NonNullable<services.Service['locations']>[number]>;
+        locations?: Array<NonNullable<Service['locations']>[number]>;
         staff?: Array<{
             name?: string;
             _id?: string;
@@ -110,8 +110,8 @@ export declare function Info(props: InfoProps): React.ReactNode;
  */
 export interface PriceProps {
     children: (data: {
-        servicePayment: services.Payment | undefined;
-        rateType: services.Payment['rateType'] | undefined;
+        servicePayment: Payment | undefined;
+        rateType: Payment['rateType'] | undefined;
         money: MoneyData | null;
         minPrice: MoneyData | null;
         maxPrice: MoneyData | null;
@@ -151,7 +151,7 @@ export interface ActionsProps {
         select: () => void;
         add: () => void;
         remove: () => void;
-        rawService: services.Service;
+        rawService: Service;
         bookable: boolean;
         selected: boolean;
         requiresAvailability: boolean;
@@ -180,7 +180,7 @@ export declare function Actions(props: ActionsProps): React.ReactNode;
  */
 export interface PolicyProps {
     children: (data: {
-        bookingPolicy: services.BookingPolicy | null;
+        bookingPolicy: BookingPolicy | null;
         cancellationPolicyEnabled: boolean;
         limitLatestCancellationEnabled: boolean;
         latestCancellationInMinutes: number | undefined;
@@ -219,7 +219,7 @@ export declare function Policy(props: PolicyProps): React.ReactNode;
  */
 export interface ScheduleProps {
     children: (data: {
-        schedule: services.Schedule | null;
+        schedule: Schedule | null;
         isClassOrCourse: boolean;
     }) => React.ReactNode;
 }

package/cjs/dist/react/core/service-list/ServiceList.d.ts

@@ -4,7 +4,7 @@
  */
 import React from 'react';
 import { type ServiceListServiceConfig, type QueryOptions } from '../../../services/service-list/service-list.js';
-import type { services } from '@wix/bookings';
+import type { Service } from '@wix/auto_sdk_bookings_services';
 import type { PagingMetadata } from '../../../api/query-services/index.js';
 /**
  * Props for ServiceList.Root component
@@ -37,7 +37,7 @@ export interface ServicesProps {
  */
 export interface ServicesRenderProps {
     /** Array of services */
-    services: services.Service[];
+    services: Service[];
     /** Whether services are currently loading */
     isLoading: boolean;
     /** Error message, or null if no error */