@open-tender/cloud 0.0.1

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

@@ -0,0 +1,25 @@
+import { AppState } from '../app';
+import { CompletedOrders, RequestError, RequestStatus } from '@open-tender/types';
+export interface CompletedOrdersState {
+    entities: CompletedOrders;
+    error: RequestError;
+    loading: RequestStatus;
+}
+export declare enum CompletedOrdersActionType {
+    FetchCompletedOrders = "completedOrders/fetchCompletedOrders",
+    RefreshCompletedOrders = "completedOrders/refreshCompletedOrders"
+}
+export declare const fetchCompletedOrders: import("@reduxjs/toolkit").AsyncThunk<CompletedOrders, {
+    business_date: string;
+    channelTypes: string;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCompletedOrders: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectCompletedOrders: (state: AppState) => {
+    orders: CompletedOrders;
+    loading: RequestStatus;
+    error: RequestError;
+};
+export declare const completedOrdersReducer: import("redux").Reducer<CompletedOrdersState, import("redux").AnyAction>;

package/dist/cjs/slices/completedOrders.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completedOrdersReducer = exports.selectCompletedOrders = exports.resetCompletedOrders = exports.fetchCompletedOrders = exports.CompletedOrdersActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("./types");
+const initialState = {
+    entities: [],
+    loading: 'idle',
+    error: null
+};
+var CompletedOrdersActionType;
+(function (CompletedOrdersActionType) {
+    CompletedOrdersActionType["FetchCompletedOrders"] = "completedOrders/fetchCompletedOrders";
+    CompletedOrdersActionType["RefreshCompletedOrders"] = "completedOrders/refreshCompletedOrders";
+})(CompletedOrdersActionType = exports.CompletedOrdersActionType || (exports.CompletedOrdersActionType = {}));
+exports.fetchCompletedOrders = (0, toolkit_1.createAsyncThunk)(CompletedOrdersActionType.FetchCompletedOrders, (requestData, { getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { api } = getState().config;
+        const args = {
+            business_date: requestData.business_date,
+            prep_status: `COMPLETED,FULFILLED`
+        };
+        if (requestData.channelTypes)
+            args.channel_type = requestData.channelTypes;
+        const orders = yield api.getOrders(args);
+        return orders;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+const completedOrdersSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.CompletedOrders,
+    initialState,
+    reducers: {
+        resetCompletedOrders: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchCompletedOrders.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchCompletedOrders.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchCompletedOrders.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+exports.resetCompletedOrders = completedOrdersSlice.actions.resetCompletedOrders;
+const selectCompletedOrders = (state) => {
+    const { entities: orders, loading, error } = state.completedOrders;
+    return { orders, loading, error };
+};
+exports.selectCompletedOrders = selectCompletedOrders;
+exports.completedOrdersReducer = completedOrdersSlice.reducer;

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

@@ -0,0 +1,87 @@
+import { ConfigApp, ConfigBrand, ConfigContent, ConfigSettings, ConfigTheme, RequestError, RequestStatus } from '@open-tender/types';
+import { AppState } from '../app';
+export interface ConfigState {
+    api: any;
+    itemTypes: any;
+    app: ConfigApp | null;
+    brand: ConfigBrand | null;
+    content: ConfigContent | null;
+    error: any;
+    isBackgroundFetch: boolean;
+    loading: RequestStatus;
+    retries: number;
+    settings: ConfigSettings | null;
+    theme: ConfigTheme | null;
+}
+export declare enum ConfigActionType {
+    FetchConfig = "config/getConfig"
+}
+export declare const fetchConfig: import("@reduxjs/toolkit").AsyncThunk<ConfigState, {
+    baseUrl: string;
+    authUrl: string;
+    clientId: string;
+    brandId: string;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetConfig: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetRetries: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, incrementRetries: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectCateringOnly: (state: AppState) => boolean;
+export declare const selectConfig: (state: AppState) => ConfigState;
+export declare const selectBrand: (state: AppState) => ConfigBrand | null;
+export declare const selectTheme: (state: AppState) => ConfigTheme | null;
+export declare const selectContent: (state: AppState) => ConfigContent | null;
+export declare const selectSettings: (state: AppState) => ConfigSettings | null;
+export declare const selectApi: (state: AppState) => any;
+export declare const selectAccountConfig: (state: AppState) => {
+    addresses: import("@open-tender/types").ConfigContentField;
+    allergens: import("@open-tender/types").ConfigContentField;
+    background: string;
+    content: string;
+    creditCards: import("@open-tender/types").ConfigContentField;
+    deals: import("@open-tender/types").ConfigContentField;
+    displayLogo: boolean;
+    displayLogoApp: boolean;
+    displayLogoMobile: boolean;
+    displayed: string[];
+    displayedMobile: string[];
+    favorites: import("@open-tender/types").ConfigContentField;
+    giftCards: import("@open-tender/types").ConfigContentField;
+    greeting: string;
+    groupOrders: import("@open-tender/types").ConfigContentField;
+    houseAccounts: import("@open-tender/types").ConfigContentField;
+    levelup: import("@open-tender/types").ConfigContentField;
+    loyalty: {
+        signUp: string;
+        title: string;
+        subtitle: string;
+        skip: string;
+    };
+    mobile: string;
+    profile: import("@open-tender/types").ConfigContentField;
+    punctuation: string;
+    recentItems: import("@open-tender/types").ConfigContentField;
+    recentOrders: import("@open-tender/types").ConfigContentField;
+    rewards: import("@open-tender/types").ConfigContentField;
+    showFirstName: boolean;
+    showHero: boolean;
+    subtitle: string;
+    thanx: import("@open-tender/types").ConfigContentField;
+    title: string;
+} | undefined;
+export declare const selectDisplaySettings: (state: AppState) => import("@open-tender/types").ConfigDisplaySetting | undefined;
+export declare const selectConfigRetries: (state: AppState) => number;
+export declare const selectLightColor: (state: AppState) => string;
+export declare const selectOptIns: (state: AppState) => {
+    accepts_marketing: import("@open-tender/types").ConfigAcceptMarketing | undefined;
+    order_notifications: import("@open-tender/types").ConfigOrderNotifications | undefined;
+};
+export declare const selectFulfillment: (state: AppState) => import("@open-tender/types").ConfigFulfillment | undefined;
+export declare const selectRecaptcha: (state: AppState) => {
+    addCard: boolean;
+    donations: boolean;
+    giftCards: boolean;
+} | undefined;
+export declare const selectSoldOutMsg: (state: AppState) => string;
+export declare const configReducer: import("redux").Reducer<ConfigState, import("redux").AnyAction>;

package/dist/cjs/slices/config.js

@@ -0,0 +1,121 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configReducer = exports.selectSoldOutMsg = exports.selectRecaptcha = exports.selectFulfillment = exports.selectOptIns = exports.selectLightColor = exports.selectConfigRetries = exports.selectDisplaySettings = exports.selectAccountConfig = exports.selectApi = exports.selectSettings = exports.selectContent = exports.selectTheme = exports.selectBrand = exports.selectConfig = exports.selectCateringOnly = exports.incrementRetries = exports.resetRetries = exports.resetConfig = exports.fetchConfig = exports.ConfigActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const utils_1 = require("@open-tender/utils");
+const types_1 = require("./types");
+const api_1 = tslib_1.__importDefault(require("../services/api"));
+const initialState = {
+    app: null,
+    brand: null,
+    content: null,
+    theme: null,
+    settings: null,
+    api: null,
+    loading: 'idle',
+    error: null,
+    retries: 0,
+    isBackgroundFetch: false,
+    itemTypes: null
+};
+var ConfigActionType;
+(function (ConfigActionType) {
+    ConfigActionType["FetchConfig"] = "config/getConfig";
+})(ConfigActionType = exports.ConfigActionType || (exports.ConfigActionType = {}));
+exports.fetchConfig = (0, toolkit_1.createAsyncThunk)(ConfigActionType.FetchConfig, (options, { rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = new api_1.default(options);
+        const response = yield api.getConfig();
+        const app = { baseUrl: options.baseUrl, authUrl: options.authUrl, clientId: options.clientId, brandId: options.brandId };
+        options.callback && options.callback();
+        return Object.assign(Object.assign({}, response), { app });
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+const configSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.Config,
+    initialState: initialState,
+    reducers: {
+        resetConfig: () => initialState,
+        resetRetries: state => {
+            state.retries = 0;
+        },
+        incrementRetries: state => {
+            state.retries = state.retries + 1;
+        },
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchConfig.fulfilled, (state, action) => {
+            const { app, brand, content, theme, settings } = action.payload;
+            state.app = app;
+            state.brand = brand;
+            state.content = content;
+            state.theme = theme ? (0, utils_1.decorateTheme)(theme) : null;
+            state.settings = settings;
+            state.loading = 'idle';
+            state.api = new api_1.default(app);
+            state.error = null;
+            state.retries = 0;
+        })
+            .addCase(exports.fetchConfig.pending, (state, action) => {
+            var _a;
+            state.loading = 'pending';
+            state.isBackgroundFetch = ((_a = action === null || action === void 0 ? void 0 : action.meta) === null || _a === void 0 ? void 0 : _a.arg) !== undefined ? true : false;
+        })
+            .addCase(exports.fetchConfig.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+_a = configSlice.actions, exports.resetConfig = _a.resetConfig, exports.resetRetries = _a.resetRetries, exports.incrementRetries = _a.incrementRetries;
+const selectCateringOnly = (state) => {
+    const { orderTypes } = state.config.settings || {};
+    return !!((orderTypes === null || orderTypes === void 0 ? void 0 : orderTypes.includes('CATERING')) && orderTypes.length === 1);
+};
+exports.selectCateringOnly = selectCateringOnly;
+const selectConfig = (state) => state.config;
+exports.selectConfig = selectConfig;
+const selectBrand = (state) => state.config.brand;
+exports.selectBrand = selectBrand;
+const selectTheme = (state) => state.config.theme;
+exports.selectTheme = selectTheme;
+const selectContent = (state) => state.config.content;
+exports.selectContent = selectContent;
+const selectSettings = (state) => state.config.settings;
+exports.selectSettings = selectSettings;
+const selectApi = (state) => state.config.api;
+exports.selectApi = selectApi;
+const selectAccountConfig = (state) => { var _a; return (_a = state.config.content) === null || _a === void 0 ? void 0 : _a.account; };
+exports.selectAccountConfig = selectAccountConfig;
+const selectDisplaySettings = (state) => {
+    var _a;
+    const orderType = state.order.orderType || 'OLO';
+    return (_a = state.config.settings) === null || _a === void 0 ? void 0 : _a.displaySettings[orderType];
+};
+exports.selectDisplaySettings = selectDisplaySettings;
+const selectConfigRetries = (state) => state.config.retries;
+exports.selectConfigRetries = selectConfigRetries;
+const selectLightColor = (state) => state.config.theme ? state.config.theme.colors.light : '#ffffff';
+exports.selectLightColor = selectLightColor;
+const selectOptIns = (state) => {
+    const { accepts_marketing, order_notifications } = state.config.brand || {};
+    return { accepts_marketing, order_notifications };
+};
+exports.selectOptIns = selectOptIns;
+const selectFulfillment = (state) => { var _a; return (_a = state.config.brand) === null || _a === void 0 ? void 0 : _a.fulfillment; };
+exports.selectFulfillment = selectFulfillment;
+const selectRecaptcha = (state) => { var _a; return (_a = state.config.settings) === null || _a === void 0 ? void 0 : _a.recaptcha; };
+exports.selectRecaptcha = selectRecaptcha;
+const selectSoldOutMsg = (state) => {
+    var _a;
+    const { soldOutMessage } = ((_a = state.config.content) === null || _a === void 0 ? void 0 : _a.menu) || {};
+    return soldOutMessage || 'Sold out for day';
+};
+exports.selectSoldOutMsg = selectSoldOutMsg;
+exports.configReducer = configSlice.reducer;

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

@@ -0,0 +1,8 @@
+import { Order } from '@open-tender/types';
+import { AppState } from '../app';
+export interface ConfirmationState {
+    order: Order | null;
+}
+export declare const resetConfirmation: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectConfirmationOrder: (state: AppState) => Order | null;
+export declare const confirmationReducer: import("redux").Reducer<ConfirmationState, import("redux").AnyAction>;

package/dist/cjs/slices/confirmation.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.confirmationReducer = exports.selectConfirmationOrder = exports.resetConfirmation = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("./types");
+const initialState = {
+    order: null
+};
+const confirmationSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.Confirmation,
+    initialState,
+    reducers: {
+        resetConfirmation: () => initialState,
+        setConfirmationOrder: (state, action) => {
+            state.order = action.payload;
+        }
+    }
+});
+exports.resetConfirmation = confirmationSlice.actions.resetConfirmation;
+const selectConfirmationOrder = (state) => state.confirmation.order;
+exports.selectConfirmationOrder = selectConfirmationOrder;
+exports.confirmationReducer = confirmationSlice.reducer;

package/dist/cjs/slices/customer/account.d.ts

@@ -0,0 +1,59 @@
+import { AnyAction, ThunkDispatch } from '@reduxjs/toolkit';
+import { AppState } from '../../app';
+import { Auth, LoginData, Profile, RequestError, RequestStatus } from '@open-tender/types';
+export interface AccountState {
+    auth: Auth | null;
+    profile: Partial<Profile> | null;
+    loading: RequestStatus;
+    error: RequestError;
+}
+export declare enum AccountActionType {
+    LoginCustomer = "customer/loginCustomer",
+    LogoutCustomer = "customer/logoutCustomer",
+    FetchCustomer = "customer/fetchCustomer",
+    UpdateCustomer = "customer/updateCustomer",
+    VerifyCustomer = "customer/verifyCustomer",
+    LinkPosToken = "customer/linkPosToken"
+}
+export declare const checkAuth: (err: RequestError, dispatch: ThunkDispatch<AppState, unknown, AnyAction>, rejectWithValue: () => any) => Promise<any>;
+export declare const fetchCustomer: import("@reduxjs/toolkit").AsyncThunk<Partial<Profile>, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const loginCustomer: import("@reduxjs/toolkit").AsyncThunk<Auth, LoginData, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const logoutCustomer: import("@reduxjs/toolkit").AsyncThunk<null, boolean | undefined, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const linkPosToken: import("@reduxjs/toolkit").AsyncThunk<void, string, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const updateCustomer: import("@reduxjs/toolkit").AsyncThunk<Partial<Profile>, {
+    data: Partial<Profile>;
+    callback?: ((data: Partial<Profile>) => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const sendCustomerVerificationEmail: import("@reduxjs/toolkit").AsyncThunk<void, string, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const loginCustomerThanx: import("@reduxjs/toolkit").AsyncThunk<null, string, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const authCustomerThanx: import("@reduxjs/toolkit").AsyncThunk<Auth, {
+    code: any;
+    path: string | null;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomer: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetLoginError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, fulfillLoginCustomer: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectToken: (state: AppState) => string | null;
+export declare const accountReducer: import("redux").Reducer<AccountState, AnyAction>;

package/dist/cjs/slices/customer/account.js

@@ -0,0 +1,288 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountReducer = exports.selectToken = exports.fulfillLoginCustomer = exports.resetLoginError = exports.resetCustomer = exports.authCustomerThanx = exports.loginCustomerThanx = exports.sendCustomerVerificationEmail = exports.updateCustomer = exports.linkPosToken = exports.logoutCustomer = exports.loginCustomer = exports.fetchCustomer = exports.checkAuth = exports.AccountActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("../types");
+const types_2 = require("@open-tender/types");
+const notifications_1 = require("../notifications");
+const allergens_1 = require("./allergens");
+const allergens_2 = require("../allergens");
+const favorites_1 = require("./favorites");
+const creditCards_1 = require("./creditCards");
+const addresses_1 = require("./addresses");
+const houseAccounts_1 = require("./houseAccounts");
+const loyalty_1 = require("./loyalty");
+const order_1 = require("./order");
+const orders_1 = require("./orders");
+const rewards_1 = require("./rewards");
+const communicationPreferences_1 = require("./communicationPreferences");
+const giftCards_1 = require("./giftCards");
+const levelup_1 = require("./levelup");
+const order_2 = require("../order");
+const utils_1 = require("@open-tender/utils");
+const checkout_1 = require("../checkout");
+const groupOrder_1 = require("../groupOrder");
+const guest_1 = require("../guest");
+const initialState = {
+    auth: null,
+    profile: null,
+    loading: 'idle',
+    error: null
+};
+var AccountActionType;
+(function (AccountActionType) {
+    AccountActionType["LoginCustomer"] = "customer/loginCustomer";
+    AccountActionType["LogoutCustomer"] = "customer/logoutCustomer";
+    AccountActionType["FetchCustomer"] = "customer/fetchCustomer";
+    AccountActionType["UpdateCustomer"] = "customer/updateCustomer";
+    AccountActionType["VerifyCustomer"] = "customer/verifyCustomer";
+    AccountActionType["LinkPosToken"] = "customer/linkPosToken";
+})(AccountActionType = exports.AccountActionType || (exports.AccountActionType = {}));
+const checkAuth = (err, dispatch, rejectWithValue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    if ((err === null || err === void 0 ? void 0 : err.status) === 401) {
+        yield dispatch((0, exports.logoutCustomer)());
+        dispatch((0, order_2.addMessage)('Please login to reauthenticate your account'));
+        return null;
+    }
+    else {
+        return rejectWithValue();
+    }
+});
+exports.checkAuth = checkAuth;
+exports.fetchCustomer = (0, toolkit_1.createAsyncThunk)(AccountActionType.FetchCustomer, 
+// eslint-disable-next-line no-unused-vars
+(_, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, exports.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        const customer = yield api.getCustomer(token);
+        const { allergens, gift_cards, favorites, levelup } = customer;
+        dispatch((0, allergens_1.setCustomerAllergens)(allergens || []));
+        dispatch((0, allergens_2.setSelectedAllergens)(allergens || []));
+        dispatch((0, giftCards_1.setCustomerGiftCards)(gift_cards || []));
+        dispatch((0, favorites_1.setCustomerFavorites)(favorites || []));
+        dispatch((0, levelup_1.setCustomerLevelUp)(levelup || []));
+        const lookup = (0, utils_1.makeFavoritesLookup)(favorites);
+        dispatch((0, favorites_1.setCustomerFavoritesLookup)(lookup || {}));
+        const profile = (0, utils_1.makeCustomerProfile)(customer);
+        return profile;
+    }
+    catch (err) {
+        const error = err;
+        return (0, exports.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+exports.loginCustomer = (0, toolkit_1.createAsyncThunk)(AccountActionType.LoginCustomer, (data, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { email, password } = data;
+        const api = getState().config.api;
+        const auth = yield api.postLogin(email, password);
+        dispatch(exports.fetchCustomer);
+        return auth;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+exports.logoutCustomer = (0, toolkit_1.createAsyncThunk)(AccountActionType.LogoutCustomer, (isReset, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { api } = getState().config;
+        const token = (0, exports.selectToken)(getState());
+        if (!token)
+            throw new Error(undefined);
+        if (isReset) {
+            dispatch((0, order_2.resetOrder)());
+            dispatch((0, checkout_1.resetCheckout)());
+            dispatch((0, allergens_2.setSelectedAllergens)(null));
+        }
+        yield api.postLogout(token);
+        dispatch((0, checkout_1.updateCheckoutCustomer)(null));
+        dispatch((0, addresses_1.resetCustomerAddresses)());
+        dispatch((0, allergens_1.resetCustomerAllergens)());
+        dispatch((0, creditCards_1.resetCustomerCreditCards)());
+        dispatch((0, favorites_1.resetCustomerFavorites)());
+        dispatch((0, levelup_1.resetCustomerLevelUp)());
+        dispatch((0, giftCards_1.resetCustomerGiftCards)());
+        dispatch((0, houseAccounts_1.resetCustomerHouseAccounts)());
+        dispatch((0, loyalty_1.resetCustomerLoyalty)());
+        dispatch((0, order_1.resetCustomerOrder)());
+        dispatch((0, orders_1.resetCustomerOrders)());
+        dispatch((0, groupOrder_1.resetGroupOrder)());
+        dispatch((0, rewards_1.resetCustomerRewards)());
+        dispatch((0, communicationPreferences_1.resetCustomerCommunicationPreferences)());
+        dispatch((0, guest_1.resetGuest)());
+        return null;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+exports.linkPosToken = (0, toolkit_1.createAsyncThunk)(AccountActionType.LinkPosToken, (posToken, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, exports.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        yield api.postCustomerPosToken(token, posToken);
+        dispatch((0, notifications_1.showNotification)('Order successfully linked!'));
+        dispatch(exports.fetchCustomer);
+        return;
+    }
+    catch (err) {
+        const error = err;
+        dispatch((0, order_2.addMessage)((error === null || error === void 0 ? void 0 : error.detail) || (error === null || error === void 0 ? void 0 : error.message)));
+        return rejectWithValue(error);
+    }
+}));
+exports.updateCustomer = (0, toolkit_1.createAsyncThunk)(AccountActionType.UpdateCustomer, (data, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const token = (0, exports.selectToken)(getState());
+        const api = getState().config.api;
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        const customer = yield api.putCustomer(token, data.data);
+        const profile = (0, utils_1.makeCustomerProfile)(customer);
+        dispatch((0, notifications_1.showNotification)('Account updated!'));
+        if (data.callback)
+            data.callback(data.data);
+        return profile;
+    }
+    catch (err) {
+        const error = err;
+        const errors = (0, utils_1.makeFormErrors)(err);
+        return (0, exports.checkAuth)(error, dispatch, () => rejectWithValue(errors));
+    }
+}));
+exports.sendCustomerVerificationEmail = (0, toolkit_1.createAsyncThunk)(AccountActionType.VerifyCustomer, (linkUrl, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, exports.selectToken)(getState());
+        if (!token) {
+            dispatch((0, order_2.addMessage)('Missing customer token'));
+            throw new Error(types_2.MISSING_CUSTOMER_TOKEN);
+        }
+        yield api.postSendVerificationEmail(token, linkUrl);
+        dispatch((0, notifications_1.showNotification)('Verification email sent!'));
+        return;
+    }
+    catch (err) {
+        dispatch((0, order_2.addMessage)(err.detail || err.message));
+        return rejectWithValue(err);
+    }
+}));
+exports.loginCustomerThanx = (0, toolkit_1.createAsyncThunk)(AccountActionType.LoginCustomer, (email, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        yield api.postThanxLogin(email);
+        dispatch((0, order_2.setAlert)({ type: 'close' }));
+        dispatch((0, order_2.addMessage)('Thanks! Please check your email on this device.'));
+        return null;
+    }
+    catch (err) {
+        const errr = err;
+        if (errr) {
+            const error = (errr === null || errr === void 0 ? void 0 : errr.params) ? errr.params['$.email'] : null;
+            if (error && error.includes("'email'")) {
+                errr.detail = 'Please enter a valid email address';
+            }
+        }
+        return rejectWithValue(errr);
+    }
+}));
+exports.authCustomerThanx = (0, toolkit_1.createAsyncThunk)(AccountActionType.LoginCustomer, (data, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const auth = yield api.postThanxAuth(data.code, data.path);
+        dispatch((0, exports.fetchCustomer)());
+        return auth;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+const accountSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.Account,
+    initialState,
+    reducers: {
+        resetCustomer: () => initialState,
+        resetLoginError: state => {
+            state.loading = 'idle';
+            state.error = null;
+        },
+        fulfillLoginCustomer: (state, action) => {
+            state.auth = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.loginCustomer.fulfilled, (state, action) => {
+            state.auth = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.loginCustomer.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.loginCustomer.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        })
+            .addCase(exports.fetchCustomer.fulfilled, (state, action) => {
+            state.profile = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchCustomer.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchCustomer.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        })
+            .addCase(exports.updateCustomer.fulfilled, (state, action) => {
+            state.profile = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.updateCustomer.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.updateCustomer.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        })
+            .addCase(exports.logoutCustomer.fulfilled, () => initialState)
+            .addCase(exports.logoutCustomer.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.logoutCustomer.rejected, () => initialState)
+            .addCase(exports.sendCustomerVerificationEmail.fulfilled, state => {
+            state.loading = 'idle';
+        })
+            .addCase(exports.sendCustomerVerificationEmail.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.sendCustomerVerificationEmail.rejected, state => {
+            state.loading = 'idle';
+        })
+            .addCase(exports.linkPosToken.fulfilled, () => {
+            //do nothing
+        })
+            .addCase(exports.linkPosToken.pending, () => {
+            //do nothing
+        })
+            .addCase(exports.linkPosToken.rejected, () => {
+            //do nothing
+        });
+    }
+});
+_a = accountSlice.actions, exports.resetCustomer = _a.resetCustomer, exports.resetLoginError = _a.resetLoginError, exports.fulfillLoginCustomer = _a.fulfillLoginCustomer;
+const selectToken = (state) => state.customer.account.auth ? state.customer.account.auth.access_token : null;
+exports.selectToken = selectToken;
+exports.accountReducer = accountSlice.reducer;