@wix/headless-restaurants-olo 0.0.33 → 0.0.35

package/cjs/dist/services/fulfillment-details-service.d.ts

@@ -0,0 +1,127 @@
+import { type Signal, type ReadOnlySignal } from '@wix/services-definitions/core-services/signals';
+import { DispatchType, TimeSlot, FulfillmentTypeEnum } from '../types/fulfillments-types.js';
+import { Operation } from '../types/operation.js';
+import { Address } from '@wix/auto_sdk_restaurants_operations';
+/**
+ * Date availability information
+ */
+export interface AvailableDate {
+    /** The date that is available */
+    date: Date;
+    /** Whether this date has available slots */
+    hasAvailableSlots: boolean;
+}
+/**
+ * API interface for the Fulfillment Details service
+ * Provides reactive state management for fulfillment scheduling
+ */
+export interface FulfillmentDetailsServiceAPI {
+    /** Currently selected time slot */
+    timeslot: Signal<TimeSlot | null>;
+    /** Delivery/pickup address */
+    address: Signal<Address | null>;
+    /** Selected date for fulfillment */
+    date: Signal<Date | null>;
+    /** Dispatch type (PICKUP or DELIVERY) */
+    dispatchType: Signal<DispatchType | null>;
+    /** ASAP time slot (when user wants the order as soon as possible) */
+    asapTimeSlot: Signal<TimeSlot | null>;
+    /** Loading state for async operations */
+    isLoading: Signal<boolean>;
+    /** Error state */
+    error: Signal<string | null>;
+    /** Available dates within the configured range */
+    availableDates: Signal<AvailableDate[]>;
+    /** Available time slots for the selected date */
+    availableTimeSlotsForDate: Signal<TimeSlot[]>;
+    /** Available time slots filtered by current dispatch type */
+    availableTimeSlots: ReadOnlySignal<TimeSlot[]>;
+    /** Selected scheduling type (ASAP or PREORDER) */
+    schedulingType: Signal<FulfillmentTypeEnum | undefined>;
+    /**
+     * Get the currently selected time slot
+     * @returns The selected time slot or null
+     */
+    getTimeslot: () => TimeSlot | null;
+    /**
+     * Set the selected time slot
+     * @param timeslot - The time slot to select
+     */
+    setTimeslot: (timeslot: TimeSlot | null) => void;
+    /**
+     * Set the delivery/pickup address
+     * @param address - The address to set
+     */
+    setAddress: (address: Address | null) => void;
+    /**
+     * Set the selected date for fulfillment
+     * Also triggers fetching available time slots for the date
+     * @param date - The date to select
+     */
+    setDate: (date: Date | null) => Promise<void>;
+    /**
+     * Set the dispatch type (PICKUP or DELIVERY)
+     * @param type - The dispatch type to set
+     */
+    setDispatchType: (type: DispatchType | null) => void;
+    /**
+     * Set the ASAP time slot
+     * @param timeslot - The ASAP time slot to set
+     */
+    setAsapTimeSlot: (timeslot: TimeSlot | null) => void;
+    /**
+     * Set the scheduling type (ASAP or PREORDER)
+     * Also selects an appropriate time slot based on the type
+     * @param type - The scheduling type to set
+     */
+    setSchedulingType: (type: FulfillmentTypeEnum | undefined) => void;
+    /**
+     * Calculate available dates within a date range
+     * @param startDate - Start of the date range
+     * @param endDate - End of the date range
+     * @returns Promise that resolves to available dates
+     */
+    calculateAvailableDatesInRange: (startDate: Date, endDate: Date) => Promise<AvailableDate[]>;
+    /**
+     * Calculate available time slots for a specific date
+     * @param date - The date to get time slots for
+     * @returns Promise that resolves to available time slots
+     */
+    calculateAvailableTimeSlotsForDate: (date: Date) => Promise<TimeSlot[]>;
+}
+/**
+ * Configuration for the Fulfillment Details service
+ */
+export interface FulfillmentDetailsServiceConfig {
+    /** The operation to get fulfillment details for */
+    operation?: Operation;
+    /** Initial dispatch type */
+    initialDispatchType?: DispatchType;
+    /** Initial address */
+    initialAddress?: Address;
+    /** Number of days ahead to calculate available dates (default: 30) */
+    daysAhead?: number;
+}
+export declare const FulfillmentDetailsServiceDefinition: string & {
+    __api: FulfillmentDetailsServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & FulfillmentDetailsServiceAPI;
+export declare const FulfillmentDetailsService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: FulfillmentDetailsServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & FulfillmentDetailsServiceAPI, FulfillmentDetailsServiceConfig>;
+/**
+ * Load configuration for the FulfillmentDetailsService
+ * Used for SSR initialization
+ *
+ * @param operation - The operation to configure the service with
+ * @param options - Additional configuration options
+ * @returns The service configuration
+ */
+export declare function loadFulfillmentDetailsServiceConfig(operation: Operation, options?: {
+    initialDispatchType?: DispatchType;
+    initialAddress?: Address;
+    daysAhead?: number;
+}): FulfillmentDetailsServiceConfig;

package/cjs/dist/services/fulfillment-details-service.js

@@ -0,0 +1,351 @@
+import { defineService, implementService } from '@wix/services-definitions';
+import { SignalsServiceDefinition, } from '@wix/services-definitions/core-services/signals';
+import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
+import { DispatchType, FulfillmentTypeEnum, } from '../types/fulfillments-types.js';
+import { convertDateToTimezone, createTimeSlotId, getLocale, getTimezone, resolveFulfillmentInfo, } from '../utils/fulfillments-utils.js';
+import { createDateFromYMD } from '../utils/date-utils.js';
+import { FulfillmentsServiceDefinition } from './fulfillments-service.js';
+// ========================================
+// Service Definition
+// ========================================
+export const FulfillmentDetailsServiceDefinition = defineService('fulfillment-details');
+// ========================================
+// Service Implementation
+// ========================================
+export const FulfillmentDetailsService = implementService.withConfig()(FulfillmentDetailsServiceDefinition, ({ getService, config }) => {
+    if (!config.operation) {
+        throw new Error('Operation is required for FulfillmentDetailsService');
+    }
+    const fulfillmentsService = getService(FulfillmentsServiceDefinition);
+    const signalsService = getService(SignalsServiceDefinition);
+    const operation = config.operation;
+    const daysAhead = config.daysAhead ?? 30;
+    // ========================================
+    // Initialize Signals
+    // ========================================
+    const timeslot = signalsService.signal(null);
+    const address = signalsService.signal(config?.initialAddress ??
+        fulfillmentsService.selectedDispatchInfoSignal?.get()?.address ??
+        null);
+    const date = signalsService.signal(null);
+    const dispatchType = signalsService.signal(config.initialDispatchType ??
+        fulfillmentsService.selectedFulfillment.get()
+            ?.type ??
+        null);
+    const asapTimeSlot = signalsService.signal(null);
+    const isLoading = signalsService.signal(false);
+    const error = signalsService.signal(null);
+    const availableDates = signalsService.signal([]);
+    const availableTimeSlotsForDate = signalsService.signal([]);
+    const schedulingType = signalsService.signal(fulfillmentsService.schedulingType?.get());
+    // ========================================
+    // Helper Functions
+    // ========================================
+    /**
+     * Process time slots from SDK response to our TimeSlot format
+     */
+    const processTimeSlots = (timeSlotsResponse, targetDispatchType) => {
+        if (!timeSlotsResponse)
+            return [];
+        const slots = [];
+        for (const fulfillmentSlot of timeSlotsResponse) {
+            const { timeSlot, fulfilmentType, fulfillmentInfo } = fulfillmentSlot;
+            // Filter by dispatch type if specified
+            const slotDispatchType = fulfilmentType === 'DELIVERY'
+                ? DispatchType.DELIVERY
+                : DispatchType.PICKUP;
+            if (targetDispatchType && slotDispatchType !== targetDispatchType) {
+                continue;
+            }
+            const { startTime, endTime, orderSchedulingType } = timeSlot ?? {};
+            if (!startTime || !endTime)
+                continue;
+            const selectedFulfillmentInfo = resolveFulfillmentInfo(fulfillmentInfo ?? []);
+            const fulfillmentDetails = {
+                maxTimeOptions: selectedFulfillmentInfo?.maxTime,
+                durationRangeOptions: selectedFulfillmentInfo?.durationRange,
+                ...selectedFulfillmentInfo,
+            };
+            const timezone = getTimezone();
+            const locale = getLocale();
+            slots.push({
+                id: createTimeSlotId(startTime, endTime),
+                startTime: convertDateToTimezone(startTime, timezone, locale),
+                endTime: convertDateToTimezone(endTime, timezone, locale),
+                dispatchType: slotDispatchType,
+                startsNow: orderSchedulingType === operationsSDK.OrderSchedulingType.ASAP,
+                fulfillmentDetails,
+            });
+        }
+        return slots;
+    };
+    /**
+     * Check if two dates are on the same day
+     */
+    const isSameDay = (date1, date2) => {
+        return (date1.getFullYear() === date2.getFullYear() &&
+            date1.getMonth() === date2.getMonth() &&
+            date1.getDate() === date2.getDate());
+    };
+    // ========================================
+    // Action Implementations
+    // ========================================
+    const getTimeslot = () => {
+        return timeslot.get();
+    };
+    const setTimeslot = (slot) => {
+        timeslot.set(slot);
+        // Update date if timeslot has a start time
+        if (slot?.startTime) {
+            date.set(slot.startTime);
+        }
+        // Update dispatch type based on timeslot
+        if (slot?.dispatchType) {
+            dispatchType.set(slot.dispatchType);
+        }
+        // Update asap timeslot if this is an ASAP slot
+        if (slot?.startsNow) {
+            asapTimeSlot.set(slot);
+        }
+    };
+    const setAddress = (addr) => {
+        address.set(addr);
+    };
+    const setDate = async (selectedDate) => {
+        date.set(selectedDate);
+        // Fetch time slots for the selected date
+        if (selectedDate) {
+            await calculateAvailableTimeSlotsForDateFn(selectedDate);
+        }
+        else {
+            availableTimeSlotsForDate.set([]);
+        }
+    };
+    const setDispatchType = (type) => {
+        console.log('setDispatchType', type);
+        dispatchType.set(type);
+        // Re-filter available time slots based on new dispatch type
+        const currentDate = date.get();
+        if (currentDate) {
+            calculateAvailableTimeSlotsForDateFn(currentDate);
+        }
+    };
+    const setAsapTimeSlot = (slot) => {
+        asapTimeSlot.set(slot);
+        if (slot) {
+            timeslot.set(slot);
+            if (slot.startTime) {
+                date.set(slot.startTime);
+            }
+        }
+    };
+    const setSchedulingType = (type) => {
+        schedulingType.set(type);
+        // Find appropriate time slot based on type
+        const slots = availableTimeSlotsForDate.get();
+        const targetSlot = slots.find((slot) => {
+            if (type === FulfillmentTypeEnum.ASAP) {
+                return slot.startsNow;
+            }
+            else {
+                return !slot.startsNow;
+            }
+        });
+        if (targetSlot) {
+            setTimeslot(targetSlot);
+        }
+    };
+    // ========================================
+    // Fetch Method Implementations
+    // ========================================
+    const calculateAvailableDatesInRangeFn = async (startDate, endDate) => {
+        isLoading.set(true);
+        error.set(null);
+        try {
+            // Call the SDK to get available dates in the range
+            const response = await operationsSDK.calculateAvailableDatesInRange(operation.id, {
+                from: {
+                    year: startDate.getFullYear(),
+                    month: startDate.getMonth() + 1, // SDK uses 1-based months
+                    day: startDate.getDate(),
+                },
+                until: {
+                    year: endDate.getFullYear(),
+                    month: endDate.getMonth() + 1,
+                    day: endDate.getDate(),
+                },
+                deliveryAddress: address.get() ?? undefined,
+            });
+            const { availableDatesPerFulfillmentType } = response;
+            // Process the response to extract available dates
+            const datesMap = new Map();
+            const currentDispatchType = dispatchType.get();
+            for (const fulfillmentDates of availableDatesPerFulfillmentType ??
+                []) {
+                const { fulfilmentType, dates } = fulfillmentDates;
+                // Filter by dispatch type if set
+                if (currentDispatchType) {
+                    const slotType = fulfilmentType === 'DELIVERY'
+                        ? DispatchType.DELIVERY
+                        : DispatchType.PICKUP;
+                    if (slotType !== currentDispatchType)
+                        continue;
+                }
+                if (dates) {
+                    for (const sdkDate of dates) {
+                        if (!sdkDate.year || !sdkDate.month || !sdkDate.day)
+                            continue;
+                        const dateObj = createDateFromYMD(sdkDate.year, sdkDate.month, sdkDate.day);
+                        const dateKey = dateObj.toISOString().split('T')[0];
+                        if (!datesMap.has(dateKey)) {
+                            datesMap.set(dateKey, {
+                                date: dateObj,
+                                hasAvailableSlots: true,
+                            });
+                        }
+                    }
+                }
+            }
+            const dates = Array.from(datesMap.values()).sort((a, b) => a.date.getTime() - b.date.getTime());
+            availableDates.set(dates);
+            return dates;
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error
+                ? err.message
+                : 'Failed to calculate available dates';
+            error.set(errorMessage);
+            console.error('Error calculating available dates:', err);
+            return [];
+        }
+        finally {
+            isLoading.set(false);
+        }
+    };
+    const calculateAvailableTimeSlotsForDateFn = async (targetDate) => {
+        isLoading.set(true);
+        error.set(null);
+        try {
+            // Call the SDK to get time slots for the specific date
+            const response = await operationsSDK.calculateAvailableTimeSlotsForDate(operation.id, {
+                date: {
+                    year: targetDate.getFullYear(),
+                    month: targetDate.getMonth() + 1,
+                    day: targetDate.getDate(),
+                },
+                deliveryAddress: address.get() ?? undefined,
+            });
+            const { timeslotsPerFulfillmentType } = response;
+            const currentDispatchType = dispatchType.get();
+            const slots = processTimeSlots(timeslotsPerFulfillmentType, currentDispatchType).reverse();
+            availableTimeSlotsForDate.set(slots);
+            // Auto-select first available slot if none selected
+            if (slots.length > 0 && !timeslot.get()) {
+                const firstAsapSlot = slots.find((s) => s.startsNow);
+                setTimeslot(firstAsapSlot ?? slots[0]);
+            }
+            return slots;
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error
+                ? err.message
+                : 'Failed to calculate time slots for date';
+            error.set(errorMessage);
+            console.error('Error calculating time slots for date:', err);
+            return [];
+        }
+        finally {
+            isLoading.set(false);
+        }
+    };
+    // ========================================
+    // Initialize with default date range
+    // ========================================
+    // Auto-load available dates on service initialization
+    const initializeDates = async () => {
+        const startDate = new Date();
+        startDate.setHours(0, 0, 0, 0);
+        const endDate = new Date();
+        endDate.setDate(endDate.getDate() + daysAhead);
+        endDate.setHours(23, 59, 59, 999);
+        await calculateAvailableDatesInRangeFn(startDate, endDate);
+        // If we have available dates, auto-select today or first available
+        const dates = availableDates.get();
+        if (dates.length > 0) {
+            const today = new Date();
+            const todayAvailable = dates.find((d) => isSameDay(d.date, today) && d.hasAvailableSlots);
+            const firstAvailable = todayAvailable ?? dates.find((d) => d.hasAvailableSlots);
+            if (firstAvailable) {
+                await setDate(firstAvailable.date);
+            }
+        }
+    };
+    // Initialize asynchronously (don't block service creation)
+    initializeDates().catch((err) => {
+        console.error('Error initializing fulfillment details:', err);
+        error.set('Failed to initialize fulfillment details');
+    });
+    // ========================================
+    // Computed Signals
+    // ========================================
+    /**
+     * Available time slots filtered by current dispatch type
+     */
+    const availableTimeSlots = signalsService.computed(() => {
+        const currentDispatchType = dispatchType.get();
+        console.log('currentDispatchType', currentDispatchType);
+        const allTimeSlots = availableTimeSlotsForDate.get();
+        if (!currentDispatchType) {
+            return allTimeSlots;
+        }
+        return allTimeSlots.filter((slot) => slot.dispatchType === currentDispatchType);
+    });
+    // ========================================
+    // Return Service API
+    // ========================================
+    return {
+        // Signals
+        timeslot,
+        address,
+        date,
+        dispatchType,
+        asapTimeSlot,
+        isLoading,
+        error,
+        availableDates,
+        availableTimeSlotsForDate,
+        availableTimeSlots,
+        schedulingType,
+        // Actions
+        getTimeslot,
+        setTimeslot,
+        setAddress,
+        setDate,
+        setDispatchType,
+        setAsapTimeSlot,
+        setSchedulingType,
+        // Fetch methods
+        calculateAvailableDatesInRange: calculateAvailableDatesInRangeFn,
+        calculateAvailableTimeSlotsForDate: calculateAvailableTimeSlotsForDateFn,
+    };
+});
+// ========================================
+// Config Loader
+// ========================================
+/**
+ * Load configuration for the FulfillmentDetailsService
+ * Used for SSR initialization
+ *
+ * @param operation - The operation to configure the service with
+ * @param options - Additional configuration options
+ * @returns The service configuration
+ */
+export function loadFulfillmentDetailsServiceConfig(operation, options) {
+    console.log('options', options);
+    return {
+        operation,
+        initialDispatchType: options?.initialDispatchType,
+        initialAddress: options?.initialAddress,
+        daysAhead: options?.daysAhead ?? 30,
+    };
+}

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

@@ -2,8 +2,8 @@ import { defineService, implementService } from '@wix/services-definitions';
 import { SignalsServiceDefinition } from '@wix/services-definitions/core-services/signals';
 import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
 import * as fulfillemtMethodsSDK from '@wix/auto_sdk_restaurants_fulfillment-methods';
-import { processFulfillments, processFulfillmentTimeSlotByOperationList, } from '../utils/fulfillments-utils.js';
-import { DispatchType, } from '../types/fulfillments-types.js';
+import { convertDateToTimezone, getLocale, getTimezone, processFulfillments, processFulfillmentTimeSlotByOperationList, } from '../utils/fulfillments-utils.js';
+import { DispatchType, FulfillmentTypeEnum, } from '../types/fulfillments-types.js';
 export const FulfillmentsServiceDefinition = defineService('fulfillments');
 export const FulfillmentsService = implementService.withConfig()(FulfillmentsServiceDefinition, ({ getService, config }) => {
     if (!config.operation) {
@@ -12,42 +12,80 @@ export const FulfillmentsService = implementService.withConfig()(FulfillmentsSer
     const signalsService = getService(SignalsServiceDefinition);
     const firstAvailableTimeSlotsByOperationList = new Map(config.firstAvailableTimeSlots?.map(processFulfillmentTimeSlotByOperationList) ?? []);
     const fulfillments = signalsService.signal(config.fulfillments ?? []);
-    const firstAvailableTimeSlots = signalsService.signal(firstAvailableTimeSlotsByOperationList.get(
-    // @ts-expect-error - operation is not typed
-    config.operation?.id ?? '') ?? []);
+    const firstAvailableTimeSlots = signalsService.signal(firstAvailableTimeSlotsByOperationList.get(config.operation?.id ?? '') ?? []);
     const isLoading = signalsService.signal(false);
     const error = signalsService.signal(null);
     const dispatchesInfoSignal = signalsService.signal({});
     const selectedDispatchInfoSignal = signalsService.signal(null);
     const asapTimeSignal = signalsService.signal(undefined);
     const asapTimeRangeSignal = signalsService.signal(undefined);
-    processFulfillments(fulfillments.get() ?? [], firstAvailableTimeSlots.get() ?? [], config.operation ?? undefined).then((result) => {
-        const { dispatchesInfo } = result ?? {};
-        dispatchesInfoSignal.set(dispatchesInfo ?? {});
-        const selectedDispatchInfo = dispatchesInfoSignal.get()[selectedFulfillment.get()?.type];
-        selectedDispatchInfoSignal.set(selectedDispatchInfo ?? null);
-        const { maxTimeOptions, durationRangeOptions } = selectedDispatchInfo ?? {};
-        // const isDelivery = !!address;
-        const isAsap = !!selectedTimeSlot.get()?.startsNow;
-        // if (isDelivery && isAsap) {
-        const { fulfillmentDetails } = selectedTimeSlot.get() ?? {};
-        if (isAsap) {
-            asapTimeSignal.set(fulfillmentDetails?.maxTimeOptions ?? maxTimeOptions);
-            asapTimeRangeSignal.set(fulfillmentDetails?.durationRangeOptions ?? durationRangeOptions);
-        }
-    });
+    const selectedFulfillment = signalsService.signal(null);
     const pickupTimeSlot = firstAvailableTimeSlots
         .get()
         ?.find((t) => t.dispatchType === DispatchType.PICKUP) ?? null;
     const initialSelected = pickupTimeSlot ?? firstAvailableTimeSlots.get()?.[0] ?? null;
     const selectedTimeSlot = signalsService.signal(initialSelected);
-    const selectedFulfillment = signalsService.signal(null);
+    const { dispatchesInfo } = processFulfillments(fulfillments.get() ?? [], firstAvailableTimeSlots.get() ?? [], config.operation ?? undefined) ?? {};
+    // Initialize selected fulfillment for initial time slot
+    if (initialSelected && fulfillments.get()?.length > 0) {
+        const timezone = getTimezone();
+        const locale = getLocale();
+        initialSelected.startTime = convertDateToTimezone(initialSelected.startTime, timezone, locale);
+        initialSelected.endTime = convertDateToTimezone(initialSelected.endTime, timezone, locale);
+        const fulfillmentList = fulfillments.get();
+        const matchingFulfillment = fulfillmentList.find((f) => f.type === initialSelected.dispatchType) ?? null;
+        selectedFulfillment.set(matchingFulfillment);
+    }
+    dispatchesInfoSignal.set(dispatchesInfo ?? {});
+    const selectedDispatchInfo = dispatchesInfoSignal.get()[selectedFulfillment.get()?.type];
+    selectedDispatchInfoSignal.set(selectedDispatchInfo ?? null);
+    const { maxTimeOptions, durationRangeOptions } = selectedDispatchInfo ?? {};
+    // const isDelivery = !!address;
+    const isAsap = !!selectedTimeSlot.get()?.startsNow;
+    // if (isDelivery && isAsap) {
+    const { fulfillmentDetails } = selectedTimeSlot.get() ?? {};
+    if (isAsap) {
+        asapTimeSignal.set(fulfillmentDetails?.maxTimeOptions ?? maxTimeOptions);
+        asapTimeRangeSignal.set(fulfillmentDetails?.durationRangeOptions ?? durationRangeOptions);
+    }
+    // });
     const availableTypes = signalsService.signal([]);
+    const getSchedulingType = (timeSlot) => {
+        if (!timeSlot)
+            return undefined;
+        if (config.operation?.operationType === operationsSDK.SchedulingType.ASAP) {
+            return timeSlot.startsNow
+                ? FulfillmentTypeEnum.ASAP
+                : FulfillmentTypeEnum.ASAP_AND_FUTURE;
+        }
+        return FulfillmentTypeEnum.PREORDER;
+    };
+    const schedulingType = signalsService.signal(getSchedulingType(initialSelected));
+    // Compute initial fulfillment type options based on time slots
+    const computeFulfillmentTypeOptions = (timeSlots) => {
+        const hasAsap = timeSlots
+            .filter((slot) => slot.dispatchType === selectedFulfillment.get()?.type)
+            .some((slot) => slot.startsNow);
+        const hasFuture = !!config.operation?.allowAsapFutureHandling;
+        return {
+            hasAsapOption: hasAsap,
+            hasPreorderOption: !hasAsap && hasFuture,
+            hasAsapAndFutureOption: hasAsap && hasFuture,
+        };
+    };
+    const initialOptions = computeFulfillmentTypeOptions(firstAvailableTimeSlots.get() ?? []);
+    const hasAsapOption = signalsService.signal(initialOptions.hasAsapOption);
+    const hasPreorderOption = signalsService.signal(initialOptions.hasPreorderOption);
+    const hasAsapAndFutureOption = signalsService.signal(initialOptions.hasAsapAndFutureOption);
     selectedTimeSlot.set(initialSelected);
     const selectFulfillmentType = (type) => {
         const timeSlot = firstAvailableTimeSlots.get()?.find((t) => t.dispatchType === type) ??
             null;
         if (timeSlot) {
+            const timezone = getTimezone();
+            const locale = getLocale();
+            timeSlot.startTime = convertDateToTimezone(timeSlot.startTime, timezone, locale);
+            timeSlot.endTime = convertDateToTimezone(timeSlot.endTime, timezone, locale);
             setSelectedTimeSlot(timeSlot);
         }
     };
@@ -56,39 +94,21 @@ export const FulfillmentsService = implementService.withConfig()(FulfillmentsSer
      * This action updates:
      * - selectedTimeSlot signal
      * - selectedFulfillment signal (based on dispatch type)
+     * - schedulingType signal (based on order scheduling type)
      * - minOrderPrice signal (based on fulfillment method)
      */
     const setSelectedTimeSlot = (timeSlot) => {
+        console.log('setSelectedTimeSlot', timeSlot);
         // Update the selected time slot
         selectedTimeSlot.set(timeSlot);
+        // Update scheduling type based on order scheduling configuration
+        schedulingType.set(getSchedulingType(timeSlot));
         // Update selected fulfillment based on dispatch type
         const matchingFulfillment = fulfillments.get().find((f) => f.type === timeSlot.dispatchType) ??
             null;
         selectedFulfillment.set(matchingFulfillment);
         selectedDispatchInfoSignal.set(dispatchesInfoSignal.get()[matchingFulfillment?.type] ?? null);
     };
-    // Initialize selected fulfillment for initial time slot
-    if (initialSelected && fulfillments.get()?.length > 0) {
-        const fulfillmentList = fulfillments.get();
-        const matchingFulfillment = fulfillmentList.find((f) => f.type === initialSelected.dispatchType) ?? null;
-        selectedFulfillment.set(matchingFulfillment);
-    }
-    // Load time slots and fulfillments if not provided
-    if (!config.firstAvailableTimeSlots && config.operation) {
-        loadFulfillmentsServiceConfig(config.operation).then((loadedConfig) => {
-            const timeSlotsMap = new Map(loadedConfig.firstAvailableTimeSlots?.map(processFulfillmentTimeSlotByOperationList) ?? []);
-            const newTimeSlots = 
-            // @ts-expect-error - operation is not typed
-            timeSlotsMap.get(loadedConfig.operation?.id ?? '') ?? [];
-            firstAvailableTimeSlots.set(newTimeSlots);
-            fulfillments.set(loadedConfig.fulfillments ?? []);
-            // Set initial time slot using the action to ensure all related signals are updated
-            const newInitialSelected = newTimeSlots[0];
-            if (newInitialSelected) {
-                setSelectedTimeSlot(newInitialSelected);
-            }
-        });
-    }
     availableTypes.set(Array.from(new Set(firstAvailableTimeSlots.get()?.map((t) => t.dispatchType) ?? [])).sort((a, _) => (a === DispatchType.PICKUP ? -1 : 1)));
     return {
         firstAvailableTimeSlots,
@@ -100,6 +120,10 @@ export const FulfillmentsService = implementService.withConfig()(FulfillmentsSer
         asapTimeRangeSignal,
         selectedTimeSlot,
         availableTypes,
+        schedulingType,
+        hasAsapOption,
+        hasPreorderOption,
+        hasAsapAndFutureOption,
         isLoading,
         error,
         setSelectedTimeSlot,

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

@@ -2,3 +2,5 @@ export { ItemService, ItemServiceDefinition, loadItemServiceConfig, ItemServiceC
 export { OLOSettingsService, OLOSettingsServiceDefinition, loadOLOSettingsServiceConfig, type OLOSettingsServiceConfig, type OLOSettingsServiceAPI, } from './olo-settings-service.js';
 export { AvailabilityStatus, AvailabilityStatusMap, RuleType, RuleTypeMap, AddToCartButtonState, AddToCartButtonLabelMap, } from './common-types.js';
 export { FulfillmentsService, FulfillmentsServiceDefinition, loadFulfillmentsServiceConfig, } from './fulfillments-service.js';
+export { type FulfillmentsServiceConfig } from '../types/fulfillments-types.js';
+export { FulfillmentDetailsService, FulfillmentDetailsServiceDefinition, loadFulfillmentDetailsServiceConfig, type FulfillmentDetailsServiceAPI, type FulfillmentDetailsServiceConfig, type AvailableDate, } from './fulfillment-details-service.js';

package/cjs/dist/services/index.js

@@ -2,3 +2,4 @@ export { ItemService, ItemServiceDefinition, loadItemServiceConfig, } from './it
 export { OLOSettingsService, OLOSettingsServiceDefinition, loadOLOSettingsServiceConfig, } from './olo-settings-service.js';
 export { AvailabilityStatus, RuleType, AddToCartButtonState, } from './common-types.js';
 export { FulfillmentsService, FulfillmentsServiceDefinition, loadFulfillmentsServiceConfig, } from './fulfillments-service.js';
+export { FulfillmentDetailsService, FulfillmentDetailsServiceDefinition, loadFulfillmentDetailsServiceConfig, } from './fulfillment-details-service.js';

package/cjs/dist/services/item-details-service.d.ts

@@ -16,6 +16,7 @@ export interface ItemServiceAPI {
     quantity: Signal<number>;
     specialRequest: Signal<string>;
     lineItem: ReadOnlySignal<LineItem>;
+    onHandleAddToCart: (onClick: (lineItem: LineItem) => void) => void;
     buttonState: ReadOnlySignal<AddToCartButtonState | undefined>;
     addToCartButtonDisabled: Signal<boolean>;
     price: ReadOnlySignal<number>;
@@ -43,7 +44,6 @@ export interface ItemServiceAPI {
         endDate?: Date;
         weeklyAvailabilitySummary?: WeeklyAvailability;
     };
-    doesModifierGroupHaveError: ReadOnlySignal<boolean>;
 }
 /**
  * Service definition for the Item service.