@open-tender/cloud 0.0.1

package/dist/esm/slices/groupOrder.d.ts

@@ -0,0 +1,80 @@
+import { AppState } from '../app';
+import { CartOwner, GroupOrder, ISOString, OrderItem, RequestError, RequestStatus, ServiceType } from '@open-tender/types';
+export interface GroupOrderState {
+    cart: Array<OrderItem>;
+    cartGuest: any;
+    cartGuests: any;
+    cartId: number | null;
+    cartOwner: CartOwner | null;
+    closed: boolean;
+    cutoffAt: string | null;
+    error: RequestError;
+    guestCount: number | null;
+    guestLimit: number | null;
+    isCartOwner: boolean;
+    loading: RequestStatus;
+    requestedAt: ISOString | null;
+    revenueCenterId: number | null;
+    serviceType: ServiceType | null;
+    spendingLimit: string | null;
+    token: string | null;
+}
+export declare enum GroupOrderActionType {
+    JoinGroupOrder = "groupOrder/joinGroupOrder",
+    FetchGroupOrder = "groupOrder/fetchGroupOrder",
+    UpdateGroupOrder = "groupOrder/updateGroupOrder",
+    ReloadGuestOrder = "groupOrder/reloadGuestOrder"
+}
+export declare const makeCartPayload: (response: GroupOrder, cartGuestId?: number) => {
+    cartId: number;
+    token: string;
+    revenueCenterId: number;
+    serviceType: ServiceType;
+    requestedAt: `${number}${number}${number}${number}-${number}${number}-${number}${number}T${number}${number}:${number}${number}:${number}${number}Z`;
+    cutoffAt: string;
+    guestLimit: number;
+    guestCount: number;
+    spendingLimit: string;
+    closed: boolean;
+    cartOwner: CartOwner | null;
+    cart: OrderItem[];
+    cartGuests: any;
+};
+export declare const joinGroupOrder: import("@reduxjs/toolkit").AsyncThunk<any, {
+    cart_id: number;
+    first_name: string;
+    last_name: string;
+}, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const fetchGroupOrder: import("@reduxjs/toolkit").AsyncThunk<void | Partial<GroupOrderState>, number, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const updateGroupOrder: import("@reduxjs/toolkit").AsyncThunk<void | Partial<GroupOrderState>, void, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const reloadGuestOrder: import("@reduxjs/toolkit").AsyncThunk<void, void, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const resetGroupOrder: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectGroupOrder: (state: AppState) => GroupOrderState;
+export declare const selectGroupOrderToken: (state: AppState) => string | null;
+export declare const selectSpendingLimit: (state: AppState) => number | null;
+export declare const selectGroupOrderClosed: (state: AppState) => any;
+export declare const selectGroupOrderTests: (state: AppState) => {
+    closed: boolean;
+    pastCutoff: boolean;
+    atCapacity: boolean;
+};
+export declare const selectGroupOrderPrepTimes: (state: AppState) => {
+    prepTime?: undefined;
+    leadTime?: undefined;
+} | {
+    prepTime: number;
+    leadTime: number | undefined;
+};
+export declare const groupOrderReducer: import("redux").Reducer<GroupOrderState, import("redux").AnyAction>;

package/dist/esm/slices/groupOrder.js

@@ -0,0 +1,216 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+import { resetOrder, selectTimezone, setCart, setMenuVars } from './order';
+import { isoToDate, makeSimpleCart, rehydrateCart } from '@open-tender/utils';
+const initialState = {
+    cartId: null,
+    token: null,
+    revenueCenterId: null,
+    serviceType: null,
+    requestedAt: null,
+    cutoffAt: null,
+    guestLimit: null,
+    guestCount: null,
+    spendingLimit: null,
+    closed: false,
+    isCartOwner: false,
+    cartOwner: null,
+    cartGuest: null,
+    cartGuests: [],
+    cart: [],
+    error: null,
+    loading: 'idle'
+};
+export var GroupOrderActionType;
+(function (GroupOrderActionType) {
+    GroupOrderActionType["JoinGroupOrder"] = "groupOrder/joinGroupOrder";
+    GroupOrderActionType["FetchGroupOrder"] = "groupOrder/fetchGroupOrder";
+    GroupOrderActionType["UpdateGroupOrder"] = "groupOrder/updateGroupOrder";
+    GroupOrderActionType["ReloadGuestOrder"] = "groupOrder/reloadGuestOrder";
+})(GroupOrderActionType || (GroupOrderActionType = {}));
+export const makeCartPayload = (response, cartGuestId) => {
+    const { customer = null, closed, cart_id: cartId, token, cart, revenue_center_id: revenueCenterId, service_type: serviceType, requested_at: requestedAt, cutoff_at: cutoffAt, spending_limit: spendingLimit, guest_limit: guestLimit, guest_count: guestCount, cart_guests: cartGuests } = response;
+    const filteredCart = cartGuestId
+        ? cart.filter(i => i.cart_guest_id === cartGuestId)
+        : cart;
+    return {
+        cartId,
+        token,
+        revenueCenterId,
+        serviceType,
+        requestedAt,
+        cutoffAt,
+        guestLimit,
+        guestCount,
+        spendingLimit,
+        closed,
+        cartOwner: customer,
+        cart: filteredCart,
+        cartGuests: cartGuests || []
+    };
+};
+export const joinGroupOrder = createAsyncThunk(GroupOrderActionType.JoinGroupOrder, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return null;
+    try {
+        const data = {
+            cart_id: requestData.cart_id,
+            first_name: requestData.first_name,
+            last_name: requestData.last_name
+        };
+        const response = yield api.postCartGuest(data);
+        const { cart_guest_id: cartGuestId, first_name: firstName, last_name: lastName } = response;
+        const { revenueCenter } = getState().order;
+        dispatch(resetOrder());
+        const { serviceType, requestedAt } = getState().groupOrder;
+        dispatch(setMenuVars({ revenueCenter, serviceType, requestedAt }));
+        dispatch(setCart([]));
+        const payload = { cartGuestId, firstName, lastName };
+        return payload;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+export const fetchGroupOrder = createAsyncThunk(GroupOrderActionType.FetchGroupOrder, (id, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const response = yield api.getCart(id);
+        const { cartGuest } = getState().groupOrder;
+        const cartGuestId = cartGuest ? cartGuest.cartGuestId : null;
+        const payload = makeCartPayload(response, cartGuestId);
+        return payload;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+export const updateGroupOrder = createAsyncThunk(GroupOrderActionType.UpdateGroupOrder, (_, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const { api } = getState().config;
+    if (!api)
+        return;
+    const { cartId, cartGuest } = getState().groupOrder;
+    try {
+        const data = {
+            cart: makeSimpleCart((_a = getState().order.cart) !== null && _a !== void 0 ? _a : []),
+            cart_guest_id: cartGuest.cartGuestId
+        };
+        const response = yield api.putCart(cartId, data);
+        const payload = makeCartPayload(response, cartGuest.cartGuestId);
+        return payload;
+    }
+    catch (err) {
+        yield dispatch(fetchGroupOrder(cartId));
+        return rejectWithValue(err);
+    }
+}));
+export const reloadGuestOrder = createAsyncThunk(GroupOrderActionType.ReloadGuestOrder, (_, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const { revenueCenterId, serviceType } = getState().groupOrder;
+        const { cart: items } = getState().groupOrder;
+        const menuItems = yield api.getMenuItems(revenueCenterId, serviceType);
+        const { cart } = rehydrateCart(menuItems, items);
+        dispatch(setCart(cart));
+        return;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+const groupOrderSlice = createSlice({
+    name: ReducerType.GroupOrder,
+    initialState,
+    reducers: {
+        resetGroupOrder: () => initialState,
+        deleteGroupOrder: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(joinGroupOrder.fulfilled, (state, action) => {
+            state.loading = 'idle';
+            state.error = null;
+            state.cartGuest = action.payload;
+        })
+            .addCase(joinGroupOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(joinGroupOrder.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        })
+            .addCase(fetchGroupOrder.fulfilled, (state, action) => {
+            state = Object.assign(Object.assign(Object.assign({}, state), { loading: 'idle', error: null }), action.payload);
+        })
+            .addCase(fetchGroupOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchGroupOrder.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        })
+            .addCase(updateGroupOrder.fulfilled, (state, action) => {
+            state = Object.assign(Object.assign(Object.assign({}, state), { loading: 'idle', error: null }), action.payload);
+        })
+            .addCase(updateGroupOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(updateGroupOrder.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        })
+            .addCase(reloadGuestOrder.fulfilled, state => {
+            state.loading = 'idle';
+        })
+            .addCase(reloadGuestOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(reloadGuestOrder.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        });
+    }
+});
+export const { resetGroupOrder } = groupOrderSlice.actions;
+export const selectGroupOrder = (state) => state.groupOrder;
+export const selectGroupOrderToken = (state) => state.groupOrder.token;
+export const selectSpendingLimit = (state) => {
+    const { cartGuest, spendingLimit } = state.groupOrder;
+    return cartGuest && spendingLimit ? parseFloat(spendingLimit) : null;
+};
+export const selectGroupOrderClosed = (state) => {
+    const { cartGuest, cutoffAt, closed } = state.groupOrder;
+    const tz = selectTimezone(state);
+    const cutoffDate = cutoffAt ? isoToDate(cutoffAt, tz) : null;
+    const pastCutoff = cutoffDate ? new Date() > cutoffDate : false;
+    return cartGuest && (closed || pastCutoff);
+};
+export const selectGroupOrderTests = (state) => {
+    const { closed, cutoffAt, guestLimit, guestCount } = state.groupOrder;
+    const tz = selectTimezone(state);
+    const cutoffDate = cutoffAt ? isoToDate(cutoffAt, tz) : null;
+    const pastCutoff = cutoffDate ? new Date() > cutoffDate : false;
+    const spotsRemaining = guestLimit ? guestLimit - (guestCount !== null && guestCount !== void 0 ? guestCount : 0) : null;
+    const atCapacity = spotsRemaining !== null && spotsRemaining <= 0;
+    return { closed, pastCutoff, atCapacity };
+};
+export const selectGroupOrderPrepTimes = (state) => {
+    const { revenueCenter, serviceType } = state.order;
+    if (!revenueCenter || !serviceType)
+        return {};
+    const { settings } = revenueCenter;
+    const { wait_times, group_ordering } = settings || revenueCenter;
+    const { prep_time, lead_time: leadTime } = group_ordering || {};
+    const st = serviceType === 'WALKIN' ? 'PICKUP' : serviceType;
+    const waitTime = wait_times && wait_times[st] ? wait_times[st] : 0;
+    const prepTime = (waitTime !== null && waitTime !== void 0 ? waitTime : 0) + (prep_time !== null && prep_time !== void 0 ? prep_time : 0);
+    return { prepTime, leadTime };
+};
+export const groupOrderReducer = groupOrderSlice.reducer;

package/dist/esm/slices/guest.d.ts

@@ -0,0 +1,38 @@
+import { AppState } from '../app';
+import { Brands, RequestStatus } from '@open-tender/types';
+export interface GuestState {
+    brands: Brands | null;
+    errors: any;
+    loading: RequestStatus;
+    email?: string | null;
+    showMagicLink: boolean;
+}
+export declare enum GuestActionType {
+    FetchGuest = "guest/fetchGuest",
+    FetchGuestThanx = "guest/fetchGuestThanx"
+}
+export declare const fetchGuest: import("@reduxjs/toolkit").AsyncThunk<Partial<GuestState>, {
+    email: string;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: {
+        errors: any;
+        email: string;
+    };
+}>;
+export declare const fetchGuestThanx: import("@reduxjs/toolkit").AsyncThunk<void | {
+    email: string;
+}, {
+    email: string;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: {
+        errors: any;
+        email: string;
+    };
+}>;
+export declare const resetGuest: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectGuest: (state: AppState) => GuestState;
+export declare const guestReducer: import("redux").Reducer<GuestState, import("redux").AnyAction>;

package/dist/esm/slices/guest.js

@@ -0,0 +1,97 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+import { makeFormErrors } from '@open-tender/utils';
+const initialState = {
+    brands: null,
+    showMagicLink: false,
+    errors: null,
+    loading: 'idle',
+    email: null
+};
+export var GuestActionType;
+(function (GuestActionType) {
+    GuestActionType["FetchGuest"] = "guest/fetchGuest";
+    GuestActionType["FetchGuestThanx"] = "guest/fetchGuestThanx";
+})(GuestActionType || (GuestActionType = {}));
+export const fetchGuest = createAsyncThunk(GuestActionType.FetchGuest, (requestData, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const response = yield api.getGuest(requestData.email);
+        if (requestData.callback)
+            requestData.callback();
+        return response;
+    }
+    catch (err) {
+        let errors = makeFormErrors(err);
+        if (errors.form && errors.form.includes('Unknown 500 error')) {
+            errors = { form: 'Invalid email address. Please try again.' };
+        }
+        return rejectWithValue({ errors, email: requestData.email });
+    }
+}));
+export const fetchGuestThanx = createAsyncThunk(GuestActionType.FetchGuestThanx, (requestData, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        yield api.postThanxLogin(requestData.email);
+        if (requestData.callback)
+            requestData.callback();
+        return { email: requestData.email };
+    }
+    catch (err) {
+        const errors = makeFormErrors(err);
+        return rejectWithValue({ errors, email: requestData.email });
+    }
+}));
+const guestSlice = createSlice({
+    name: ReducerType.Guest,
+    initialState,
+    reducers: {
+        resetGuest: () => initialState,
+        resetGuestErrors: state => {
+            state.errors = null;
+            state.loading = 'idle';
+            state.showMagicLink = false;
+        },
+        setGuestEmail: (state, action) => {
+            state.email = action.payload;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchGuest.fulfilled, (state, action) => {
+            state = Object.assign(Object.assign(Object.assign({}, state), { loading: 'idle', errors: null }), action.payload);
+        })
+            .addCase(fetchGuest.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchGuest.rejected, (state, action) => {
+            var _a, _b;
+            state.errors = (_a = action.payload) === null || _a === void 0 ? void 0 : _a.errors;
+            state.email = (_b = action.payload) === null || _b === void 0 ? void 0 : _b.email;
+            state.loading = 'idle';
+            state.brands = null;
+        })
+            .addCase(fetchGuestThanx.fulfilled, (state, action) => {
+            state = Object.assign(Object.assign(Object.assign({}, state), { loading: 'idle', errors: null, showMagicLink: true }), action.payload);
+        })
+            .addCase(fetchGuestThanx.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchGuestThanx.rejected, (state, action) => {
+            var _a, _b;
+            state.errors = (_a = action.payload) === null || _a === void 0 ? void 0 : _a.errors;
+            state.email = (_b = action.payload) === null || _b === void 0 ? void 0 : _b.email;
+            state.loading = 'idle';
+            state.showMagicLink = false;
+            state.brands = null;
+        });
+    }
+});
+export const { resetGuest } = guestSlice.actions;
+export const selectGuest = (state) => state.guest;
+export const guestReducer = guestSlice.reducer;

package/dist/esm/slices/index.d.ts

@@ -0,0 +1,27 @@
+export * from './alerts';
+export * from './notifications';
+export * from './allergens';
+export * from './announcements';
+export * from './customer';
+export * from './signUp';
+export * from './revenueCenters';
+export * from './checkout';
+export * from './completedOrders';
+export * from './order';
+export * from './orderFulfillment';
+export * from './orderRating';
+export * from './orders';
+export * from './deals';
+export * from './confirmation';
+export * from './donations';
+export * from './guest';
+export * from './verifyAccount';
+export * from './menu';
+export * from './resetPassword';
+export * from './validTimes';
+export * from './menuItems';
+export * from './menuDisplay';
+export * from './giftCards';
+export * from './groupOrder';
+export * from './levelup';
+export * from './config';

package/dist/esm/slices/index.js

@@ -0,0 +1,27 @@
+export * from './alerts';
+export * from './notifications';
+export * from './allergens';
+export * from './announcements';
+export * from './customer';
+export * from './signUp';
+export * from './revenueCenters';
+export * from './checkout';
+export * from './completedOrders';
+export * from './order';
+export * from './orderFulfillment';
+export * from './orderRating';
+export * from './orders';
+export * from './deals';
+export * from './confirmation';
+export * from './donations';
+export * from './guest';
+export * from './verifyAccount';
+export * from './menu';
+export * from './resetPassword';
+export * from './validTimes';
+export * from './menuItems';
+export * from './menuDisplay';
+export * from './giftCards';
+export * from './groupOrder';
+export * from './levelup';
+export * from './config';

package/dist/esm/slices/levelup.d.ts

@@ -0,0 +1,18 @@
+import { AppState } from '../app';
+import { RequestError, RequestStatus } from '@open-tender/types';
+export interface LevelupState {
+    loading: RequestStatus;
+    error: RequestError;
+}
+export declare enum LevelupActionType {
+    FetchLevelUpCustomer = "levelup/fetchLevelUpCustomer"
+}
+export declare const fetchLevelUpCustomer: import("@reduxjs/toolkit").AsyncThunk<void, {
+    token: string;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetLevelup: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const levelupReducer: import("redux").Reducer<LevelupState, import("redux").AnyAction>;

package/dist/esm/slices/levelup.js

@@ -0,0 +1,48 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+import { fetchCustomer, fulfillLoginCustomer } from './customer';
+const initialState = {
+    loading: 'idle',
+    error: null
+};
+export var LevelupActionType;
+(function (LevelupActionType) {
+    LevelupActionType["FetchLevelUpCustomer"] = "levelup/fetchLevelUpCustomer";
+})(LevelupActionType || (LevelupActionType = {}));
+export const fetchLevelUpCustomer = createAsyncThunk(LevelupActionType.FetchLevelUpCustomer, (data, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const auth = yield api.postLevelUp({ token: data.token });
+        dispatch(fulfillLoginCustomer(auth));
+        dispatch(fetchCustomer());
+        if (data.callback)
+            data.callback();
+        return;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+const levelupSlice = createSlice({
+    name: ReducerType.Levelup,
+    initialState,
+    reducers: {
+        resetLevelup: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchLevelUpCustomer.fulfilled, () => initialState)
+            .addCase(fetchLevelUpCustomer.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchLevelUpCustomer.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        });
+    }
+});
+export const { resetLevelup } = levelupSlice.actions;
+export const levelupReducer = levelupSlice.reducer;

package/dist/esm/slices/menu.d.ts

@@ -0,0 +1,22 @@
+import { AppState } from '../app';
+import { MenuCategories, MenuVars, OrderRevenueCenter, RequestError, RequestStatus, SoldOut } from '@open-tender/types';
+export interface MenuState {
+    loading: RequestStatus;
+    error: RequestError;
+    cartErrors: any;
+    categories: MenuCategories;
+    menuVars: Partial<MenuVars> | null;
+    previousMenuVars: Partial<MenuVars> | null;
+    revenueCenters: OrderRevenueCenter[] | null;
+    soldOut: SoldOut;
+}
+export declare enum MenuActionType {
+    FetchMenu = "menu/fetchMenu"
+}
+export declare const fetchMenu: import("@reduxjs/toolkit").AsyncThunk<void | Partial<MenuState>, Partial<MenuVars>, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const resetMenu: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCartErrors: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetMenuVars: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCartErrors: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectMenu: (state: AppState) => MenuState;
+export declare const menuReducer: import("redux").Reducer<MenuState, import("redux").AnyAction>;

package/dist/esm/slices/menu.js

@@ -0,0 +1,81 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+import { refreshRevenueCenter, setAlert, setCart } from './order';
+import { validateCart } from '@open-tender/utils';
+const initialState = {
+    menuVars: null,
+    previousMenuVars: null,
+    revenueCenters: null,
+    categories: [],
+    soldOut: [],
+    cartErrors: null,
+    error: null,
+    loading: 'idle'
+};
+export var MenuActionType;
+(function (MenuActionType) {
+    MenuActionType["FetchMenu"] = "menu/fetchMenu";
+})(MenuActionType || (MenuActionType = {}));
+export const fetchMenu = createAsyncThunk(MenuActionType.FetchMenu, (menuVars, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    const { revenueCenterId, serviceType, requestedAt } = menuVars;
+    try {
+        if (requestedAt === null) {
+            const err = getState().menu.error;
+            throw err;
+        }
+        const menu = yield api.getMenu(revenueCenterId, serviceType, requestedAt);
+        const { cart } = getState().order;
+        const { menu: categories, sold_out_items: soldOut, revenue_centers: revenueCenters } = menu;
+        const { newCart, errors } = validateCart(cart !== null && cart !== void 0 ? cart : [], categories, soldOut);
+        if (errors) {
+            dispatch(setCartErrors({ newCart, errors }));
+            dispatch(setAlert({ type: 'cartErrors' }));
+        }
+        else {
+            dispatch(setCart(newCart));
+            dispatch(resetCartErrors());
+        }
+        return { categories, soldOut, revenueCenters, menuVars };
+    }
+    catch (err) {
+        dispatch(refreshRevenueCenter(Object.assign(Object.assign({}, menuVars), { reset: true })));
+        return rejectWithValue(err);
+    }
+}));
+const menuSlice = createSlice({
+    name: ReducerType.Menu,
+    initialState,
+    reducers: {
+        resetMenu: () => initialState,
+        resetMenuVars: state => {
+            state.menuVars = null;
+            state.previousMenuVars = null;
+        },
+        resetCartErrors: state => {
+            state.cartErrors = null;
+        },
+        setCartErrors: (state, action) => {
+            state.cartErrors = action.payload;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchMenu.fulfilled, (state, action) => {
+            state = Object.assign(Object.assign(Object.assign({}, state), { previousMenuVars: state.menuVars || null, loading: 'idle', error: null }), action.payload);
+        })
+            .addCase(fetchMenu.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchMenu.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        });
+    }
+});
+export const { resetMenu, resetCartErrors, resetMenuVars, setCartErrors } = menuSlice.actions;
+export const selectMenu = (state) => state.menu;
+export const menuReducer = menuSlice.reducer;