@wix/headless-restaurants-olo 0.0.30 → 0.0.32

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

@@ -2,46 +2,108 @@ 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 { processFulfillmentTimeSlotByOperationList } from '../utils/fulfillments-utils.js';
+import { processFulfillments, processFulfillmentTimeSlotByOperationList, } from '../utils/fulfillments-utils.js';
+import { DispatchType, } from '../types/fulfillments-types.js';
 export const FulfillmentsServiceDefinition = defineService('fulfillments');
 export const FulfillmentsService = implementService.withConfig()(FulfillmentsServiceDefinition, ({ getService, config }) => {
-    console.log('config', config);
     if (!config.operation) {
         throw new Error('Operation ID is required');
     }
     const signalsService = getService(SignalsServiceDefinition);
-    const timeSlotsMap = new Map(config.timeSlots?.map(processFulfillmentTimeSlotByOperationList) ?? []);
+    const firstAvailableTimeSlotsByOperationList = new Map(config.firstAvailableTimeSlots?.map(processFulfillmentTimeSlotByOperationList) ?? []);
     const fulfillments = signalsService.signal(config.fulfillments ?? []);
-    const timeSlots = signalsService.signal(
+    const firstAvailableTimeSlots = signalsService.signal(firstAvailableTimeSlotsByOperationList.get(
     // @ts-expect-error - operation is not typed
-    timeSlotsMap.get(config.operation?.id ?? '') ?? []);
+    config.operation?.id ?? '') ?? []);
     const isLoading = signalsService.signal(false);
     const error = signalsService.signal(null);
-    const initialSelected = timeSlots.get()?.[0] ?? 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 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 availableTypes = signalsService.signal([]);
     selectedTimeSlot.set(initialSelected);
+    const selectFulfillmentType = (type) => {
+        const timeSlot = firstAvailableTimeSlots.get()?.find((t) => t.dispatchType === type) ??
+            null;
+        if (timeSlot) {
+            setSelectedTimeSlot(timeSlot);
+        }
+    };
+    /**
+     * Service Action: Set the selected time slot and update related fulfillment data
+     * This action updates:
+     * - selectedTimeSlot signal
+     * - selectedFulfillment signal (based on dispatch type)
+     * - minOrderPrice signal (based on fulfillment method)
+     */
     const setSelectedTimeSlot = (timeSlot) => {
+        // Update the selected time slot
         selectedTimeSlot.set(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);
     };
-    if (!config.timeSlots && config.operation) {
-        loadFulfillmentsServiceConfig(config.operation).then((config) => {
-            const timeSlotsMap = new Map(config.timeSlots?.map(processFulfillmentTimeSlotByOperationList) ??
-                []);
-            timeSlots.set(
+    // 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(config.operation?.id ?? '') ?? []);
-            const initialSelected = timeSlots.get()?.[0] ?? null;
-            selectedTimeSlot.set(initialSelected);
-            fulfillments.set(config.fulfillments ?? []);
+            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 {
-        timeSlots,
+        firstAvailableTimeSlots,
         fulfillments,
+        selectedFulfillment,
+        dispatchesInfoSignal,
+        selectedDispatchInfoSignal,
+        asapTimeSignal,
+        asapTimeRangeSignal,
         selectedTimeSlot,
+        availableTypes,
         isLoading,
         error,
         setSelectedTimeSlot,
+        selectFulfillmentType,
     };
 });
 export const loadFulfillmentsServiceConfig = async (operation) => {
@@ -55,13 +117,9 @@ export const loadFulfillmentsServiceConfig = async (operation) => {
             .in('_id', operation?.fulfillmentIds)
             .find(),
     ]);
-    // const fulfillments = await operationsSDK.calculateFirstAvailableTimeSlotsPerOperation([
-    //   operationId,
-    // ]);
-    console.log('fulfillments', fulfillments.items);
-    // const fulfillmentsMap = new Map(fulfillments.timeSlotsPerOperation?.map(processFulfillmentTimeSlotByOperationList));
+    console.log('operation', operation);
     return {
-        timeSlots: timeSlots.timeSlotsPerOperation, //fulfillmentsMap.get(operationId) ?? [],
+        firstAvailableTimeSlots: timeSlots.timeSlotsPerOperation,
         operation: operation,
         fulfillments: fulfillments.items.filter((f) => f.enabled),
     };

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

@@ -1,6 +1,7 @@
 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';
 export declare enum DispatchType {
     /** Pickup fulfillment */
     PICKUP = "PICKUP",
@@ -21,16 +22,62 @@ export interface Fulfillment {
     type: string;
     isAvailable: boolean;
 }
+export type DispatchInfo = {
+    address?: Address;
+    selectedTimeSlot?: TimeSlot;
+    maxTimeOptions?: number;
+    durationRangeOptions?: DurationRange;
+    minOrder?: string;
+    deliveryFee?: string;
+    freeFulfillmentPriceThreshold?: string;
+    minDate?: Date;
+};
+export type DispatchesInfo = Record<DispatchType, DispatchInfo>;
 export interface FulfillmentsServiceAPI {
-    timeSlots: Signal<TimeSlot[]>;
+    /** Available time slots for the operation */
+    firstAvailableTimeSlots: Signal<TimeSlot[]>;
+    /** Available fulfillment methods (pickup, delivery, etc.) */
     fulfillments: Signal<fulfillemtMethodsSDK.FulfillmentMethod[]>;
+    /** Currently selected fulfillment method based on dispatch type */
+    selectedFulfillment: Signal<fulfillemtMethodsSDK.FulfillmentMethod | null>;
+    /** Currently selected time slot */
     selectedTimeSlot: Signal<TimeSlot | null>;
+    /** Currently selected ASAP time */
+    asapTimeSignal: Signal<number | undefined>;
+    /** Currently selected ASAP time range */
+    asapTimeRangeSignal: Signal<operationsSDK.DurationRange | undefined>;
+    /** Loading state */
     isLoading: Signal<boolean>;
+    /** Error state */
     error: Signal<string | null>;
+    /** Available dispatch types */
+    availableTypes: Signal<DispatchType[]>;
+    /**
+     * Dispatches info by dispatch type
+     */
+    dispatchesInfoSignal: Signal<DispatchesInfo>;
+    /**
+     * Currently selected dispatch info
+     */
+    selectedDispatchInfoSignal: Signal<DispatchInfo | null>;
+    /**
+     * Action: Set the selected time slot and update related fulfillment data
+     * This action automatically updates:
+     * - selectedTimeSlot signal
+     * - selectedFulfillment signal (based on dispatch type)
+     * - dispatchesInfo signal (based on dispatch type)
+     *
+     * @param timeSlot - The time slot to select
+     */
     setSelectedTimeSlot: (timeSlot: TimeSlot) => void;
+    /**
+     * Action: Select a fulfillment type and update related fulfillment data
+     * This action automatically updates the selected time slot and fulfillment data
+     */
+    selectFulfillmentType: (type: DispatchType) => void;
 }
 export interface FulfillmentsServiceConfig {
-    timeSlots?: operationsSDK.TimeSlotForOperation[];
+    firstAvailableTimeSlots?: operationsSDK.TimeSlotForOperation[];
     operation?: operationsSDK.Operation;
     fulfillments?: fulfillemtMethodsSDK.FulfillmentMethod[];
 }

package/cjs/dist/types/operation.d.ts

@@ -11,7 +11,7 @@ export type PreorderScheduling = {
     timeWindowDuration: number;
     timeInAdvance: MinMaxRange;
 };
-export type OperationType = 'PRE_ORDER' | 'ASAP';
+export type OperationType = 'PRE_ORDER' | 'ASAP' | 'ASAP_AND_FUTURE';
 type BaseOperation = {
     id: string;
     name: string;

package/cjs/dist/utils/fulfillments-utils.d.ts

@@ -1,5 +1,21 @@
 import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
-import { TimeSlot } from '../types/fulfillments-types.js';
+import { DispatchesInfo, TimeSlot } from '../types/fulfillments-types.js';
+import { Operation } from '../types/operation.js';
+import * as fulfillemtMethodsSDK from '@wix/auto_sdk_restaurants_fulfillment-methods';
+import { FulfillmentDetails } from '@wix/auto_sdk_restaurants_operations';
+/**
+ * Format a string with placeholders like {0}, {1}, etc.
+ * Similar to C#'s String.Format
+ *
+ * @example
+ * stringFormat("Hello {0}, you have {1} messages", "John", 5)
+ * // Returns: "Hello John, you have 5 messages"
+ *
+ * @example
+ * stringFormat("{0} + {1} = {2}", 1, 2, 3)
+ * // Returns: "1 + 2 = 3"
+ */
+export declare const stringFormat: (template: string, ...args: (string | number | boolean | null | undefined)[]) => string;
 export declare const createTimeSlotId: (startTime: Date, endTime: Date, maxTimeOptions?: number) => string;
 export declare function hasSameByField<T>(field: keyof T, arr: T[]): boolean;
 export declare function getMinValueObjects<T>(key: keyof T, arr: T[]): T[];
@@ -21,3 +37,20 @@ export declare const resolveDifferentMinOrderPriceOptionByFulfillmentInfo: (fulf
 export declare const resolveSameMinOrderPriceOptionByFulfillmentInfo: (fulfillmentInfo: operationsSDK.FulfillmentInfo[]) => operationsSDK.FulfillmentInfo;
 export declare const resolveFulfillmentInfo: (fulfillmentInfo: operationsSDK.FulfillmentInfo[]) => operationsSDK.FulfillmentInfo | undefined;
 export declare const processFulfillmentTimeSlotByOperationList: (operationTimeSlot: operationsSDK.TimeSlotForOperation) => [string, TimeSlot[] | undefined];
+export declare function getFastestTimeOptions(arr: FulfillmentDetails[]): FulfillmentDetails[];
+export declare function getSlowestTimeOption(arr: FulfillmentDetails[]): FulfillmentDetails;
+export declare const createTimeRange: (arr: FulfillmentDetails[]) => {
+    maxTimeOptions: number | undefined;
+    durationRangeOptions?: undefined;
+} | {
+    durationRangeOptions: {
+        minDuration: number | undefined;
+        maxDuration: number | undefined;
+    };
+    maxTimeOptions?: undefined;
+};
+export declare const processFulfillments: (fulfillments: fulfillemtMethodsSDK.FulfillmentMethod[], timeSlots: TimeSlot[], operation: Operation) => Promise<{
+    dispatchesInfo: DispatchesInfo;
+    isPickupConfigured: boolean;
+    isDeliveryConfigured: boolean;
+} | undefined>;

package/cjs/dist/utils/fulfillments-utils.js

@@ -1,5 +1,26 @@
 import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
-import { DispatchType } from '../types/fulfillments-types.js';
+import { DispatchType, } from '../types/fulfillments-types.js';
+import { EntitiesDayOfWeek as DayOfWeek, } from '@wix/auto_sdk_restaurants_fulfillment-methods';
+import { FulfillmentTimeType, } from '@wix/auto_sdk_restaurants_operations';
+/**
+ * Format a string with placeholders like {0}, {1}, etc.
+ * Similar to C#'s String.Format
+ *
+ * @example
+ * stringFormat("Hello {0}, you have {1} messages", "John", 5)
+ * // Returns: "Hello John, you have 5 messages"
+ *
+ * @example
+ * stringFormat("{0} + {1} = {2}", 1, 2, 3)
+ * // Returns: "1 + 2 = 3"
+ */
+export const stringFormat = (template, ...args) => {
+    return template.replace(/{(\d+)}/g, (match, index) => {
+        const argIndex = parseInt(index, 10);
+        const arg = args[argIndex];
+        return arg !== undefined && arg !== null ? String(arg) : match;
+    });
+};
 export const createTimeSlotId = (startTime, endTime, maxTimeOptions = 0) => 
 // maxTimeOptions is used to avoid collisions when order pacing is enabled
 `${startTime?.toUTCString()}-${endTime?.toUTCString()}-${maxTimeOptions}`;
@@ -142,3 +163,190 @@ export const processFulfillmentTimeSlotByOperationList = (operationTimeSlot) =>
         }),
     ];
 };
+const DAY_OF_WEEK = {
+    [DayOfWeek.MON]: 1,
+    [DayOfWeek.TUE]: 2,
+    [DayOfWeek.WED]: 3,
+    [DayOfWeek.THU]: 4,
+    [DayOfWeek.FRI]: 5,
+    [DayOfWeek.SAT]: 6,
+    [DayOfWeek.SUN]: 7,
+};
+const convertTimeOfDayToDateTime = (time, timezone) => {
+    const now = new Date();
+    if (timezone) {
+        // Get today's date components in the specified timezone
+        const options = {
+            timeZone: timezone,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+        };
+        const parts = new Intl.DateTimeFormat('en-US', options).formatToParts(now);
+        const year = parts.find((p) => p.type === 'year')?.value;
+        const month = parts.find((p) => p.type === 'month')?.value;
+        const day = parts.find((p) => p.type === 'day')?.value;
+        // Create an ISO string with the date in the timezone and the specified time
+        const hours = String(time.hours ?? 0).padStart(2, '0');
+        const minutes = String(time.minutes ?? 0).padStart(2, '0');
+        const isoString = `${year}-${month}-${day}T${hours}:${minutes}:00.000`;
+        // Convert to Date - this will be interpreted as local time
+        const localDate = new Date(isoString);
+        // Get what this time would be formatted as in the target timezone
+        const formattedInTz = new Date(localDate.toLocaleString('en-US', { timeZone: timezone }));
+        // Calculate the difference and adjust
+        const offset = localDate.getTime() - formattedInTz.getTime();
+        return new Date(localDate.getTime() + offset);
+    }
+    // If no timezone specified, use local time
+    const date = new Date();
+    date.setHours(time.hours ?? 0, time.minutes ?? 0, 0, 0);
+    return date;
+};
+const isInTimeRange = (time, range, timeZone) => {
+    const startTime = range.startTime
+        ? convertTimeOfDayToDateTime(range.startTime, timeZone)
+        : time;
+    const endTime = range.endTime
+        ? convertTimeOfDayToDateTime(range.endTime, timeZone)
+        : time;
+    return (time.getTime() >= startTime.getTime() && time.getTime() <= endTime.getTime());
+};
+const isFulfillmentAvailable = (fulfillment, operation) => {
+    const { availability: { timeZone, availableTimes } = {} } = fulfillment;
+    const { asapOptions: { maxInMinutes, rangeInMinutes } = {} } = operation;
+    const deliveryTime = fulfillment.deliveryOptions?.deliveryTimeInMinutes ?? 0;
+    const zone = timeZone;
+    const timeNow = new Date();
+    timeNow.setMinutes(timeNow.getMinutes() +
+        (maxInMinutes ?? rangeInMinutes?.min ?? 0) +
+        deliveryTime);
+    // getDay() returns 0 (Sunday) to 6 (Saturday), but we need 1 (Monday) to 7 (Sunday)
+    const currentDayOfWeek = timeNow.getDay() === 0 ? 7 : timeNow.getDay();
+    return !!availableTimes?.some((availableTime) => {
+        const { dayOfWeek, timeRanges } = availableTime;
+        const dayOfWeekNumber = DAY_OF_WEEK[dayOfWeek];
+        const isAvailable = dayOfWeekNumber === currentDayOfWeek &&
+            !!timeRanges?.some((range) => isInTimeRange(timeNow, range, zone));
+        return isAvailable;
+    });
+};
+const isAddressValid = (address) => {
+    return (address.country && (address.geocode?.latitude || address.geocode?.longitude));
+};
+const getConsistentValue = (values) => {
+    return values.length === 0 || values.some((value) => value !== values[0])
+        ? undefined
+        : (values[0] ?? undefined);
+};
+export function getFastestTimeOptions(arr) {
+    return arr.slice(1).reduce((minArr, item) => {
+        const { durationRangeOptions, maxTimeOptions, fulfillmentTimeType } = item;
+        const min = minArr[0];
+        const minTime = min?.fulfillmentTimeType === FulfillmentTimeType.DURATION_RANGE
+            ? Number(min?.durationRangeOptions?.minDuration)
+            : Number(min?.maxTimeOptions);
+        const currTime = fulfillmentTimeType === FulfillmentTimeType.DURATION_RANGE
+            ? Number(durationRangeOptions.minDuration)
+            : Number(maxTimeOptions);
+        if (currTime < minTime) {
+            return [item];
+        }
+        else if (currTime === minTime) {
+            return [...minArr, item];
+        }
+        return minArr;
+    }, (arr[0] ? [arr[0]] : []));
+}
+export function getSlowestTimeOption(arr) {
+    return arr.reduce((max, item) => {
+        const { durationRangeOptions, maxTimeOptions, fulfillmentTimeType } = item;
+        let maxTime;
+        if (max.fulfillmentTimeType === FulfillmentTimeType.DURATION_RANGE) {
+            maxTime = Number(max.durationRangeOptions?.maxDuration || 0);
+        }
+        else {
+            maxTime = Number(max.maxTimeOptions || 0);
+        }
+        if (durationRangeOptions &&
+            fulfillmentTimeType === FulfillmentTimeType.DURATION_RANGE) {
+            return Number(durationRangeOptions.maxDuration) > maxTime ? item : max;
+        }
+        else {
+            return Number(maxTimeOptions) > maxTime ? item : max;
+        }
+    }, {});
+}
+export const createTimeRange = (arr) => {
+    const fastestOption = getFastestTimeOptions(arr)[0];
+    const slowestOption = getSlowestTimeOption(arr);
+    const minDuration = fastestOption?.durationRangeOptions?.minDuration ??
+        fastestOption?.maxTimeOptions;
+    const maxDuration = slowestOption.durationRangeOptions?.maxDuration ??
+        slowestOption.maxTimeOptions;
+    if (minDuration === maxDuration) {
+        return { maxTimeOptions: minDuration };
+    }
+    else {
+        return { durationRangeOptions: { minDuration, maxDuration } };
+    }
+};
+export const processFulfillments = async (fulfillments, timeSlots, operation) => {
+    const shouldConsiderAvailability = timeSlots.length > 0;
+    try {
+        console.log('fulfillments :>>', fulfillments);
+        const pickupFulfillment = fulfillments.find((fulfillment) => fulfillment.type === 'PICKUP' && fulfillment.enabled);
+        let deliveryFulfillments = fulfillments.filter((fulfillment) => fulfillment.type === 'DELIVERY' && fulfillment.enabled);
+        const isPickupConfigured = !!pickupFulfillment;
+        const isDeliveryConfigured = deliveryFulfillments.length > 0;
+        if (shouldConsiderAvailability) {
+            deliveryFulfillments = deliveryFulfillments.filter((fulfillment) => isFulfillmentAvailable(fulfillment, operation));
+        }
+        const dispatchesInfo = {};
+        const locationAddress = operation.locationDetails?.address &&
+            isAddressValid(operation.locationDetails?.address)
+            ? operation.locationDetails.address
+            : undefined;
+        if (isPickupConfigured) {
+            const pickupAddress = (locationAddress ?? pickupFulfillment?.pickupOptions?.address)
+                ? pickupFulfillment.pickupOptions?.address
+                : undefined;
+            dispatchesInfo[DispatchType.PICKUP] = {
+                address: pickupAddress,
+                minOrder: pickupFulfillment?.minOrderPrice ?? undefined,
+            };
+        }
+        if (isDeliveryConfigured) {
+            const deliveryFee = getConsistentValue(deliveryFulfillments.map((f) => f.fee));
+            const freeFulfillmentPriceThreshold = getConsistentValue(deliveryFulfillments.map((f) => f.deliveryOptions?.freeDeliveryThreshold));
+            const minOrder = getConsistentValue(deliveryFulfillments.map((f) => f.minOrderPrice));
+            const { asapOptions: { maxInMinutes, rangeInMinutes } = {} } = operation;
+            const fulfillmentDetails = deliveryFulfillments.map((f) => {
+                const deliveryTime = f.deliveryOptions?.deliveryTimeInMinutes ?? 0;
+                const timeObject = typeof maxInMinutes === 'number'
+                    ? {
+                        maxTimeOptions: deliveryTime + maxInMinutes,
+                        FulfillmentTimeType: FulfillmentTimeType.MAX_TIME,
+                    }
+                    : {
+                        durationRangeOptions: {
+                            minDuration: deliveryTime + (rangeInMinutes?.min ?? 0),
+                            maxDuration: deliveryTime + (rangeInMinutes?.max ?? 0),
+                        },
+                        fulfillmentTimeType: FulfillmentTimeType.DURATION_RANGE,
+                    };
+                return timeObject;
+            });
+            dispatchesInfo[DispatchType.DELIVERY] = {
+                minOrder,
+                deliveryFee,
+                freeFulfillmentPriceThreshold,
+                ...((typeof maxInMinutes === 'number' || !!rangeInMinutes) &&
+                    fulfillmentDetails.length > 0 &&
+                    createTimeRange(fulfillmentDetails)),
+            };
+        }
+        return { dispatchesInfo, isPickupConfigured, isDeliveryConfigured };
+    }
+    catch (error) { }
+};

package/dist/react/ClickableItem.d.ts

@@ -1,9 +1,24 @@
 import React from 'react';
-declare function ClickableItem({ onItemSelected, children, }: {
-    onItemSelected: (item: any) => void;
+import { type SelectedItemData } from './core/ClickableItem.js';
+/**
+ * ClickableItem component
+ *
+ * A wrapper that makes an item clickable and passes the selected item data up via callback.
+ * Uses direct props pattern - no global state.
+ *
+ * @example
+ * ```tsx
+ * <ClickableItem onItemSelected={(item) => setSelectedItem(item)}>
+ *   <div>Click me</div>
+ * </ClickableItem>
+ * ```
+ */
+declare function ClickableItem({ onItemSelected, children, className, }: {
+    onItemSelected: (item: SelectedItemData) => void;
     children: React.ReactNode;
+    className?: string;
 }): import("react/jsx-runtime").JSX.Element;
 export declare const Actions: {
     Select: typeof ClickableItem;
 };
-export {};
+export type { SelectedItemData } from './core/ClickableItem.js';

package/dist/react/ClickableItem.js

@@ -1,13 +1,20 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { CoreClickableItem } from './core/ClickableItem.js';
-function ClickableItem({ onItemSelected, children, }) {
-    const selectItem = (item, callback) => {
-        callback();
-        onItemSelected(item);
-    };
-    return (_jsx(CoreClickableItem, { children: ({ item, itemSelected }) => (_jsx("div", { onClick: () => {
-                selectItem(item, itemSelected);
-            }, children: children })) }));
+import { CoreClickableItem, } from './core/ClickableItem.js';
+/**
+ * ClickableItem component
+ *
+ * A wrapper that makes an item clickable and passes the selected item data up via callback.
+ * Uses direct props pattern - no global state.
+ *
+ * @example
+ * ```tsx
+ * <ClickableItem onItemSelected={(item) => setSelectedItem(item)}>
+ *   <div>Click me</div>
+ * </ClickableItem>
+ * ```
+ */
+function ClickableItem({ onItemSelected, children, className, }) {
+    return (_jsx(CoreClickableItem, { children: ({ itemData }) => (_jsx("div", { onClick: () => onItemSelected(itemData), className: className, children: children })) }));
 }
 export const Actions = {
     Select: ClickableItem,