@wix/headless-restaurants-olo 0.0.14 → 0.0.16

package/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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) {

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

@@ -1,4 +1,10 @@
 import type { EnhancedModifier, EnhancedModifierGroup } from '@wix/headless-restaurants-menus/services';
+import { RuleType, RuleTypeMap } from './common-types.js';
+interface ruleUtilsArgs {
+    required: boolean;
+    minSelections: number;
+    maxSelections?: number | null;
+}
 export declare const getModifiersInitState: (modifierGroups: EnhancedModifierGroup[]) => Record<string, string[]>;
 export declare const isSingleSelectRule: (rule: NonNullable<EnhancedModifierGroup["rule"]>) => boolean | null | undefined;
 export declare const getFirstPreSelectedModifier: (modifiers: EnhancedModifier[]) => string | null | undefined;
@@ -18,3 +24,14 @@ export declare const convertModifierToFormModifier: (modifier: EnhancedModifier,
     };
     preSelected?: boolean;
 };
+export declare const getModifierGroupRuleType: (modifierGroupRule: EnhancedModifierGroup["rule"]) => RuleType;
+export declare const hasNoLimit: ({ required, minSelections, maxSelections, }: ruleUtilsArgs) => boolean;
+export declare const canChooseOne: ({ required, minSelections, maxSelections, }: ruleUtilsArgs) => boolean;
+export declare const hasToChooseOne: ({ required, minSelections, maxSelections, }: ruleUtilsArgs) => boolean;
+export declare const hasToChooseX: ({ required, minSelections, maxSelections, }: ruleUtilsArgs) => boolean | 0 | null | undefined;
+export declare const hasToChooseAtLeastOne: ({ required, minSelections, maxSelections, }: ruleUtilsArgs) => boolean;
+export declare const hasToChooseAtLeastX: ({ required, minSelections, maxSelections, }: ruleUtilsArgs) => boolean;
+export declare const chooseUpToX: ({ required, minSelections, maxSelections, }: ruleUtilsArgs) => boolean;
+export declare const hasToChooseBetweenXAndY: ({ required, minSelections, maxSelections, }: ruleUtilsArgs) => boolean;
+export declare const getRuleTypeMapValue: (ruleTypeMap: RuleTypeMap, ruleType: RuleType, modifierGroupName: string, rule: EnhancedModifierGroup["rule"]) => string | undefined;
+export {};

package/cjs/dist/services/utils.js

@@ -1,3 +1,4 @@
+import { RuleType } from './common-types.js';
 export const getModifiersInitState = (modifierGroups) => {
     const initialSelectedModifiers = {};
     modifierGroups.forEach((group) => {
@@ -32,3 +33,106 @@ export const convertModifierToFormModifier = (modifier, index) => {
         _id: `${modifier._id}~${index}`,
     };
 };
+export const getModifierGroupRuleType = (modifierGroupRule) => {
+    const required = modifierGroupRule?.required ?? false;
+    const minSelections = modifierGroupRule?.minSelections ?? 0;
+    const maxSelections = modifierGroupRule?.maxSelections;
+    const ruleFields = { required, minSelections, maxSelections };
+    if (hasNoLimit(ruleFields)) {
+        return RuleType.NO_LIMIT;
+    }
+    if (hasToChooseOne(ruleFields) || canChooseOne(ruleFields)) {
+        return RuleType.CHOOSE_ONE;
+    }
+    if (hasToChooseX(ruleFields)) {
+        return RuleType.CHOOSE_X;
+    }
+    if (hasToChooseAtLeastOne(ruleFields)) {
+        return RuleType.CHOOSE_AT_LEAST_ONE;
+    }
+    if (hasToChooseAtLeastX(ruleFields)) {
+        return RuleType.CHOOSE_AT_LEAST_X;
+    }
+    if (chooseUpToX(ruleFields)) {
+        return RuleType.CHOOSE_UP_TO_X;
+    }
+    if (hasToChooseBetweenXAndY(ruleFields)) {
+        return RuleType.CHOOSE_BETWEEN_X_AND_Y;
+    }
+    return RuleType.NO_LIMIT;
+};
+const hasNoValue = (variable) => variable === null || variable === undefined;
+export const hasNoLimit = ({ required, minSelections, maxSelections, }) => !required && minSelections < 1 && (maxSelections ? maxSelections < 1 : true);
+export const canChooseOne = ({ required, minSelections, maxSelections, }) => !required &&
+    minSelections === 0 &&
+    (maxSelections ? maxSelections === 1 : false);
+export const hasToChooseOne = ({ required, minSelections, maxSelections, }) => required &&
+    minSelections === 1 &&
+    (maxSelections ? maxSelections === 1 : false);
+export const hasToChooseX = ({ required, minSelections, maxSelections, }) => required ? maxSelections && minSelections === maxSelections : false;
+export const hasToChooseAtLeastOne = ({ required, minSelections, maxSelections, }) => required ? minSelections === 1 && hasNoValue(maxSelections) : false;
+export const hasToChooseAtLeastX = ({ required, minSelections, maxSelections, }) => required ? minSelections > 1 && hasNoValue(maxSelections) : false;
+export const chooseUpToX = ({ required, minSelections, maxSelections, }) => !required &&
+    minSelections === 0 &&
+    (maxSelections ? maxSelections > 1 : false);
+export const hasToChooseBetweenXAndY = ({ required, minSelections, maxSelections, }) => required
+    ? maxSelections
+        ? minSelections > 0 && maxSelections > minSelections
+        : false
+    : false;
+export const getRuleTypeMapValue = (ruleTypeMap, ruleType, modifierGroupName, rule) => {
+    const minSelections = rule?.minSelections ?? 0;
+    const maxSelections = rule?.maxSelections;
+    switch (ruleType) {
+        case RuleType.NO_LIMIT: {
+            const callback = ruleTypeMap[RuleType.NO_LIMIT];
+            if (callback) {
+                return callback(modifierGroupName);
+            }
+            break;
+        }
+        case RuleType.CHOOSE_ONE: {
+            const callback = ruleTypeMap[RuleType.CHOOSE_ONE];
+            if (callback) {
+                return callback(modifierGroupName);
+            }
+            break;
+        }
+        case RuleType.CHOOSE_X: {
+            const callback = ruleTypeMap[RuleType.CHOOSE_X];
+            if (callback) {
+                return callback(modifierGroupName, minSelections);
+            }
+            break;
+        }
+        case RuleType.CHOOSE_AT_LEAST_ONE: {
+            const callback = ruleTypeMap[RuleType.CHOOSE_AT_LEAST_ONE];
+            if (callback) {
+                return callback(modifierGroupName);
+            }
+            break;
+        }
+        case RuleType.CHOOSE_AT_LEAST_X: {
+            const callback = ruleTypeMap[RuleType.CHOOSE_AT_LEAST_X];
+            if (callback) {
+                return callback(modifierGroupName, minSelections);
+            }
+            break;
+        }
+        case RuleType.CHOOSE_UP_TO_X: {
+            const callback = ruleTypeMap[RuleType.CHOOSE_UP_TO_X];
+            if (callback && maxSelections) {
+                return callback(modifierGroupName, maxSelections);
+            }
+            break;
+        }
+        case RuleType.CHOOSE_BETWEEN_X_AND_Y: {
+            const callback = ruleTypeMap[RuleType.CHOOSE_BETWEEN_X_AND_Y];
+            if (callback && maxSelections) {
+                return callback(modifierGroupName, minSelections, maxSelections);
+            }
+            break;
+        }
+    }
+    return undefined;
+};

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

@@ -0,0 +1,33 @@
+import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
+import { Signal } from '@wix/services-definitions/core-services/signals';
+export declare enum DispatchType {
+    /** Pickup fulfillment */
+    PICKUP = "PICKUP",
+    /** Delivery fulfillment */
+    DELIVERY = "DELIVERY"
+}
+export type TimeSlot = {
+    id: string;
+    startTime: Date;
+    endTime: Date;
+    dispatchType: DispatchType;
+    startsNow?: boolean;
+    fulfillmentDetails: operationsSDK.FulfillmentDetails;
+};
+export interface Fulfillment {
+    id: string;
+    name: string;
+    type: string;
+    isAvailable: boolean;
+}
+export interface FulfillmentsServiceAPI {
+    fulfillments: Signal<TimeSlot[]>;
+    selectedFulfillment: Signal<TimeSlot | null>;
+    isLoading: Signal<boolean>;
+    error: Signal<string | null>;
+    setSelectedFulfillment: (fulfillment: TimeSlot) => void;
+}
+export interface FulfillmentsServiceConfig {
+    fulfillments?: operationsSDK.TimeSlotForOperation[];
+    operation?: operationsSDK.Operation;
+}