@open-tender/cloud 0.0.1

package/dist/esm/slices/completedOrders.js

@@ -0,0 +1,57 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+const initialState = {
+    entities: [],
+    loading: 'idle',
+    error: null
+};
+export var CompletedOrdersActionType;
+(function (CompletedOrdersActionType) {
+    CompletedOrdersActionType["FetchCompletedOrders"] = "completedOrders/fetchCompletedOrders";
+    CompletedOrdersActionType["RefreshCompletedOrders"] = "completedOrders/refreshCompletedOrders";
+})(CompletedOrdersActionType || (CompletedOrdersActionType = {}));
+export const fetchCompletedOrders = createAsyncThunk(CompletedOrdersActionType.FetchCompletedOrders, (requestData, { getState, rejectWithValue }) => __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 = createSlice({
+    name: ReducerType.CompletedOrders,
+    initialState,
+    reducers: {
+        resetCompletedOrders: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCompletedOrders.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCompletedOrders.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCompletedOrders.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCompletedOrders } = completedOrdersSlice.actions;
+export const selectCompletedOrders = (state) => {
+    const { entities: orders, loading, error } = state.completedOrders;
+    return { orders, loading, error };
+};
+export const completedOrdersReducer = completedOrdersSlice.reducer;

package/dist/esm/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/esm/slices/config.js

@@ -0,0 +1,102 @@
+import { __awaiter } from "tslib";
+import { createSlice, createAsyncThunk } from '@reduxjs/toolkit';
+import { decorateTheme } from '@open-tender/utils';
+import { ReducerType } from './types';
+import OpenTenderAPI from '../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
+};
+export var ConfigActionType;
+(function (ConfigActionType) {
+    ConfigActionType["FetchConfig"] = "config/getConfig";
+})(ConfigActionType || (ConfigActionType = {}));
+export const fetchConfig = createAsyncThunk(ConfigActionType.FetchConfig, (options, { rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = new OpenTenderAPI(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 = createSlice({
+    name: ReducerType.Config,
+    initialState: initialState,
+    reducers: {
+        resetConfig: () => initialState,
+        resetRetries: state => {
+            state.retries = 0;
+        },
+        incrementRetries: state => {
+            state.retries = state.retries + 1;
+        },
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchConfig.fulfilled, (state, action) => {
+            const { app, brand, content, theme, settings } = action.payload;
+            state.app = app;
+            state.brand = brand;
+            state.content = content;
+            state.theme = theme ? decorateTheme(theme) : null;
+            state.settings = settings;
+            state.loading = 'idle';
+            state.api = new OpenTenderAPI(app);
+            state.error = null;
+            state.retries = 0;
+        })
+            .addCase(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(fetchConfig.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetConfig, resetRetries, incrementRetries } = configSlice.actions;
+export const selectCateringOnly = (state) => {
+    const { orderTypes } = state.config.settings || {};
+    return !!((orderTypes === null || orderTypes === void 0 ? void 0 : orderTypes.includes('CATERING')) && orderTypes.length === 1);
+};
+export const selectConfig = (state) => state.config;
+export const selectBrand = (state) => state.config.brand;
+export const selectTheme = (state) => state.config.theme;
+export const selectContent = (state) => state.config.content;
+export const selectSettings = (state) => state.config.settings;
+export const selectApi = (state) => state.config.api;
+export const selectAccountConfig = (state) => { var _a; return (_a = state.config.content) === null || _a === void 0 ? void 0 : _a.account; };
+export 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];
+};
+export const selectConfigRetries = (state) => state.config.retries;
+export const selectLightColor = (state) => state.config.theme ? state.config.theme.colors.light : '#ffffff';
+export const selectOptIns = (state) => {
+    const { accepts_marketing, order_notifications } = state.config.brand || {};
+    return { accepts_marketing, order_notifications };
+};
+export const selectFulfillment = (state) => { var _a; return (_a = state.config.brand) === null || _a === void 0 ? void 0 : _a.fulfillment; };
+export const selectRecaptcha = (state) => { var _a; return (_a = state.config.settings) === null || _a === void 0 ? void 0 : _a.recaptcha; };
+export 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';
+};
+export const configReducer = configSlice.reducer;

package/dist/esm/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/esm/slices/confirmation.js

@@ -0,0 +1,18 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+const initialState = {
+    order: null
+};
+const confirmationSlice = createSlice({
+    name: ReducerType.Confirmation,
+    initialState,
+    reducers: {
+        resetConfirmation: () => initialState,
+        setConfirmationOrder: (state, action) => {
+            state.order = action.payload;
+        }
+    }
+});
+export const { resetConfirmation } = confirmationSlice.actions;
+export const selectConfirmationOrder = (state) => state.confirmation.order;
+export const confirmationReducer = confirmationSlice.reducer;

package/dist/esm/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/esm/slices/customer/account.js

@@ -0,0 +1,282 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from '../types';
+import { MISSING_CUSTOMER, MISSING_CUSTOMER_TOKEN } from '@open-tender/types';
+import { showNotification } from '../notifications';
+import { resetCustomerAllergens, setCustomerAllergens } from './allergens';
+import { setSelectedAllergens } from '../allergens';
+import { resetCustomerFavorites, setCustomerFavorites, setCustomerFavoritesLookup } from './favorites';
+import { resetCustomerCreditCards } from './creditCards';
+import { resetCustomerAddresses } from './addresses';
+import { resetCustomerHouseAccounts } from './houseAccounts';
+import { resetCustomerLoyalty } from './loyalty';
+import { resetCustomerOrder } from './order';
+import { resetCustomerOrders } from './orders';
+import { resetCustomerRewards } from './rewards';
+import { resetCustomerCommunicationPreferences } from './communicationPreferences';
+import { resetCustomerGiftCards, setCustomerGiftCards } from './giftCards';
+import { resetCustomerLevelUp, setCustomerLevelUp } from './levelup';
+import { addMessage, resetOrder, setAlert } from '../order';
+import { makeCustomerProfile, makeFavoritesLookup, makeFormErrors } from '@open-tender/utils';
+import { resetCheckout, updateCheckoutCustomer } from '../checkout';
+import { resetGroupOrder } from '../groupOrder';
+import { resetGuest } from '../guest';
+const initialState = {
+    auth: null,
+    profile: null,
+    loading: 'idle',
+    error: null
+};
+export 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 || (AccountActionType = {}));
+export const checkAuth = (err, dispatch, rejectWithValue) => __awaiter(void 0, void 0, void 0, function* () {
+    if ((err === null || err === void 0 ? void 0 : err.status) === 401) {
+        yield dispatch(logoutCustomer());
+        dispatch(addMessage('Please login to reauthenticate your account'));
+        return null;
+    }
+    else {
+        return rejectWithValue();
+    }
+});
+export const fetchCustomer = createAsyncThunk(AccountActionType.FetchCustomer, 
+// eslint-disable-next-line no-unused-vars
+(_, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        const customer = yield api.getCustomer(token);
+        const { allergens, gift_cards, favorites, levelup } = customer;
+        dispatch(setCustomerAllergens(allergens || []));
+        dispatch(setSelectedAllergens(allergens || []));
+        dispatch(setCustomerGiftCards(gift_cards || []));
+        dispatch(setCustomerFavorites(favorites || []));
+        dispatch(setCustomerLevelUp(levelup || []));
+        const lookup = makeFavoritesLookup(favorites);
+        dispatch(setCustomerFavoritesLookup(lookup || {}));
+        const profile = makeCustomerProfile(customer);
+        return profile;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const loginCustomer = createAsyncThunk(AccountActionType.LoginCustomer, (data, { dispatch, getState, rejectWithValue }) => __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(fetchCustomer);
+        return auth;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+export const logoutCustomer = createAsyncThunk(AccountActionType.LogoutCustomer, (isReset, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { api } = getState().config;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(undefined);
+        if (isReset) {
+            dispatch(resetOrder());
+            dispatch(resetCheckout());
+            dispatch(setSelectedAllergens(null));
+        }
+        yield api.postLogout(token);
+        dispatch(updateCheckoutCustomer(null));
+        dispatch(resetCustomerAddresses());
+        dispatch(resetCustomerAllergens());
+        dispatch(resetCustomerCreditCards());
+        dispatch(resetCustomerFavorites());
+        dispatch(resetCustomerLevelUp());
+        dispatch(resetCustomerGiftCards());
+        dispatch(resetCustomerHouseAccounts());
+        dispatch(resetCustomerLoyalty());
+        dispatch(resetCustomerOrder());
+        dispatch(resetCustomerOrders());
+        dispatch(resetGroupOrder());
+        dispatch(resetCustomerRewards());
+        dispatch(resetCustomerCommunicationPreferences());
+        dispatch(resetGuest());
+        return null;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+export const linkPosToken = createAsyncThunk(AccountActionType.LinkPosToken, (posToken, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        yield api.postCustomerPosToken(token, posToken);
+        dispatch(showNotification('Order successfully linked!'));
+        dispatch(fetchCustomer);
+        return;
+    }
+    catch (err) {
+        const error = err;
+        dispatch(addMessage((error === null || error === void 0 ? void 0 : error.detail) || (error === null || error === void 0 ? void 0 : error.message)));
+        return rejectWithValue(error);
+    }
+}));
+export const updateCustomer = createAsyncThunk(AccountActionType.UpdateCustomer, (data, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const token = selectToken(getState());
+        const api = getState().config.api;
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        const customer = yield api.putCustomer(token, data.data);
+        const profile = makeCustomerProfile(customer);
+        dispatch(showNotification('Account updated!'));
+        if (data.callback)
+            data.callback(data.data);
+        return profile;
+    }
+    catch (err) {
+        const error = err;
+        const errors = makeFormErrors(err);
+        return checkAuth(error, dispatch, () => rejectWithValue(errors));
+    }
+}));
+export const sendCustomerVerificationEmail = createAsyncThunk(AccountActionType.VerifyCustomer, (linkUrl, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token) {
+            dispatch(addMessage('Missing customer token'));
+            throw new Error(MISSING_CUSTOMER_TOKEN);
+        }
+        yield api.postSendVerificationEmail(token, linkUrl);
+        dispatch(showNotification('Verification email sent!'));
+        return;
+    }
+    catch (err) {
+        dispatch(addMessage(err.detail || err.message));
+        return rejectWithValue(err);
+    }
+}));
+export const loginCustomerThanx = createAsyncThunk(AccountActionType.LoginCustomer, (email, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        yield api.postThanxLogin(email);
+        dispatch(setAlert({ type: 'close' }));
+        dispatch(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);
+    }
+}));
+export const authCustomerThanx = createAsyncThunk(AccountActionType.LoginCustomer, (data, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const auth = yield api.postThanxAuth(data.code, data.path);
+        dispatch(fetchCustomer());
+        return auth;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+const accountSlice = createSlice({
+    name: 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(loginCustomer.fulfilled, (state, action) => {
+            state.auth = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(loginCustomer.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(loginCustomer.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        })
+            .addCase(fetchCustomer.fulfilled, (state, action) => {
+            state.profile = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomer.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomer.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        })
+            .addCase(updateCustomer.fulfilled, (state, action) => {
+            state.profile = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(updateCustomer.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(updateCustomer.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.error = action.payload;
+        })
+            .addCase(logoutCustomer.fulfilled, () => initialState)
+            .addCase(logoutCustomer.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(logoutCustomer.rejected, () => initialState)
+            .addCase(sendCustomerVerificationEmail.fulfilled, state => {
+            state.loading = 'idle';
+        })
+            .addCase(sendCustomerVerificationEmail.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(sendCustomerVerificationEmail.rejected, state => {
+            state.loading = 'idle';
+        })
+            .addCase(linkPosToken.fulfilled, () => {
+            //do nothing
+        })
+            .addCase(linkPosToken.pending, () => {
+            //do nothing
+        })
+            .addCase(linkPosToken.rejected, () => {
+            //do nothing
+        });
+    }
+});
+export const { resetCustomer, resetLoginError, fulfillLoginCustomer } = accountSlice.actions;
+export const selectToken = (state) => state.customer.account.auth ? state.customer.account.auth.access_token : null;
+export const accountReducer = accountSlice.reducer;

package/dist/esm/slices/customer/addresses.d.ts

@@ -0,0 +1,37 @@
+import { AppState } from '../../app';
+import { Address, Addresses, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerAddressesState {
+    entities: Addresses;
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number]: number;
+    };
+}
+export declare enum CustomerAddressesActionType {
+    FetchCustomerAddresses = "customer/fetchCustomerAddresses",
+    UpdateCustomerAddresses = "customer/updateCustomerAddresses",
+    RemoveCustomerAddress = "customer/removeCustomerAddress"
+}
+export declare const fetchCustomerAddresses: import("@reduxjs/toolkit").AsyncThunk<Addresses, number, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const updateCustomerAddress: import("@reduxjs/toolkit").AsyncThunk<Addresses, {
+    addressId: number;
+    data: Address;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const removeCustomerAddress: import("@reduxjs/toolkit").AsyncThunk<Addresses, {
+    addressId: number;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerAddresses: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerAddresses: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectCustomerAddresses: (state: AppState) => CustomerAddressesState;
+export declare const customerAddressesReducer: import("redux").Reducer<CustomerAddressesState, import("redux").AnyAction>;