@wix/headless-restaurants-olo 0.0.13 → 0.0.15

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) {

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,10 +1,10 @@
 {
   "name": "@wix/headless-restaurants-olo",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "license": "MIT",
   "type": "module",
   "scripts": {
-    "prebuild": "cd ../components && yarn build && cd ../ecom && yarn build",
+    "prebuild": "cd ../ecom && yarn build",
     "build": "npm run build:esm && npm run build:cjs",
     "build:esm": "tsc -p tsconfig.json",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -56,7 +56,7 @@
     "@wix/auto_sdk_restaurants_items": "^1.0.48",
     "@wix/ecom": "^1.0.1461",
     "@wix/headless-media": "0.0.17",
-    "@wix/headless-restaurants-menus": "0.0.18",
+    "@wix/headless-restaurants-menus": "0.0.19",
     "@wix/headless-utils": "0.0.7",
     "@wix/redirects": "^1.0.0",
     "@wix/restaurants": "^1.0.396",
@@ -65,7 +65,7 @@
     "@wix/services-manager-react": "^0.1.26"
   },
   "peerDependencies": {
-    "@wix/headless-components": "workspace:*"
+    "@wix/headless-components": "^0.0.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
@@ -77,5 +77,5 @@
       "groupId": "com.wixpress.headless-components"
     }
   },
-  "falconPackageHash": "490e9467e8d050af06fd05dd4ea38b634aada25dc3ed9b1385bf7d2f"
+  "falconPackageHash": "71ec66f326eb20964a9b1df3e46c9cad2246603e42239226a8cacaf6"
 }