@wix/headless-restaurants-olo 0.0.14 → 0.0.16

package/dist/react/core/OLOMenus.js

@@ -0,0 +1,12 @@
+import React from 'react';
+import { OLOSettingsServiceDefinition } from '../../services/olo-settings-service.js';
+import { useService } from '@wix/services-manager-react';
+export const Root = React.forwardRef(function OLOMenusRoot({ config, children }) {
+    const service = useService(OLOSettingsServiceDefinition);
+    const filteredMenus = service.filterMenus(config.menus);
+    const hasMenus = Array.isArray(filteredMenus) && filteredMenus.length > 0;
+    if (!hasMenus)
+        return null;
+    config.menus = filteredMenus;
+    return children(config);
+});

package/dist/react/core/Settings.d.ts

@@ -0,0 +1,157 @@
+import React from 'react';
+import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
+import { TimeSlot } from '../../types/fulfillments-types.js';
+interface CurrentTime {
+    timeSlot: string;
+}
+interface CurrentFulfillment {
+    current?: operationsSDK.TimeSlot;
+}
+interface CurrentLocation {
+    name: string;
+}
+interface ExtraData {
+    acceptingOrders: boolean;
+    deliveryFee?: number;
+    minOrderAmount?: number;
+    freeDeliveryThreshold?: number;
+    taxRate?: number;
+    serviceCharge?: number;
+    isOnline?: boolean;
+    orderingDisabledReason?: string;
+}
+interface SettingsData {
+    currentTime: CurrentTime;
+    currentFulfillment: CurrentFulfillment;
+    currentLocation: CurrentLocation;
+    selectedFulfillment: any;
+    extraData: ExtraData;
+    isLoading: boolean;
+    error?: string | null;
+}
+interface SettingsRootProps {
+    children: (props: SettingsData) => React.ReactNode;
+}
+/**
+ * Core Settings component that provides access to OLO settings data
+ * Integrates with OLOSettingsService to expose operation and operation group data
+ *
+ * @example
+ * ```tsx
+ * <CoreSettings.Root>
+ *   {({ currentDetails, currentFulfillment, currentLocation, extraData, isLoading, error }) => (
+ *     isLoading ? (
+ *       <div>Loading settings...</div>
+ *     ) : error ? (
+ *       <div>Error: {error}</div>
+ *     ) : (
+ *       <div>
+ *         <h2>{currentDetails.name}</h2>
+ *         <p>Accepting Orders: {extraData.acceptingOrders ? 'Yes' : 'No'}</p>
+ *         <p>Delivery Fee: ${extraData.deliveryFee}</p>
+ *       </div>
+ *     )
+ *   )}
+ * </CoreSettings.Root>
+ * ```
+ */
+export declare const Root: React.FC<SettingsRootProps>;
+interface CurrentTimeSlotProps {
+    children: (props: {
+        timeSlot: TimeSlot;
+        hasDetails: boolean;
+    }) => React.ReactNode;
+}
+/**
+ * Component that provides access to current store details
+ *
+ * @example
+ * ```tsx
+ * <CoreSettings.CurrentTimeSlot>
+ *   {({ details, hasDetails }) => (
+ *     hasDetails ? (
+ *       <div>
+ *         <h3>{details.timeSlot}</h3>
+ *       </div>
+ *     ) : (
+ *       <div>No store details available</div>
+ *     )
+ *   )}
+ * </CoreSettings.CurrentTimeSlot>
+ * ```
+ */
+export declare const CurrentTimeSlot: React.FC<CurrentTimeSlotProps>;
+interface CurrentFulfillmentProps {
+    children: (props: {
+        fulfillment: CurrentFulfillment;
+        hasFulfillment: boolean;
+        availableOptions: string[];
+    }) => React.ReactNode;
+}
+/**
+ * Component that provides access to current fulfillment options
+ *
+ * @example
+ * ```tsx
+ * <CoreSettings.CurrentFulfillment>
+ *   {({ fulfillment, availableOptions }) => (
+ *     <div>
+ *       <h3>Available Options:</h3>
+ *       {availableOptions.map(option => (
+ *         <div key={option}>{option}: Available</div>
+ *       ))}
+ *     </div>
+ *   )}
+ * </CoreSettings.CurrentFulfillment>
+ * ```
+ */
+export declare const CurrentFulfillment: React.FC<CurrentFulfillmentProps>;
+interface CurrentLocationProps {
+    children: (props: {
+        location: CurrentLocation;
+        hasLocation: boolean;
+    }) => React.ReactNode;
+}
+/**
+ * Component that provides access to current location data
+ *
+ * @example
+ * ```tsx
+ * <CoreSettings.CurrentLocation>
+ *   {({ location, hasCoordinates }) => (
+ *     <div>
+ *       <p>{location.address}</p>
+ *       {hasCoordinates && (
+ *         <p>Coordinates: {location.latitude}, {location.longitude}</p>
+ *       )}
+ *     </div>
+ *   )}
+ * </CoreSettings.CurrentLocation>
+ * ```
+ */
+export declare const CurrentLocation: React.FC<CurrentLocationProps>;
+interface ExtraDataProps {
+    children: (props: {
+        extraData: ExtraData;
+        hasExtraData: boolean;
+    }) => React.ReactNode;
+}
+/**
+ * Component that provides access to extra settings data
+ *
+ * @example
+ * ```tsx
+ * <CoreSettings.ExtraData>
+ *   {({ extraData }) => (
+ *     <div>
+ *       <p>Accepting Orders: {extraData.acceptingOrders ? 'Yes' : 'No'}</p>
+ *       <p>Delivery Fee: ${extraData.deliveryFee}</p>
+ *       <p>Min Order: ${extraData.minOrderAmount}</p>
+ *       <p>Free Delivery: ${extraData.freeDeliveryThreshold}</p>
+ *     </div>
+ *   )}
+ * </CoreSettings.ExtraData>
+ * ```
+ */
+export declare const ExtraData: React.FC<ExtraDataProps>;
+export {};

package/dist/react/core/Settings.js

@@ -0,0 +1,192 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useService } from '@wix/services-manager-react';
+import { OLOSettingsServiceDefinition } from '../../services/olo-settings-service.js';
+import { FulfillmentsServiceDefinition } from '../../services/fulfillments-service.js';
+/**
+ * Core Settings component that provides access to OLO settings data
+ * Integrates with OLOSettingsService to expose operation and operation group data
+ *
+ * @example
+ * ```tsx
+ * <CoreSettings.Root>
+ *   {({ currentDetails, currentFulfillment, currentLocation, extraData, isLoading, error }) => (
+ *     isLoading ? (
+ *       <div>Loading settings...</div>
+ *     ) : error ? (
+ *       <div>Error: {error}</div>
+ *     ) : (
+ *       <div>
+ *         <h2>{currentDetails.name}</h2>
+ *         <p>Accepting Orders: {extraData.acceptingOrders ? 'Yes' : 'No'}</p>
+ *         <p>Delivery Fee: ${extraData.deliveryFee}</p>
+ *       </div>
+ *     )
+ *   )}
+ * </CoreSettings.Root>
+ * ```
+ */
+export const Root = ({ children }) => {
+    const service = useService(OLOSettingsServiceDefinition);
+    const fulfillmentsService = useService(FulfillmentsServiceDefinition);
+    const operation = service.operation?.get();
+    const selectedFulfillment = fulfillmentsService.selectedFulfillment?.get();
+    console.log('selectedFulfillment', selectedFulfillment);
+    const isLoading = service.isLoading?.get() ?? false;
+    const error = service.error?.get();
+    // Extract current details from operation group
+    // Note: Using safe property access since the exact API structure may vary
+    const currentTime = {
+        timeSlot: 'TODO', // service.currentTimeSlot?.get(),
+    };
+    // Extract fulfillment options from operation
+    // Note: Using safe property access since the exact API structure may vary
+    const currentFulfillment = {
+        current: fulfillmentsService.selectedFulfillment?.get() ?? undefined,
+    };
+    // Extract location data from operation group
+    // Note: Using safe property access since the exact API structure may vary
+    const currentLocation = {
+        name: operation.locationDetails?.name,
+    };
+    // Extract extra data from operation
+    // Note: Using safe property access since the exact API structure may vary
+    const extraData = {
+        acceptingOrders: operation?.status === 'ACTIVE' && !operation?.paused,
+        deliveryFee: operation?.fulfillment?.delivery?.fee?.amount ||
+            operation?.deliveryFee,
+        minOrderAmount: operation?.orderingRules?.minimumOrderValue?.amount ||
+            operation?.minOrderAmount,
+        freeDeliveryThreshold: operation?.fulfillment?.delivery?.freeDeliveryThreshold
+            ?.amount || operation?.freeDeliveryThreshold,
+        taxRate: operation?.pricing?.taxRate || operation?.taxRate,
+        serviceCharge: operation?.pricing?.serviceCharge?.amount ||
+            operation?.serviceCharge,
+        isOnline: operation?.status === 'ACTIVE',
+        orderingDisabledReason: operation?.paused
+            ? operation?.pauseReason
+            : undefined,
+    };
+    return children({
+        currentTime,
+        currentFulfillment,
+        selectedFulfillment,
+        currentLocation,
+        extraData,
+        isLoading,
+        error,
+    });
+};
+/**
+ * Component that provides access to current store details
+ *
+ * @example
+ * ```tsx
+ * <CoreSettings.CurrentTimeSlot>
+ *   {({ details, hasDetails }) => (
+ *     hasDetails ? (
+ *       <div>
+ *         <h3>{details.timeSlot}</h3>
+ *       </div>
+ *     ) : (
+ *       <div>No store details available</div>
+ *     )
+ *   )}
+ * </CoreSettings.CurrentTimeSlot>
+ * ```
+ */
+export const CurrentTimeSlot = ({ children, }) => {
+    return (_jsx(Root, { children: ({ selectedFulfillment }) => {
+            const hasDetails = Boolean(selectedFulfillment);
+            console.log('selectedFulfillment', selectedFulfillment);
+            console.log('timeSlot', selectedFulfillment?.startTime.toLocaleString());
+            return children({
+                timeSlot: selectedFulfillment,
+                hasDetails,
+            });
+        } }));
+};
+/**
+ * Component that provides access to current fulfillment options
+ *
+ * @example
+ * ```tsx
+ * <CoreSettings.CurrentFulfillment>
+ *   {({ fulfillment, availableOptions }) => (
+ *     <div>
+ *       <h3>Available Options:</h3>
+ *       {availableOptions.map(option => (
+ *         <div key={option}>{option}: Available</div>
+ *       ))}
+ *     </div>
+ *   )}
+ * </CoreSettings.CurrentFulfillment>
+ * ```
+ */
+export const CurrentFulfillment = ({ children, }) => {
+    return (_jsx(Root, { children: ({ currentFulfillment }) => {
+            const availableOptions = [];
+            // if (currentFulfillment.pickup?.enabled) availableOptions.push('pickup');
+            // if (currentFulfillment.delivery?.enabled) availableOptions.push('delivery');
+            const hasFulfillment = availableOptions.length > 0;
+            return children({
+                fulfillment: currentFulfillment,
+                hasFulfillment,
+                availableOptions,
+            });
+        } }));
+};
+/**
+ * Component that provides access to current location data
+ *
+ * @example
+ * ```tsx
+ * <CoreSettings.CurrentLocation>
+ *   {({ location, hasCoordinates }) => (
+ *     <div>
+ *       <p>{location.address}</p>
+ *       {hasCoordinates && (
+ *         <p>Coordinates: {location.latitude}, {location.longitude}</p>
+ *       )}
+ *     </div>
+ *   )}
+ * </CoreSettings.CurrentLocation>
+ * ```
+ */
+export const CurrentLocation = ({ children, }) => {
+    return (_jsx(Root, { children: ({ currentLocation }) => {
+            console.log('currentLocation', currentLocation);
+            const hasLocation = Boolean(currentLocation.name);
+            return children({
+                location: currentLocation,
+                hasLocation,
+            });
+        } }));
+};
+/**
+ * Component that provides access to extra settings data
+ *
+ * @example
+ * ```tsx
+ * <CoreSettings.ExtraData>
+ *   {({ extraData }) => (
+ *     <div>
+ *       <p>Accepting Orders: {extraData.acceptingOrders ? 'Yes' : 'No'}</p>
+ *       <p>Delivery Fee: ${extraData.deliveryFee}</p>
+ *       <p>Min Order: ${extraData.minOrderAmount}</p>
+ *       <p>Free Delivery: ${extraData.freeDeliveryThreshold}</p>
+ *     </div>
+ *   )}
+ * </CoreSettings.ExtraData>
+ * ```
+ */
+export const ExtraData = ({ children }) => {
+    return (_jsx(Root, { children: ({ extraData }) => {
+            const hasExtraData = Boolean(extraData.deliveryFee !== undefined ||
+                extraData.minOrderAmount !== undefined ||
+                extraData.freeDeliveryThreshold !== undefined);
+            return children({
+                extraData,
+                hasExtraData,
+            });
+        } }));
+};

package/dist/react/core/index.d.ts

@@ -1,3 +1,4 @@
 export * as CoreItemDetails from './ItemDetails.js';
 export { CoreClickableItem } from './ClickableItem.js';
 export * as CoreOLO from './OLO.js';
+export * as CoreSettings from './Settings.js';

package/dist/react/core/index.js

@@ -1,3 +1,4 @@
 export * as CoreItemDetails from './ItemDetails.js';
 export { CoreClickableItem } from './ClickableItem.js';
 export * as CoreOLO from './OLO.js';
+export * as CoreSettings from './Settings.js';

package/dist/react/index.d.ts

@@ -1,3 +1,6 @@
 export * as ItemDetails from './ItemDetails.js';
+export * as ModifierGroup from './ModifierGroup.js';
 export * as ClickableItem from './ClickableItem.js';
 export * as OLO from './OLO.js';
+export * as Settings from './Settings.js';
+export * as OLOMenus from './OLOMenus.js';

package/dist/react/index.js

@@ -1,3 +1,6 @@
 export * as ItemDetails from './ItemDetails.js';
+export * as ModifierGroup from './ModifierGroup.js';
 export * as ClickableItem from './ClickableItem.js';
 export * as OLO from './OLO.js';
+export * as Settings from './Settings.js';
+export * as OLOMenus from './OLOMenus.js';

package/dist/services/common-types.d.ts

@@ -1,6 +1,24 @@
 import * as currentCart from '@wix/auto_sdk_ecom_current-cart';
 export type LineItem = currentCart.LineItem;
 export type DescriptionLine = currentCart.DescriptionLine;
+export declare enum RuleType {
+    NO_LIMIT = "NO_LIMIT",
+    CHOOSE_ONE = "CHOOSE_ONE",
+    CHOOSE_X = "CHOOSE_X",
+    CHOOSE_AT_LEAST_ONE = "CHOOSE_AT_LEAST_ONE",
+    CHOOSE_AT_LEAST_X = "CHOOSE_AT_LEAST_X",
+    CHOOSE_UP_TO_X = "CHOOSE_UP_TO_X",
+    CHOOSE_BETWEEN_X_AND_Y = "CHOOSE_BETWEEN_X_AND_Y"
+}
+export interface RuleTypeMap {
+    [RuleType.NO_LIMIT]?: (modifierGroupName: string) => string;
+    [RuleType.CHOOSE_ONE]?: (modifierGroupName: string) => string;
+    [RuleType.CHOOSE_X]?: (modifierGroupName: string, x: number) => string;
+    [RuleType.CHOOSE_AT_LEAST_ONE]?: (modifierGroupName: string) => string;
+    [RuleType.CHOOSE_AT_LEAST_X]?: (modifierGroupName: string, x: number) => string;
+    [RuleType.CHOOSE_UP_TO_X]?: (modifierGroupName: string, x: number) => string;
+    [RuleType.CHOOSE_BETWEEN_X_AND_Y]?: (modifierGroupName: string, x: number, y: number) => string;
+}
 export declare enum AvailabilityStatus {
     AVAILABLE = 0,
     NOT_AVAILABLE = 1,

package/dist/services/common-types.js

@@ -1,3 +1,13 @@
+export var RuleType;
+(function (RuleType) {
+    RuleType["NO_LIMIT"] = "NO_LIMIT";
+    RuleType["CHOOSE_ONE"] = "CHOOSE_ONE";
+    RuleType["CHOOSE_X"] = "CHOOSE_X";
+    RuleType["CHOOSE_AT_LEAST_ONE"] = "CHOOSE_AT_LEAST_ONE";
+    RuleType["CHOOSE_AT_LEAST_X"] = "CHOOSE_AT_LEAST_X";
+    RuleType["CHOOSE_UP_TO_X"] = "CHOOSE_UP_TO_X";
+    RuleType["CHOOSE_BETWEEN_X_AND_Y"] = "CHOOSE_BETWEEN_X_AND_Y";
+})(RuleType || (RuleType = {}));
 export var AvailabilityStatus;
 (function (AvailabilityStatus) {
     AvailabilityStatus[AvailabilityStatus["AVAILABLE"] = 0] = "AVAILABLE";

package/dist/services/fulfillments-service.d.ts

@@ -0,0 +1,13 @@
+import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
+import { FulfillmentsServiceAPI, FulfillmentsServiceConfig } from '../types/fulfillments-types.js';
+export declare const FulfillmentsServiceDefinition: string & {
+    __api: FulfillmentsServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & FulfillmentsServiceAPI;
+export declare const FulfillmentsService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: FulfillmentsServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & FulfillmentsServiceAPI, FulfillmentsServiceConfig>;
+export declare const loadFulfillmentsServiceConfig: (operation?: operationsSDK.Operation) => Promise<FulfillmentsServiceConfig>;

package/dist/services/fulfillments-service.js

@@ -0,0 +1,64 @@
+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';
+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 fulfillmentsMap = new Map(config.fulfillments?.map(processFulfillmentTimeSlotByOperationList) ??
+        []);
+    const fulfillments = signalsService.signal(
+    // @ts-expect-error - operation is not typed
+    fulfillmentsMap.get(config.operation?.id ?? '') ?? []);
+    const isLoading = signalsService.signal(false);
+    const error = signalsService.signal(null);
+    const initialSelected = fulfillments.get()?.[0] ?? null;
+    const selectedFulfillment = signalsService.signal(initialSelected);
+    selectedFulfillment.set(initialSelected);
+    const setSelectedFulfillment = (fulfillment) => {
+        selectedFulfillment.set(fulfillment);
+    };
+    if (!config.fulfillments && config.operation) {
+        loadFulfillmentsServiceConfig(config.operation).then((config) => {
+            const fulfillmentsMap = new Map(config.fulfillments?.map(processFulfillmentTimeSlotByOperationList) ?? []);
+            fulfillments.set(
+            // @ts-expect-error - operation is not typed
+            fulfillmentsMap.get(config.operation?.id ?? '') ?? []);
+            const initialSelected = fulfillments.get()?.[0] ?? null;
+            selectedFulfillment.set(initialSelected);
+        });
+    }
+    return {
+        fulfillments,
+        selectedFulfillment,
+        isLoading,
+        error,
+        setSelectedFulfillment,
+    };
+});
+export const loadFulfillmentsServiceConfig = async (operation) => {
+    const [timeSlots, fulfillments] = await Promise.all([
+        operationsSDK.calculateFirstAvailableTimeSlotsPerOperation([
+            // @ts-expect-error - operation is not typed
+            operation.id,
+        ]),
+        fulfillemtMethodsSDK
+            .queryFulfillmentMethods()
+            .in('_id', operation?.fulfillmentIds)
+            .find(),
+    ]);
+    // const fulfillments = await operationsSDK.calculateFirstAvailableTimeSlotsPerOperation([
+    //   operationId,
+    // ]);
+    console.log('fulfillments', fulfillments.items);
+    // const fulfillmentsMap = new Map(fulfillments.timeSlotsPerOperation?.map(processFulfillmentTimeSlotByOperationList));
+    return {
+        fulfillments: timeSlots.timeSlotsPerOperation, //fulfillmentsMap.get(operationId) ?? [],
+        operation: operation,
+    };
+};

package/dist/services/index.d.ts

@@ -1,3 +1,4 @@
 export { ItemService, ItemServiceDefinition, loadItemServiceConfig, ItemServiceConfig, } from './item-details-service.js';
 export { OLOSettingsService, OLOSettingsServiceDefinition, loadOLOSettingsServiceConfig, type OLOSettingsServiceConfig, type OLOSettingsServiceAPI, } from './olo-settings-service.js';
 export { AvailabilityStatus, AvailabilityStatusMap } from './common-types.js';
+export { FulfillmentsService, FulfillmentsServiceDefinition, loadFulfillmentsServiceConfig, } from './fulfillments-service.js';

package/dist/services/index.js

@@ -1,3 +1,4 @@
 export { ItemService, ItemServiceDefinition, loadItemServiceConfig, } from './item-details-service.js';
 export { OLOSettingsService, OLOSettingsServiceDefinition, loadOLOSettingsServiceConfig, } from './olo-settings-service.js';
 export { AvailabilityStatus } from './common-types.js';
+export { FulfillmentsService, FulfillmentsServiceDefinition, loadFulfillmentsServiceConfig, } from './fulfillments-service.js';

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

@@ -23,6 +23,8 @@ export interface ItemServiceAPI {
     isLoading: Signal<boolean>;
     /** Reactive signal containing any error message, or null if no error */
     error: Signal<string | null>;
+    /** Reactive signal containing error state for each modifier group */
+    modifierGroupError: Signal<Record<string, boolean>>;
     /** Function to update the quantity of the item */
     updateQuantity: (quantity: number) => void;
     /** Function to update the special request of the item */

package/dist/services/item-details-service.js

@@ -58,8 +58,14 @@ export const ItemService = implementService.withConfig()(ItemServiceDefinition,
     const modifierGroups = config.item?.modifierGroups || [];
     const initialSelectedModifiers = getModifiersInitState(modifierGroups);
     const selectedModifiers = signalsService.signal(initialSelectedModifiers);
+    const initialModifierGroupError = modifierGroups.reduce((acc, group) => {
+        if (group._id) {
+            acc[group._id] = false;
+        }
+        return acc;
+    }, {});
+    const modifierGroupError = signalsService.signal(initialModifierGroupError);
     if (config.item) {
-        console.log('config.item', config.item);
         lineItem.set({
             quantity: quantity.get(),
             catalogReference: {
@@ -150,6 +156,7 @@ export const ItemService = implementService.withConfig()(ItemServiceDefinition,
         selectedModifiers,
         availabilityStatus,
         getSelectedModifiers,
+        modifierGroupError,
     };
 });
 /**

package/dist/services/olo-settings-service.d.ts

@@ -1,18 +1,22 @@
-import * as operationGroupsApi from '@wix/auto_sdk_restaurants_operation-groups';
-import * as operationsApi from '@wix/auto_sdk_restaurants_operations';
+import { operations as operationsSDK, operationGroups as operationGroupsSDK } from '@wix/restaurants';
 import { type Signal } from '@wix/services-definitions/core-services/signals';
+import { MenusServiceConfig } from '@wix/restaurants/services';
 export interface OLOSettingsServiceAPI {
-    operationGroup: Signal<operationGroupsApi.OperationGroup | undefined>;
-    operation: Signal<operationsApi.Operation | undefined>;
+    operationGroup: Signal<operationGroupsSDK.OperationGroup | undefined>;
+    operation: Signal<operationsSDK.Operation | undefined>;
     selectedItem?: Signal<unknown>;
     isLoading: Signal<boolean>;
     error: Signal<string | null>;
     availabilityDispatchAction?: Signal<(() => void) | undefined>;
+    currentFulfillment: Signal<string>;
+    currentTimeSlot: Signal<string>;
+    filterMenus: (menus: MenusServiceConfig['menus']) => MenusServiceConfig['menus'];
 }
 export interface OLOSettingsServiceConfig {
-    operationGroup?: operationGroupsApi.OperationGroup;
-    operation?: operationsApi.Operation;
+    operationGroup?: operationGroupsSDK.OperationGroup;
+    operation?: operationsSDK.Operation;
     availabilityDispatchAction?: () => void;
+    menuIdsByOperation?: string[];
 }
 export declare const OLOSettingsServiceDefinition: string & {
     __api: OLOSettingsServiceAPI;
@@ -25,8 +29,9 @@ export declare const OLOSettingsService: import("@wix/services-definitions").Ser
     isServiceDefinition?: boolean;
 } & OLOSettingsServiceAPI, OLOSettingsServiceConfig>;
 export declare function loadOLOSettingsServiceConfig(): Promise<{
-    operationGroup: operationGroupsApi.OperationGroup | undefined;
-    operation: operationsApi.Operation | undefined;
+    operationGroup: operationGroupsSDK.OperationGroup | undefined;
+    operation: import("../types/operation.js").Operation;
+    menuIdsByOperation: (string | null | undefined)[];
     isLoading?: undefined;
     error?: undefined;
 } | {
@@ -34,4 +39,5 @@ export declare function loadOLOSettingsServiceConfig(): Promise<{
     operation: undefined;
     isLoading: boolean;
     error: string;
+    menuIdsByOperation?: undefined;
 }>;

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

@@ -1,7 +1,7 @@
 import { defineService, implementService } from '@wix/services-definitions';
-import * as operationGroupsApi from '@wix/auto_sdk_restaurants_operation-groups';
-import * as operationsApi from '@wix/auto_sdk_restaurants_operations';
+import { operations as operationsSDK, operationGroups as operationGroupsSDK, menuOrderingSettings as menuOrderingSettingsSDK, } from '@wix/restaurants';
 import { SignalsServiceDefinition, } from '@wix/services-definitions/core-services/signals';
+import { OperationMapper } from '../mappers/operation-mapper.js';
 export const OLOSettingsServiceDefinition = defineService('oloSettings');
 export const OLOSettingsService = implementService.withConfig()(OLOSettingsServiceDefinition, ({ getService, config }) => {
     const signalsService = getService(SignalsServiceDefinition);
@@ -11,6 +11,12 @@ export const OLOSettingsService = implementService.withConfig()(OLOSettingsServi
     const selectedItem = signalsService.signal(null);
     const isLoading = signalsService.signal(false);
     const error = signalsService.signal(null);
+    const currentFulfillment = signalsService.signal('Pickup');
+    const currentTimeSlot = signalsService.signal('10-14');
+    // const isAsap = operation.get()?.orderSchedulingType === OrderSchedulingType.ASAP;
+    const filterMenus = (menus) => {
+        return menus?.filter((menu) => menu.visible && config.menuIdsByOperation?.includes(menu._id || ''));
+    };
     return {
         operationGroup,
         operation,
@@ -18,18 +24,31 @@ export const OLOSettingsService = implementService.withConfig()(OLOSettingsServi
         error,
         selectedItem,
         availabilityDispatchAction,
+        currentFulfillment,
+        currentTimeSlot,
+        filterMenus,
     };
 });
 export async function loadOLOSettingsServiceConfig() {
     try {
         // Fetch operation groups and operations in parallel
         const [operationGroupsResponse, operationsResponse] = await Promise.all([
-            operationGroupsApi.queryOperationGroups().find(),
-            operationsApi.queryOperation().find(),
+            operationGroupsSDK.queryOperationGroups().find(),
+            operationsSDK.queryOperation().find(),
         ]);
+        const [currentOperation] = operationsResponse.items;
+        if (!currentOperation) {
+            throw new Error('Operation not found');
+        }
+        const operation = OperationMapper(currentOperation);
+        const menuIdsByOperation = await menuOrderingSettingsSDK
+            .queryMenuOrderingSettings()
+            .in('operationId', operationsResponse.items[0]?._id)
+            .find();
         return {
             operationGroup: operationGroupsResponse.items[0] || undefined,
-            operation: operationsResponse.items[0] || undefined,
+            operation,
+            menuIdsByOperation: menuIdsByOperation.items.map((menu) => menu.menuId),
         };
     }
     catch (error) {