@wix/headless-restaurants-olo 0.0.33 → 0.0.34

package/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/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/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/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/dist/services/olo-settings-service.d.ts

@@ -4,7 +4,6 @@ import { MenusServiceConfig } from '@wix/restaurants/services';
 export interface OLOSettingsServiceAPI {
     operationGroup: Signal<operationGroupsSDK.OperationGroup | undefined>;
     operation: Signal<operationsSDK.Operation | undefined>;
-    selectedItem?: Signal<unknown>;
     isLoading: Signal<boolean>;
     error: Signal<string | null>;
     availabilityDispatchAction?: Signal<(() => void) | undefined>;

package/dist/services/olo-settings-service.js

@@ -10,8 +10,7 @@ export const OLOSettingsService = implementService.withConfig()(OLOSettingsServi
     const operation = signalsService.signal(config.operation);
     const formatCurrency = config.formattedPrice ??
         ((price) => price?.toFixed(2)?.toString() ?? '');
-    const selectedItem = signalsService.signal(null);
-    const isLoading = signalsService.signal(false);
+    const isLoading = signalsService.signal(true);
     const error = signalsService.signal(null);
     const currentFulfillment = signalsService.signal('Pickup');
     const currentTimeSlot = signalsService.signal('10-14');
@@ -24,7 +23,6 @@ export const OLOSettingsService = implementService.withConfig()(OLOSettingsServi
         operation,
         isLoading,
         error,
-        selectedItem,
         availabilityDispatchAction,
         currentFulfillment,
         currentTimeSlot,

package/dist/types/fulfillments-types.d.ts

@@ -2,12 +2,21 @@ import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
 import { Signal } from '@wix/services-definitions/core-services/signals';
 import * as fulfillemtMethodsSDK from '@wix/auto_sdk_restaurants_fulfillment-methods';
 import { Address, DurationRange } from '@wix/auto_sdk_restaurants_operations';
+import { Operation } from './operation.js';
 export declare enum DispatchType {
     /** Pickup fulfillment */
     PICKUP = "PICKUP",
     /** Delivery fulfillment */
     DELIVERY = "DELIVERY"
 }
+export declare enum FulfillmentTypeEnum {
+    /** ASAP - Order will be fulfilled as soon as possible */
+    ASAP = "ASAP",
+    /** PREORDER - Order will be fulfilled at a scheduled time */
+    PREORDER = "PREORDER",
+    /** ASAP_AND_FUTURE - Both ASAP and future scheduling available */
+    ASAP_AND_FUTURE = "ASAP_AND_FUTURE"
+}
 export type TimeSlot = {
     id: string;
     startTime: Date;
@@ -52,6 +61,14 @@ export interface FulfillmentsServiceAPI {
     error: Signal<string | null>;
     /** Available dispatch types */
     availableTypes: Signal<DispatchType[]>;
+    /** Current scheduling type (ASAP or PREORDER) based on selected time slot */
+    schedulingType: Signal<FulfillmentTypeEnum | undefined>;
+    /** Whether ASAP option is available */
+    hasAsapOption: Signal<boolean>;
+    /** Whether preorder (schedule for later) option is available */
+    hasPreorderOption: Signal<boolean>;
+    /** Whether both ASAP and future scheduling options are available */
+    hasAsapAndFutureOption: Signal<boolean>;
     /**
      * Dispatches info by dispatch type
      */
@@ -78,6 +95,6 @@ export interface FulfillmentsServiceAPI {
 }
 export interface FulfillmentsServiceConfig {
     firstAvailableTimeSlots?: operationsSDK.TimeSlotForOperation[];
-    operation?: operationsSDK.Operation;
+    operation?: Operation;
     fulfillments?: fulfillemtMethodsSDK.FulfillmentMethod[];
 }

package/dist/types/fulfillments-types.js

@@ -5,3 +5,12 @@ export var DispatchType;
     /** Delivery fulfillment */
     DispatchType["DELIVERY"] = "DELIVERY";
 })(DispatchType || (DispatchType = {}));
+export var FulfillmentTypeEnum;
+(function (FulfillmentTypeEnum) {
+    /** ASAP - Order will be fulfilled as soon as possible */
+    FulfillmentTypeEnum["ASAP"] = "ASAP";
+    /** PREORDER - Order will be fulfilled at a scheduled time */
+    FulfillmentTypeEnum["PREORDER"] = "PREORDER";
+    /** ASAP_AND_FUTURE - Both ASAP and future scheduling available */
+    FulfillmentTypeEnum["ASAP_AND_FUTURE"] = "ASAP_AND_FUTURE";
+})(FulfillmentTypeEnum || (FulfillmentTypeEnum = {}));