@open-tender/cloud 0.0.1

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

@@ -0,0 +1,50 @@
+export declare const errorsApi: {
+    notAuthorized: {
+        code: string;
+        status: number;
+        title: string;
+        detail: string;
+    };
+    methodNotAllowed: {
+        code: string;
+        status: number;
+        title: string;
+        detail: string;
+    };
+    parseError: {
+        code: string;
+        status: number;
+        title: string;
+        detail: string;
+    };
+    internalServerError: {
+        code: string;
+        status: number;
+        title: string;
+        detail: string;
+    };
+    notImplemented: {
+        code: string;
+        status: number;
+        title: string;
+        detail: string;
+    };
+    badGateway: {
+        code: string;
+        status: number;
+        title: string;
+        detail: string;
+    };
+    tempUnavailable: {
+        code: string;
+        status: number;
+        title: string;
+        detail: string;
+    };
+    gatewayTimeout: {
+        code: string;
+        status: number;
+        title: string;
+        detail: string;
+    };
+};

package/dist/cjs/services/errors.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorsApi = void 0;
+exports.errorsApi = {
+    notAuthorized: {
+        code: 'not_authorized',
+        status: 401,
+        title: 'Not Authorized',
+        detail: 'Your session has expired. Please login again.'
+    },
+    methodNotAllowed: {
+        code: 'method_not_allowed',
+        status: 405,
+        title: 'Method Not Allowed',
+        detail: 'The method is not allowed for the requested URL.'
+    },
+    parseError: {
+        code: 'parse_error',
+        status: 422,
+        title: 'Cannot Read File',
+        detail: 'There was an error reading this file. Please contact Open Tender Support.'
+    },
+    internalServerError: {
+        code: 'internal_server_error',
+        status: 500,
+        title: 'Internal Server Error',
+        detail: 'Internal server error. Please contact Open Tender Support.'
+    },
+    notImplemented: {
+        code: 'not_implemented',
+        status: 501,
+        title: 'Servers Overloaded',
+        detail: 'Servers temporarily overloaded. Please retry your request. If this issue persists, please contact Open Tender Support.'
+    },
+    badGateway: {
+        code: 'bad_gateway',
+        status: 502,
+        title: 'Bad Gateway',
+        detail: 'Temporary gateway error. Please retry your request. If this issue persists, please contact Open Tender Support.'
+    },
+    tempUnavailable: {
+        code: 'temporarily_unavailable',
+        status: 503,
+        title: 'Service Temporarily Unavailable',
+        detail: 'Service Temporarily Unavailable. Please retry your request. If this issue persists, please contact Open Tender Support.'
+    },
+    gatewayTimeout: {
+        code: 'gateway_timeout',
+        status: 504,
+        title: 'Gateway Timeout',
+        detail: 'Gateway Timeout. Please contact Open Tender Support.'
+    }
+};

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

@@ -0,0 +1,2 @@
+import PosAPI from './api';
+export { PosAPI };

package/dist/cjs/services/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PosAPI = void 0;
+const tslib_1 = require("tslib");
+const api_1 = tslib_1.__importDefault(require("./api"));
+exports.PosAPI = api_1.default;

package/dist/cjs/slices/alerts.d.ts

@@ -0,0 +1,5 @@
+import { Alerts } from '@open-tender/types';
+import { AppState } from '../app';
+export declare const clearAlerts: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, addAlert: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>, dismissAlert: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectAlerts: (state: AppState) => Alerts;
+export declare const alertsReducer: import("redux").Reducer<Alerts, import("redux").AnyAction>;

package/dist/cjs/slices/alerts.js

@@ -0,0 +1,28 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alertsReducer = exports.selectAlerts = exports.dismissAlert = exports.addAlert = exports.clearAlerts = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("./types");
+const utils_1 = require("@open-tender/utils");
+const initialState = [];
+const alertsSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.Alerts,
+    initialState,
+    reducers: {
+        clearAlerts: () => initialState,
+        addAlert: (state, action) => {
+            return [
+                ...state.reverse().slice(0, 4).reverse(),
+                { message: action.payload, id: (0, utils_1.makeRandomNumberString)() }
+            ];
+        },
+        dismissAlert: (state, action) => {
+            return state.filter(i => i.id !== action.payload);
+        }
+    }
+});
+_a = alertsSlice.actions, exports.clearAlerts = _a.clearAlerts, exports.addAlert = _a.addAlert, exports.dismissAlert = _a.dismissAlert;
+const selectAlerts = (state) => state.alerts;
+exports.selectAlerts = selectAlerts;
+exports.alertsReducer = alertsSlice.reducer;

package/dist/cjs/slices/allergens.d.ts

@@ -0,0 +1,19 @@
+import { AppState } from '../app';
+import { Allergen, Allergens, RequestError, RequestStatus } from '@open-tender/types';
+export interface AllergensState {
+    entities: Allergen[];
+    error: RequestError;
+    loading: RequestStatus;
+    selectedAllergens: Allergen[] | null;
+}
+export declare enum AllergensActionType {
+    FetchAllergens = "allergens/fetchAllergens"
+}
+export declare const fetchAllergens: import("@reduxjs/toolkit").AsyncThunk<Allergens, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetAllergens: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setSelectedAllergens: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectAllergens: (state: AppState) => AllergensState;
+export declare const selectSelectedAllergenNames: (state: AppState) => (string | undefined)[];
+export declare const allergensReducer: import("redux").Reducer<AllergensState, import("redux").AnyAction>;

package/dist/cjs/slices/allergens.js

@@ -0,0 +1,66 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allergensReducer = exports.selectSelectedAllergenNames = exports.selectAllergens = exports.setSelectedAllergens = exports.resetAllergens = exports.fetchAllergens = exports.AllergensActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("./types");
+const initialState = {
+    entities: [],
+    selectedAllergens: null,
+    loading: 'idle',
+    error: null
+};
+var AllergensActionType;
+(function (AllergensActionType) {
+    AllergensActionType["FetchAllergens"] = "allergens/fetchAllergens";
+})(AllergensActionType = exports.AllergensActionType || (exports.AllergensActionType = {}));
+exports.fetchAllergens = (0, toolkit_1.createAsyncThunk)(AllergensActionType.FetchAllergens, (_, { getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        return yield api.getAllergens();
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+const allergensSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.Allergens,
+    initialState,
+    reducers: {
+        resetAllergens: () => initialState,
+        setSelectedAllergens: (state, action) => {
+            state.selectedAllergens = action.payload;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchAllergens.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchAllergens.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchAllergens.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+_a = allergensSlice.actions, exports.resetAllergens = _a.resetAllergens, exports.setSelectedAllergens = _a.setSelectedAllergens;
+const selectAllergens = (state) => state.allergens;
+exports.selectAllergens = selectAllergens;
+const selectSelectedAllergenNames = (state) => {
+    const { entities: allergens, selectedAllergens } = state.allergens;
+    if (!allergens.length || !selectedAllergens || !selectedAllergens.length) {
+        return [];
+    }
+    return selectedAllergens.map(i => {
+        const allergen = allergens.find(a => a.allergen_id === i.allergen_id);
+        return allergen ? allergen.name : '';
+    });
+};
+exports.selectSelectedAllergenNames = selectSelectedAllergenNames;
+exports.allergensReducer = allergensSlice.reducer;

package/dist/cjs/slices/announcements.d.ts

@@ -0,0 +1,28 @@
+import { AppState } from '../app';
+import { AnnouncementPage, AnnouncementPages, Announcements, AuthType, RequestError, RequestStatus } from '@open-tender/types';
+export interface AnnouncementsState {
+    entities: Announcements;
+    error: RequestError;
+    loading: RequestStatus;
+    pages: AnnouncementPages;
+}
+export declare enum AnnouncementsActionType {
+    FetchAnnouncementPage = "announcements/fetchAnnouncementPage"
+}
+export declare const fetchAnnouncementPage: import("@reduxjs/toolkit").AsyncThunk<AnnouncementPage, AuthType, {
+    state: AppState;
+    rejectValue: {
+        error: RequestError;
+        page: AuthType;
+    };
+}>;
+export declare const resetAnnouncements: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectAnnouncements: (state: AppState) => AnnouncementsState;
+export declare const selectAnnouncementsPage: (page: AuthType) => (state: AppState) => {
+    settings: import("@open-tender/types").AnnouncementSettings | null;
+    entities: Announcements;
+    loading: RequestStatus;
+    error: RequestError;
+};
+export declare const selectHasAnnouncementsPage: (page: AuthType) => (state: AppState) => boolean;
+export declare const announcementsReducer: import("redux").Reducer<AnnouncementsState, import("redux").AnyAction>;

package/dist/cjs/slices/announcements.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.announcementsReducer = exports.selectHasAnnouncementsPage = exports.selectAnnouncementsPage = exports.selectAnnouncements = exports.resetAnnouncements = exports.fetchAnnouncementPage = exports.AnnouncementsActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("./types");
+const initialState = {
+    entities: [],
+    pages: [],
+    loading: 'idle',
+    error: null
+};
+var AnnouncementsActionType;
+(function (AnnouncementsActionType) {
+    AnnouncementsActionType["FetchAnnouncementPage"] = "announcements/fetchAnnouncementPage";
+})(AnnouncementsActionType = exports.AnnouncementsActionType || (exports.AnnouncementsActionType = {}));
+exports.fetchAnnouncementPage = (0, toolkit_1.createAsyncThunk)(AnnouncementsActionType.FetchAnnouncementPage, (page, { getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const response = yield api.getAnnouncementPage(page);
+        const settings = Object.assign({}, response);
+        delete settings.announcements;
+        const entities = response.announcements;
+        const payload = { settings, entities, page };
+        return payload;
+    }
+    catch (err) {
+        return rejectWithValue({ error: err, page });
+    }
+}));
+const announcementsSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.Announcements,
+    initialState,
+    reducers: {
+        resetAnnouncements: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchAnnouncementPage.fulfilled, (state, action) => {
+            const { page } = action.payload;
+            const pages = state.pages
+                ? state.pages.filter(i => i.page !== page)
+                : [];
+            state.pages = [...pages, action.payload];
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchAnnouncementPage.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchAnnouncementPage.rejected, (state, action) => {
+            const { error, page } = action.payload || {};
+            state.error = error;
+            (state.pages = state.pages.filter(i => i.page !== page)),
+                (state.loading = 'idle');
+        });
+    }
+});
+exports.resetAnnouncements = announcementsSlice.actions.resetAnnouncements;
+const selectAnnouncements = (state) => state.announcements;
+exports.selectAnnouncements = selectAnnouncements;
+const selectAnnouncementsPage = (page) => (state) => {
+    const { pages, loading, error } = state.announcements;
+    const data = pages ? pages.find(i => i.page === page) : undefined;
+    const { settings = null, entities = [] } = data || {};
+    return { settings, entities, loading, error };
+};
+exports.selectAnnouncementsPage = selectAnnouncementsPage;
+const selectHasAnnouncementsPage = (page) => (state) => {
+    const { pages, loading } = state.announcements;
+    const data = pages ? pages.find(i => i.page === page) : undefined;
+    const { entities = [] } = data || {};
+    const hasAnnouncements = entities && entities.length;
+    return loading === 'pending' || hasAnnouncements ? true : false;
+};
+exports.selectHasAnnouncementsPage = selectHasAnnouncementsPage;
+exports.announcementsReducer = announcementsSlice.reducer;

package/dist/cjs/slices/checkout.d.ts

@@ -0,0 +1,38 @@
+import { AppState } from '../app';
+import { CheckoutCheck, CheckoutForm, CompletedOrder, Order, RequestStatus } from '@open-tender/types';
+export interface CheckoutState {
+    check: CheckoutCheck | null;
+    form: CheckoutForm;
+    submitting: boolean;
+    isGuest: boolean;
+    completedOrder: CompletedOrder | null;
+    errors: any;
+    loading: RequestStatus;
+}
+export declare enum CheckoutActionType {
+    FetchCheckout = "checkout/fetchCheckout",
+    ValidateOrder = "checkout/validateOrder",
+    SubmitOrder = "checkout/SubmitOrder",
+    SubmitOrderPay = "checkout/SubmitOrderPay"
+}
+export declare const validateOrder: import("@reduxjs/toolkit").AsyncThunk<{
+    check: CheckoutCheck;
+    errors: any;
+}, Partial<Order>, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const submitOrder: import("@reduxjs/toolkit").AsyncThunk<CompletedOrder, void, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const submitOrderPay: import("@reduxjs/toolkit").AsyncThunk<CompletedOrder, boolean, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const resetCheckout: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCheck: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCompletedOrder: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetErrors: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetTip: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCompletedOrder: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>, setGuest: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>, setSubmitting: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>, updateCheckoutCustomer: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>, updateForm: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectCheckout: (state: AppState) => CheckoutState;
+export declare const selectCheck: (state: AppState) => CheckoutCheck | null;
+export declare const selectCompletedOrder: (state: AppState) => CompletedOrder | null;
+export declare const selectDiscounts: (state: AppState) => import("@open-tender/types").OrderDiscounts;
+export declare const checkoutReducer: import("redux").Reducer<CheckoutState, import("redux").AnyAction>;

package/dist/cjs/slices/checkout.js

@@ -0,0 +1,276 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkoutReducer = exports.selectDiscounts = exports.selectCompletedOrder = exports.selectCheck = exports.selectCheckout = exports.updateForm = exports.updateCheckoutCustomer = exports.setSubmitting = exports.setGuest = exports.setCompletedOrder = exports.resetTip = exports.resetErrors = exports.resetCompletedOrder = exports.resetCheck = exports.resetCheckout = exports.submitOrderPay = exports.submitOrder = exports.validateOrder = exports.CheckoutActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("./types");
+const customer_1 = require("./customer");
+const utils_1 = require("@open-tender/utils");
+const order_1 = require("./order");
+const menu_1 = require("./menu");
+const initialState = {
+    check: null,
+    form: {
+        details: {},
+        customer: {},
+        address: {},
+        surcharges: [],
+        discounts: [],
+        promoCodes: [],
+        points: [],
+        tenders: [],
+        tip: null
+    },
+    submitting: false,
+    isGuest: false,
+    completedOrder: null,
+    errors: {},
+    loading: 'idle'
+};
+var CheckoutActionType;
+(function (CheckoutActionType) {
+    CheckoutActionType["FetchCheckout"] = "checkout/fetchCheckout";
+    CheckoutActionType["ValidateOrder"] = "checkout/validateOrder";
+    CheckoutActionType["SubmitOrder"] = "checkout/SubmitOrder";
+    CheckoutActionType["SubmitOrderPay"] = "checkout/SubmitOrderPay";
+})(CheckoutActionType = exports.CheckoutActionType || (exports.CheckoutActionType = {}));
+const assembleOrder = (orderData) => {
+    const { order, checkout, groupOrder } = orderData;
+    const { orderId, revenueCenter, serviceType, requestedAt, cart, deviceType, prepType, table } = order;
+    const { revenue_center_id: revenueCenterId } = revenueCenter || {};
+    const { form } = checkout;
+    const { customer, address, details, surcharges, discounts, promoCodes, points, tenders, tip } = form;
+    // const defaultTip = check ? getDefaultTip(check.config) : null
+    const fullAddress = Object.assign(Object.assign({}, order.address), address);
+    const data = {
+        orderId,
+        revenueCenterId,
+        serviceType,
+        requestedAt,
+        cart,
+        customer,
+        address: (0, utils_1.isEmpty)(fullAddress) ? null : fullAddress,
+        details,
+        surcharges,
+        discounts,
+        promoCodes,
+        points,
+        tip,
+        tenders,
+        cartId: groupOrder.cartId || null,
+        deviceType,
+        prepType,
+        table
+    };
+    const preparedOrder = (0, utils_1.prepareOrder)(data);
+    return preparedOrder;
+};
+const refreshKeys = ['revenue_center_id', 'service_type', 'requested_at'];
+const makeRefreshArgs = (order) => ({
+    revenueCenterId: order.revenue_center_id,
+    serviceType: order.service_type,
+    requestedAt: order.requested_at
+});
+exports.validateOrder = (0, toolkit_1.createAsyncThunk)(CheckoutActionType.FetchCheckout, (order, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { api } = getState().config;
+        if (!order)
+            order = assembleOrder(getState());
+        const check = yield api.postOrderValidate(order);
+        const errMessages = (0, utils_1.handleCheckoutErrors)({ params: check.errors });
+        const errors = {};
+        const keys = Object.keys(errMessages);
+        const args = makeRefreshArgs(order);
+        if ((0, utils_1.contains)(keys, refreshKeys)) {
+            dispatch((0, order_1.refreshRevenueCenter)(args));
+        }
+        else if ((0, utils_1.contains)(keys, ['cart'])) {
+            const cartError = errMessages.cart;
+            if ((0, utils_1.isString)(cartError)) {
+                dispatch((0, menu_1.fetchMenu)(args));
+            }
+            else {
+                const alert = { type: 'cartCounts', args: { errors: cartError } };
+                dispatch((0, order_1.setAlert)(alert));
+            }
+        }
+        else if ((0, utils_1.contains)(keys, ['promo_codes'])) {
+            errors['promo_codes'] = errMessages.promo_codes;
+        }
+        return { check, errors };
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+const handleOrderErrors = (err, preparedOrder, dispatch, rejectWithValue) => {
+    const errors = (0, utils_1.handleCheckoutErrors)(err);
+    const keys = Object.keys(errors);
+    const args = makeRefreshArgs(preparedOrder);
+    if ((0, utils_1.contains)(keys, refreshKeys)) {
+        dispatch((0, order_1.refreshRevenueCenter)(args));
+        return rejectWithValue({});
+    }
+    else if ((0, utils_1.contains)(keys, ['cart'])) {
+        const cartError = errors.cart;
+        if ((0, utils_1.isString)(cartError)) {
+            dispatch((0, menu_1.fetchMenu)(args));
+        }
+        else {
+            const alert = { type: 'cartCounts', args: { errors: cartError } };
+            setTimeout(() => {
+                dispatch((0, order_1.setAlert)(alert));
+            }, 500);
+        }
+        return rejectWithValue({});
+    }
+    else {
+        return rejectWithValue(errors);
+    }
+};
+exports.submitOrder = (0, toolkit_1.createAsyncThunk)(CheckoutActionType.SubmitOrder, (_, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    const alert = {
+        type: 'working',
+        args: { text: 'Submitting your order...' }
+    };
+    dispatch((0, order_1.setAlert)(alert));
+    const preparedOrder = assembleOrder(getState());
+    try {
+        const completedOrder = yield api.postOrder(preparedOrder);
+        const auth = getState().customer.account.auth;
+        const { email, password } = preparedOrder.customer || {};
+        if (password && !auth)
+            yield dispatch((0, customer_1.loginCustomer)({ email: email, password }));
+        dispatch((0, order_1.setAlert)({ type: 'close' }));
+        return completedOrder;
+    }
+    catch (err) {
+        dispatch((0, order_1.setAlert)({ type: 'close' }));
+        return rejectWithValue(err);
+    }
+}));
+exports.submitOrderPay = (0, toolkit_1.createAsyncThunk)(CheckoutActionType.SubmitOrderPay, (showAlert, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    dispatch((0, exports.setSubmitting)(true));
+    if (showAlert || false) {
+        const alert = {
+            type: 'working',
+            args: { text: 'Submitting your order...' }
+        };
+        dispatch((0, order_1.setAlert)(alert));
+    }
+    const preparedOrder = assembleOrder(getState());
+    try {
+        const completedOrder = yield api.postOrder(preparedOrder);
+        const auth = getState().customer.account.auth;
+        const { email, password } = preparedOrder.customer || {};
+        if (password && !auth)
+            yield dispatch((0, customer_1.loginCustomer)({ email: email, password }));
+        dispatch((0, order_1.setAlert)({ type: 'close' }));
+        return completedOrder;
+    }
+    catch (err) {
+        dispatch((0, order_1.setAlert)({ type: 'close' }));
+        handleOrderErrors(err, preparedOrder, dispatch, rejectWithValue);
+    }
+}));
+const checkoutSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.Checkout,
+    initialState,
+    reducers: {
+        resetCheckout: () => initialState,
+        resetCheck: state => {
+            state.check = null;
+        },
+        resetTip: state => {
+            state.form = Object.assign(Object.assign({}, state.form), { tip: null });
+        },
+        resetErrors: state => {
+            state.errors = {};
+        },
+        resetCompletedOrder: state => {
+            state.completedOrder = null;
+        },
+        setCompletedOrder: (state, action) => {
+            state.completedOrder = action.payload;
+        },
+        setSubmitting: (state, action) => {
+            state.submitting = action.payload;
+        },
+        setGuest: (state, action) => {
+            state.isGuest = action.payload;
+        },
+        updateForm: (state, action) => {
+            const errors = Object.assign({}, state.errors);
+            const { tenders } = action.payload;
+            if (tenders)
+                delete errors.tenders;
+            state.form = Object.assign(Object.assign({}, state.form), action.payload);
+            state.errors = errors;
+        },
+        updateCheckoutCustomer: (state, action) => {
+            const account = action.payload;
+            const customer = Object.assign({}, state.form.customer);
+            const customerId = customer ? customer.customer_id : null;
+            let form = Object.assign({}, state.form);
+            if (!account) {
+                if (customerId) {
+                    form = Object.assign(Object.assign({}, form), { customer: {}, promoCodes: [], discounts: [], tenders: [] });
+                }
+                else {
+                    form = Object.assign(Object.assign({}, form), { customer: {}, promoCodes: [] });
+                }
+            }
+            else if (customerId && account.customer_id !== customerId) {
+                form = Object.assign(Object.assign({}, form), { customer, discounts: [], tenders: [] });
+            }
+            else if (account && !customerId) {
+                form = Object.assign(Object.assign({}, form), { customer: account, discounts: [], tenders: [] });
+            }
+            state.form = Object.assign({}, form);
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.validateOrder.fulfilled, (state, action) => {
+            state.check = action.payload.check;
+            state.errors = action.payload.errors;
+        })
+            .addCase(exports.validateOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.validateOrder.rejected, (state, action) => {
+            state.errors = {
+                form: action.payload
+            };
+            state.loading = 'idle';
+        })
+            .addCase(exports.submitOrder.fulfilled, (state, action) => {
+            state.completedOrder = action.payload;
+        })
+            .addCase(exports.submitOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.submitOrder.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.submitting = false;
+            state.errors = action.payload;
+        });
+    }
+});
+_a = checkoutSlice.actions, exports.resetCheckout = _a.resetCheckout, exports.resetCheck = _a.resetCheck, exports.resetCompletedOrder = _a.resetCompletedOrder, exports.resetErrors = _a.resetErrors, exports.resetTip = _a.resetTip, exports.setCompletedOrder = _a.setCompletedOrder, exports.setGuest = _a.setGuest, exports.setSubmitting = _a.setSubmitting, exports.updateCheckoutCustomer = _a.updateCheckoutCustomer, exports.updateForm = _a.updateForm;
+const selectCheckout = (state) => state.checkout;
+exports.selectCheckout = selectCheckout;
+const selectCheck = (state) => state.checkout.check;
+exports.selectCheck = selectCheck;
+const selectCompletedOrder = (state) => state.checkout.completedOrder;
+exports.selectCompletedOrder = selectCompletedOrder;
+const selectDiscounts = (state) => state.checkout.form.discounts;
+exports.selectDiscounts = selectDiscounts;
+exports.checkoutReducer = checkoutSlice.reducer;