@wix/headless-restaurants-olo 0.0.14 → 0.0.16

package/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/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/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;
+}

package/dist/types/fulfillments-types.js

@@ -0,0 +1,7 @@
+export var DispatchType;
+(function (DispatchType) {
+    /** Pickup fulfillment */
+    DispatchType["PICKUP"] = "PICKUP";
+    /** Delivery fulfillment */
+    DispatchType["DELIVERY"] = "DELIVERY";
+})(DispatchType || (DispatchType = {}));

package/dist/types/operation.d.ts

@@ -0,0 +1,57 @@
+import { DispatchType } from './fulfillments-types.js';
+export type MinMaxRange = {
+    min: number;
+    max: number;
+};
+export type AsapScheduling = {
+    maxInMinutes?: number;
+    rangeInMinutes?: MinMaxRange;
+};
+export type PreorderScheduling = {
+    timeWindowDuration: number;
+    timeInAdvance: MinMaxRange;
+};
+export type OperationType = 'PRE_ORDER' | 'ASAP';
+type BaseOperation = {
+    id: string;
+    name: string;
+};
+export interface StreetAddress {
+    apt?: String;
+    formattedAddressLine?: String;
+    name?: String;
+    number?: String;
+}
+export interface Address {
+    addressLine?: String;
+    addressLine2?: String;
+    city?: String;
+    country?: String;
+    countryFullname?: String;
+    formattedAddress?: String;
+    hint?: String;
+    postalCode?: String;
+    streetAddress?: StreetAddress;
+    subdivision?: String;
+    subdivisionFullname?: String;
+}
+export type OSLocation = {
+    name: string;
+    address?: Address;
+    default?: boolean;
+    timeZone?: string;
+};
+export type Operation = BaseOperation & {
+    enabled: boolean;
+    fulfillmentIds: string[];
+    asapOptions?: AsapScheduling;
+    allowAsapFutureHandling?: boolean;
+    businessDaysAheadHandlingOptions?: number;
+    operationType: OperationType;
+    preOrderOptions?: PreorderScheduling;
+    defaultDispatchType?: DispatchType;
+    operationGroupId: string;
+    locationId: string;
+    locationDetails?: OSLocation;
+};
+export {};

package/dist/types/operation.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,23 @@
+import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
+import { TimeSlot } from '../types/fulfillments-types.js';
+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[];
+export declare function getMinTime(info: operationsSDK.FulfillmentInfo): number;
+export declare function getFastestTimeOptionsByFulfillmentInfo(arr: operationsSDK.FulfillmentInfo[]): operationsSDK.FulfillmentInfo[];
+export declare function getSlowestTimeOptionByFulfillmentInfo(arr: operationsSDK.FulfillmentInfo[]): operationsSDK.FulfillmentInfo;
+export declare const createTimeRangeByFulfillmentInfo: (arr: operationsSDK.FulfillmentInfo[]) => {
+    maxTimeOptions: number | undefined;
+    durationRangeOptions?: undefined;
+} | {
+    durationRangeOptions: {
+        minDuration: number | undefined;
+        maxDuration: number | undefined;
+    };
+    maxTimeOptions?: undefined;
+};
+export declare function hasSameTime(arr: operationsSDK.FulfillmentDetails[]): boolean;
+export declare const resolveDifferentMinOrderPriceOptionByFulfillmentInfo: (fulfillmentInfo: operationsSDK.FulfillmentInfo[]) => operationsSDK.FulfillmentInfo | undefined;
+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];

package/dist/utils/fulfillments-utils.js

@@ -0,0 +1,144 @@
+import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
+import { DispatchType } from '../types/fulfillments-types.js';
+export const createTimeSlotId = (startTime, endTime, maxTimeOptions = 0) => 
+// maxTimeOptions is used to avoid collisions when order pacing is enabled
+`${startTime?.toUTCString()}-${endTime?.toUTCString()}-${maxTimeOptions}`;
+export function hasSameByField(field, arr) {
+    const [first, ...rest] = arr;
+    return rest.every((item) => item[field] === first?.[field]);
+}
+export function getMinValueObjects(key, arr) {
+    return arr.slice(1).reduce((min, item) => {
+        if (Number(item[key]) < Number(min[0]?.[key])) {
+            return [item];
+        }
+        else if (Number(item[key]) === Number(min[0]?.[key])) {
+            return [...min, item];
+        }
+        return min;
+    }, (arr[0] ? [arr[0]] : []));
+}
+export function getMinTime(info) {
+    return info.durationRange
+        ? Number(info.durationRange.minDuration)
+        : Number(info.maxTime);
+}
+export function getFastestTimeOptionsByFulfillmentInfo(arr) {
+    const [first, ...rest] = arr;
+    if (!first) {
+        return [];
+    }
+    return rest.reduce((fastestOptions, current) => {
+        const currentTime = getMinTime(current);
+        const fastestTime = getMinTime(fastestOptions[0]);
+        if (currentTime < fastestTime) {
+            return [current];
+        }
+        else if (currentTime === fastestTime) {
+            return [...fastestOptions, current];
+        }
+        return fastestOptions;
+    }, [first]);
+}
+export function getSlowestTimeOptionByFulfillmentInfo(arr) {
+    return arr.reduce((max, item) => {
+        const { durationRange, maxTime: maxTimeOptions } = item;
+        let maxTime;
+        if (max.durationRange) {
+            maxTime = Number(max.durationRange?.maxDuration || 0);
+        }
+        else {
+            maxTime = Number(max.maxTime || 0);
+        }
+        if (durationRange) {
+            return Number(durationRange.maxDuration) > maxTime ? item : max;
+        }
+        else {
+            return Number(maxTimeOptions) > maxTime ? item : max;
+        }
+    }, {});
+}
+export const createTimeRangeByFulfillmentInfo = (arr) => {
+    const fastestOption = getFastestTimeOptionsByFulfillmentInfo(arr)[0];
+    const slowestOption = getSlowestTimeOptionByFulfillmentInfo(arr);
+    const minDuration = fastestOption?.durationRange?.minDuration ?? fastestOption?.maxTime;
+    const maxDuration = slowestOption.durationRange?.maxDuration ?? slowestOption.maxTime;
+    if (minDuration === maxDuration) {
+        return { maxTimeOptions: minDuration };
+    }
+    else {
+        return { durationRangeOptions: { minDuration, maxDuration } };
+    }
+};
+export function hasSameTime(arr) {
+    return (hasSameByField('fulfillmentTimeType', arr) &&
+        (arr[0]?.fulfillmentTimeType === operationsSDK.FulfillmentTimeType.MAX_TIME
+            ? hasSameByField('maxTimeOptions', arr)
+            : arr.every((details) => {
+                const { durationRangeOptions } = details;
+                return (durationRangeOptions?.maxDuration ===
+                    arr[0]?.durationRangeOptions?.maxDuration &&
+                    durationRangeOptions?.minDuration ===
+                        arr[0]?.durationRangeOptions?.minDuration);
+            })));
+}
+export const resolveDifferentMinOrderPriceOptionByFulfillmentInfo = (fulfillmentInfo) => {
+    const hasSameFee = hasSameByField('fee', fulfillmentInfo);
+    if (hasSameFee && hasSameTime(fulfillmentInfo)) {
+        // if fee and time are the same, return the object with the min order price with the min free delivery price threshold
+        return getMinValueObjects('freeFulfillmentPriceThreshold', getMinValueObjects('minOrderPrice', fulfillmentInfo))[0];
+    }
+    else {
+        // if the fee is the same and time is different, return the fee
+        const fee = hasSameFee ? fulfillmentInfo[0]?.fee : undefined;
+        // if free delivery price threshold is the same, return free delivery price threshold
+        const freeFulfillmentPriceThreshold = hasSameByField('freeFulfillmentPriceThreshold', fulfillmentInfo)
+            ? fulfillmentInfo[0]?.freeFulfillmentPriceThreshold
+            : undefined;
+        // create a time range object from all the fulfillments
+        return {
+            fee,
+            ...createTimeRangeByFulfillmentInfo(fulfillmentInfo),
+            freeFulfillmentPriceThreshold,
+        };
+    }
+};
+export const resolveSameMinOrderPriceOptionByFulfillmentInfo = (fulfillmentInfo) => {
+    // filtering fulfillment details by order of precedent: fee, time, free delivery price threshold
+    const cheapestFulfillmentInfo = getMinValueObjects('fee', fulfillmentInfo);
+    const fastestFulfillmentInfo = getFastestTimeOptionsByFulfillmentInfo(cheapestFulfillmentInfo);
+    return getMinValueObjects('freeFulfillmentPriceThreshold', fastestFulfillmentInfo)[0];
+};
+export const resolveFulfillmentInfo = (fulfillmentInfo) => {
+    if (hasSameByField('minOrderPrice', fulfillmentInfo)) {
+        return resolveSameMinOrderPriceOptionByFulfillmentInfo(fulfillmentInfo);
+    }
+    else {
+        return resolveDifferentMinOrderPriceOptionByFulfillmentInfo(fulfillmentInfo);
+    }
+};
+export const processFulfillmentTimeSlotByOperationList = (operationTimeSlot) => {
+    return [
+        operationTimeSlot.operationId ?? '',
+        operationTimeSlot.timeslotsPerFulfillmentType?.map((fulfillmentTimeSlot) => {
+            const { timeSlot, fulfilmentType, fulfillmentInfo } = fulfillmentTimeSlot;
+            const { startTime, endTime, orderSchedulingType } = timeSlot ?? {};
+            const selectedFulfillmentInfo = resolveFulfillmentInfo(fulfillmentInfo);
+            const fulfillmentDetails = {
+                maxTimeOptions: selectedFulfillmentInfo?.maxTime,
+                durationRangeOptions: selectedFulfillmentInfo?.durationRange,
+                ...selectedFulfillmentInfo,
+            };
+            return {
+                id: createTimeSlotId(startTime, endTime),
+                startTime: startTime,
+                endTime: endTime,
+                dispatchType: fulfilmentType === 'DELIVERY'
+                    ? DispatchType.DELIVERY
+                    : DispatchType.PICKUP,
+                startsNow: orderSchedulingType === operationsSDK.OrderSchedulingType.ASAP,
+                fulfillmentDetails,
+            };
+        }),
+    ];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/headless-restaurants-olo",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -40,6 +40,7 @@
     "@typescript-eslint/eslint-plugin": "^6.21.0",
     "@typescript-eslint/parser": "^6.21.0",
     "@vitest/ui": "^3.1.4",
+    "@wix/headless-components": "0.0.0",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-react": "^7.34.1",
@@ -55,8 +56,9 @@
     "@radix-ui/react-slot": "^1.1.0",
     "@wix/auto_sdk_restaurants_items": "^1.0.48",
     "@wix/ecom": "^1.0.1461",
+    "@wix/headless-components": "0.0.26",
     "@wix/headless-media": "0.0.17",
-    "@wix/headless-restaurants-menus": "0.0.19",
+    "@wix/headless-restaurants-menus": "0.0.20",
     "@wix/headless-utils": "0.0.7",
     "@wix/redirects": "^1.0.0",
     "@wix/restaurants": "^1.0.396",
@@ -64,9 +66,6 @@
     "@wix/services-definitions": "^0.1.4",
     "@wix/services-manager-react": "^0.1.26"
   },
-  "peerDependencies": {
-    "@wix/headless-components": "^0.0.0"
-  },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -77,5 +76,5 @@
       "groupId": "com.wixpress.headless-components"
     }
   },
-  "falconPackageHash": "d55bda80573cab9d81fb40395046c186392cfb841af6c59bd7eb2e07"
+  "falconPackageHash": "916d8efd6fea1907af999eee9708352f2f73eb4fabb59d25b129c9fc"
 }