@open-tender/store 0.1.10 → 0.1.280

package/dist/esm/slices/sendReceipt.js

@@ -0,0 +1,53 @@
+import { __awaiter, __generator } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+var initialState = {
+    loading: 'idle',
+    error: null
+};
+export var SendReceiptActionType;
+(function (SendReceiptActionType) {
+    SendReceiptActionType["SendReceipt"] = "SendReceipt/sendReceipt";
+})(SendReceiptActionType || (SendReceiptActionType = {}));
+export var sendReceipt = createAsyncThunk(SendReceiptActionType.SendReceipt, function (_a, _b) { return __awaiter(void 0, [_a, _b], void 0, function (_c, _d) {
+    var api, err_1;
+    var orderUuid = _c.orderUuid, data = _c.data;
+    var getState = _d.getState, rejectWithValue = _d.rejectWithValue;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                _e.trys.push([0, 2, , 3]);
+                api = getState().config.api;
+                return [4 /*yield*/, api.postSendReceipt(orderUuid, data)];
+            case 1: return [2 /*return*/, _e.sent()];
+            case 2:
+                err_1 = _e.sent();
+                return [2 /*return*/, rejectWithValue(err_1)];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); });
+var sendReceiptSlice = createSlice({
+    name: ReducerType.SendReceipt,
+    initialState: initialState,
+    reducers: {
+        resetSendReceipt: function () { return initialState; }
+    },
+    extraReducers: function (builder) {
+        builder
+            .addCase(sendReceipt.fulfilled, function (state) {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(sendReceipt.pending, function (state) {
+            state.loading = 'pending';
+        })
+            .addCase(sendReceipt.rejected, function (state, action) {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export var resetSendReceipt = sendReceiptSlice.actions.resetSendReceipt;
+export var selectSendReceipt = function (state) { return state.sendReceipt; };
+export var sendReceiptReducer = sendReceiptSlice.reducer;

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

@@ -1,21 +1,45 @@
-import { EntityType, RequestError, RequestStatus, Settings } from '../types';
+import { EntityType, RequestError, RequestStatus, Settings } from '@open-tender/types';
 import { AppState } from '../app';
 export interface SettingsState {
+    data: any | null;
     loading: RequestStatus;
     error: RequestError;
 }
 export declare enum SettingsActionType {
+    FetchSetting = "settings/fetchSetting",
     UpdateSetting = "settings/updateSetting",
     UpdateSettings = "settings/updateSettings"
 }
-export declare const updateSetting: import("@reduxjs/toolkit").AsyncThunk<Settings, EntityType, {
+export declare const fetchSetting: import("@reduxjs/toolkit").AsyncThunk<any, EntityType, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").UnknownAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const updateSetting: import("@reduxjs/toolkit").AsyncThunk<Settings, EntityType | undefined, {
+    state: AppState;
+    rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").UnknownAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const updateSettings: import("@reduxjs/toolkit").AsyncThunk<Settings[], EntityType[], {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").UnknownAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-export declare const resetSettings: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const resetSettings: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"settings/resetSettings">;
 export declare const selectSettings: (state: AppState) => SettingsState;
-export declare const settingsReducer: import("redux").Reducer<SettingsState, import("redux").AnyAction>;
+export declare const settingsReducer: import("redux").Reducer<SettingsState>;

package/dist/esm/slices/settings.js

@@ -2,60 +2,75 @@ import { __awaiter, __generator } from "tslib";
 import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
 import { ReducerType } from './types';
 var initialState = {
+    data: null,
     loading: 'idle',
     error: null
 };
 export var SettingsActionType;
 (function (SettingsActionType) {
+    SettingsActionType["FetchSetting"] = "settings/fetchSetting";
     SettingsActionType["UpdateSetting"] = "settings/updateSetting";
     SettingsActionType["UpdateSettings"] = "settings/updateSettings";
 })(SettingsActionType || (SettingsActionType = {}));
-export var updateSetting = createAsyncThunk(SettingsActionType.UpdateSetting, function (entityType, _a) {
-    var getState = _a.getState, rejectWithValue = _a.rejectWithValue;
-    return __awaiter(void 0, void 0, void 0, function () {
-        var api, err_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    api = getState().config.api;
-                    return [4 /*yield*/, api.postSettings(entityType)];
-                case 1: return [2 /*return*/, _b.sent()];
-                case 2:
-                    err_1 = _b.sent();
-                    return [2 /*return*/, rejectWithValue(err_1)];
-                case 3: return [2 /*return*/];
-            }
-        });
+export var fetchSetting = createAsyncThunk(SettingsActionType.FetchSetting, function (posSettingType_1, _a) { return __awaiter(void 0, [posSettingType_1, _a], void 0, function (posSettingType, _b) {
+    var api, err_1;
+    var getState = _b.getState, rejectWithValue = _b.rejectWithValue;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _c.trys.push([0, 2, , 3]);
+                api = getState().config.api;
+                return [4 /*yield*/, api.getSettings(posSettingType)];
+            case 1: return [2 /*return*/, _c.sent()];
+            case 2:
+                err_1 = _c.sent();
+                return [2 /*return*/, rejectWithValue(err_1)];
+            case 3: return [2 /*return*/];
+        }
     });
-});
-export var updateSettings = createAsyncThunk(SettingsActionType.UpdateSettings, function (entityTypes, _a) {
-    var getState = _a.getState, rejectWithValue = _a.rejectWithValue;
-    return __awaiter(void 0, void 0, void 0, function () {
-        var api_1, requests, err_2;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    api_1 = getState().config.api;
-                    requests = entityTypes.map(function (entityType) { return __awaiter(void 0, void 0, void 0, function () {
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, api_1.postSettings(entityType)];
-                                case 1: return [2 /*return*/, _a.sent()];
-                            }
-                        });
-                    }); });
-                    return [4 /*yield*/, Promise.all(requests)];
-                case 1: return [2 /*return*/, _b.sent()];
-                case 2:
-                    err_2 = _b.sent();
-                    return [2 /*return*/, rejectWithValue(err_2)];
-                case 3: return [2 /*return*/];
-            }
-        });
+}); });
+export var updateSetting = createAsyncThunk(SettingsActionType.UpdateSetting, function (posSettingType_1, _a) { return __awaiter(void 0, [posSettingType_1, _a], void 0, function (posSettingType, _b) {
+    var api, err_2;
+    var getState = _b.getState, rejectWithValue = _b.rejectWithValue;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _c.trys.push([0, 2, , 3]);
+                api = getState().config.api;
+                return [4 /*yield*/, api.postSettings(posSettingType)];
+            case 1: return [2 /*return*/, _c.sent()];
+            case 2:
+                err_2 = _c.sent();
+                return [2 /*return*/, rejectWithValue(err_2)];
+            case 3: return [2 /*return*/];
+        }
     });
-});
+}); });
+export var updateSettings = createAsyncThunk(SettingsActionType.UpdateSettings, function (posSettingTypes_1, _a) { return __awaiter(void 0, [posSettingTypes_1, _a], void 0, function (posSettingTypes, _b) {
+    var api_1, requests, err_3;
+    var getState = _b.getState, rejectWithValue = _b.rejectWithValue;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _c.trys.push([0, 2, , 3]);
+                api_1 = getState().config.api;
+                requests = posSettingTypes.map(function (posSettingType) { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, api_1.postSettings(posSettingType)];
+                            case 1: return [2 /*return*/, _a.sent()];
+                        }
+                    });
+                }); });
+                return [4 /*yield*/, Promise.all(requests)];
+            case 1: return [2 /*return*/, _c.sent()];
+            case 2:
+                err_3 = _c.sent();
+                return [2 /*return*/, rejectWithValue(err_3)];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); });
 var settingsSlice = createSlice({
     name: ReducerType.Settings,
     initialState: initialState,
@@ -64,23 +79,35 @@ var settingsSlice = createSlice({
     },
     extraReducers: function (builder) {
         builder
-            .addCase(updateSetting.fulfilled, function (state) {
+            .addCase(fetchSetting.pending, function (state) {
+            state.loading = 'pending';
+        })
+            .addCase(fetchSetting.fulfilled, function (state, action) {
+            state.data = action.payload;
             state.loading = 'idle';
             state.error = null;
+        })
+            .addCase(fetchSetting.rejected, function (state, action) {
+            state.error = action.payload;
+            state.loading = 'idle';
         })
             .addCase(updateSetting.pending, function (state) {
             state.loading = 'pending';
+        })
+            .addCase(updateSetting.fulfilled, function (state) {
+            state.loading = 'idle';
+            state.error = null;
         })
             .addCase(updateSetting.rejected, function (state, action) {
             state.error = action.payload;
             state.loading = 'idle';
+        })
+            .addCase(updateSettings.pending, function (state) {
+            state.loading = 'pending';
         })
             .addCase(updateSettings.fulfilled, function (state) {
             state.loading = 'idle';
             state.error = null;
-        })
-            .addCase(updateSettings.pending, function (state) {
-            state.loading = 'pending';
         })
             .addCase(updateSettings.rejected, function (state, action) {
             state.error = action.payload;

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

@@ -2,6 +2,6 @@ import { AppState } from '../app';
 export interface SidebarState {
     isOpen: boolean;
 }
-export declare const toggleSidebar: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, openSidebar: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, closeSidebar: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const toggleSidebar: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"sidebar/toggleSidebar">, openSidebar: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"sidebar/openSidebar">, closeSidebar: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"sidebar/closeSidebar">;
 export declare const selectSidebar: (state: AppState) => SidebarState;
-export declare const sidebarReducer: import("redux").Reducer<SidebarState, import("redux").AnyAction>;
+export declare const sidebarReducer: import("redux").Reducer<SidebarState>;

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

@@ -1,4 +1,4 @@
-import { RequestError, RequestStatus, Surcharges, Version } from '../types';
+import { RequestError, RequestStatus, Surcharges, Version } from '@open-tender/types';
 import { AppState } from '../app';
 export interface SurchargesState {
     entities: Surcharges;
@@ -7,16 +7,22 @@ export interface SurchargesState {
     version: Version;
 }
 export declare enum SurchargesActionType {
-    GetSurcharges = "surcharges/getSurcharges"
+    GetSurcharges = "surcharges/fetchSurcharges"
 }
-export declare const getSurcharges: import("@reduxjs/toolkit").AsyncThunk<Surcharges, void, {
+export declare const fetchSurcharges: import("@reduxjs/toolkit").AsyncThunk<Surcharges, void, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").UnknownAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-export declare const resetSurcharges: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const resetSurcharges: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"surcharges/resetSurcharges">;
 export declare const selectSurcharges: (state: AppState) => {
-    entities: import("../types").Surcharge[];
+    entities: import("@open-tender/types").Surcharge[];
     loading: RequestStatus;
     error: RequestError;
 };
-export declare const surchargesReducer: import("redux").Reducer<SurchargesState, import("redux").AnyAction>;
+export declare const surchargesReducer: import("redux").Reducer<SurchargesState>;

package/dist/esm/slices/surcharges.js

@@ -9,29 +9,28 @@ var initialState = {
 };
 export var SurchargesActionType;
 (function (SurchargesActionType) {
-    SurchargesActionType["GetSurcharges"] = "surcharges/getSurcharges";
+    SurchargesActionType["GetSurcharges"] = "surcharges/fetchSurcharges";
 })(SurchargesActionType || (SurchargesActionType = {}));
-export var getSurcharges = createAsyncThunk(SurchargesActionType.GetSurcharges, function (_, _a) {
-    var getState = _a.getState, rejectWithValue = _a.rejectWithValue;
-    return __awaiter(void 0, void 0, void 0, function () {
-        var api, order, serviceType, err_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    api = getState().config.api;
-                    order = { serviceType: 'PICKUP' };
-                    serviceType = order.serviceType;
-                    return [4 /*yield*/, api.getSurcharges(serviceType)];
-                case 1: return [2 /*return*/, _b.sent()];
-                case 2:
-                    err_1 = _b.sent();
-                    return [2 /*return*/, rejectWithValue(err_1)];
-                case 3: return [2 /*return*/];
-            }
-        });
+export var fetchSurcharges = createAsyncThunk(SurchargesActionType.GetSurcharges, function (_1, _a) { return __awaiter(void 0, [_1, _a], void 0, function (_, _b) {
+    var api, serviceType, err_1;
+    var getState = _b.getState, rejectWithValue = _b.rejectWithValue;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _c.trys.push([0, 2, , 3]);
+                api = getState().config.api;
+                serviceType = getState().order.serviceType;
+                if (!serviceType)
+                    return [2 /*return*/, []];
+                return [4 /*yield*/, api.getSurcharges(serviceType)];
+            case 1: return [2 /*return*/, _c.sent()];
+            case 2:
+                err_1 = _c.sent();
+                return [2 /*return*/, rejectWithValue(err_1)];
+            case 3: return [2 /*return*/];
+        }
     });
-});
+}); });
 var surchargesSlice = createSlice({
     name: ReducerType.Surcharges,
     initialState: initialState,
@@ -40,17 +39,17 @@ var surchargesSlice = createSlice({
     },
     extraReducers: function (builder) {
         builder
-            .addCase(getSurcharges.fulfilled, function (state, action) {
+            .addCase(fetchSurcharges.fulfilled, function (state, action) {
             if (action.payload) {
                 state.entities = action.payload;
             }
             state.loading = 'idle';
             state.error = null;
         })
-            .addCase(getSurcharges.pending, function (state) {
+            .addCase(fetchSurcharges.pending, function (state) {
             state.loading = 'pending';
         })
-            .addCase(getSurcharges.rejected, function (state, action) {
+            .addCase(fetchSurcharges.rejected, function (state, action) {
             state.error = action.payload;
             state.loading = 'idle';
         });

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

@@ -0,0 +1,88 @@
+import { Tags, RequestError, RequestStatus } from '@open-tender/types';
+import { AppState } from '../app';
+export interface TagsState {
+    entities: Tags;
+    error: RequestError;
+    loading: RequestStatus;
+    selectedTags: Tags;
+    showTagsModal: boolean;
+}
+export declare enum TagsActionType {
+    FetchTags = "tags/fetchTags"
+}
+export declare const fetchTags: import("@reduxjs/toolkit").AsyncThunk<Tags, void, {
+    state: AppState;
+    rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").UnknownAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const resetTags: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"tags/resetTags">, setSelectedTags: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "tags/setSelectedTags">, toggleTagsModal: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "tags/toggleTagsModal">;
+export declare const selectTags: (state: AppState) => TagsState;
+export declare const selectSelectedTags: (state: AppState) => Tags;
+export declare const selectShowTagsModal: (state: AppState) => boolean;
+export declare const selectSelectedTagNames: ((state: {
+    alerts: import("@open-tender/types").Alerts;
+    allergens: import("./allergens").AllergensState;
+    arrivals: import("./arrivals").ArrivalsState;
+    cartSummary: import("./cartSummary").CartSummaryState;
+    checkout: import("./checkout").CheckoutState;
+    config: import("./config").ConfigState;
+    customer: import("./customer").CustomerState;
+    customerIdentify: import("./customerIdentify").CustomerIdentifyState;
+    deals: import("./deals").DealsState;
+    discounts: import("./discounts").DiscountsState;
+    errorAlerts: import("./errorAlerts").ErrorAlertsState;
+    kds: import("./kds").KdsState;
+    kiosk: import("./kiosk").KioskState;
+    menu: import("./menu").MenuState;
+    menuPages: import("./menuPages").MenuPagesState;
+    modal: import("./modal").ModalState;
+    notifications: import("@open-tender/types").Notifications;
+    offlineAuths: import("./offlineAuths").OfflineAuthsState;
+    order: import("./order").OrderState;
+    pos: import("./pos").PosState;
+    punches: import("./punches").PunchesState;
+    refund: import("./refund").RefundState;
+    sendReceipt: import("./sendReceipt").SendReceiptState;
+    settings: import("./settings").SettingsState;
+    sidebar: import("./sidebar").SidebarState;
+    surcharges: import("./surcharges").SurchargesState;
+    taxes: import("./taxes").TaxesState;
+    idle: import("./idle").IdleState;
+    tags: TagsState;
+    revenueCenter: import("./revenueCenter").RevenueCenterState;
+}) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        tags: Tags;
+        selectedTags: Tags;
+    }) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        tags: Tags;
+        selectedTags: Tags;
+    }) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [(state: AppState) => {
+        tags: Tags;
+        selectedTags: Tags;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const tagsReducer: import("redux").Reducer<TagsState>;

package/dist/esm/slices/tags.js

@@ -0,0 +1,83 @@
+var _a;
+import { __assign, __awaiter, __generator } from "tslib";
+import { createAsyncThunk, createSelector, createSlice } from '@reduxjs/toolkit';
+import { resetMenu } from './menu';
+import { ReducerType } from './types';
+var initialState = {
+    entities: [],
+    error: null,
+    loading: 'idle',
+    selectedTags: [],
+    showTagsModal: false
+};
+export var TagsActionType;
+(function (TagsActionType) {
+    TagsActionType["FetchTags"] = "tags/fetchTags";
+})(TagsActionType || (TagsActionType = {}));
+export var fetchTags = createAsyncThunk(TagsActionType.FetchTags, function (_1, _a) { return __awaiter(void 0, [_1, _a], void 0, function (_, _b) {
+    var api, data, err_1;
+    var getState = _b.getState, rejectWithValue = _b.rejectWithValue;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _c.trys.push([0, 2, , 3]);
+                api = getState().config.api;
+                return [4 /*yield*/, api.getTags()];
+            case 1:
+                data = _c.sent();
+                return [2 /*return*/, data];
+            case 2:
+                err_1 = _c.sent();
+                return [2 /*return*/, rejectWithValue(err_1)];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); });
+var tagsSlice = createSlice({
+    name: ReducerType.Tags,
+    initialState: initialState,
+    reducers: {
+        resetTags: function (state) { return (__assign(__assign({}, initialState), { entities: state.entities })); },
+        setSelectedTags: function (state, action) {
+            state.selectedTags = action.payload;
+        },
+        toggleTagsModal: function (state, action) {
+            state.showTagsModal = action.payload;
+        }
+    },
+    extraReducers: function (builder) {
+        builder
+            .addCase(fetchTags.fulfilled, function (state, action) {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchTags.pending, function (state) {
+            state.loading = 'pending';
+        })
+            .addCase(fetchTags.rejected, function (state, action) {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+        builder.addCase(resetMenu, function () { return initialState; });
+    }
+});
+export var resetTags = (_a = tagsSlice.actions, _a.resetTags), setSelectedTags = _a.setSelectedTags, toggleTagsModal = _a.toggleTagsModal;
+export var selectTags = function (state) { return state.tags; };
+export var selectSelectedTags = function (state) { return state.tags.selectedTags; };
+export var selectShowTagsModal = function (state) { return state.tags.showTagsModal; };
+export var selectSelectedTagNames = createSelector(function (state) {
+    var _a = state.tags, tags = _a.entities, selectedTags = _a.selectedTags;
+    return { tags: tags, selectedTags: selectedTags };
+}, function (_a) {
+    var tags = _a.tags, selectedTags = _a.selectedTags;
+    if (!selectedTags)
+        return [];
+    var selected = selectedTags.map(function (i) {
+        var _a;
+        var tag = tags.find(function (a) { return a.tag_id === i.tag_id; });
+        return tag ? (_a = tag.name) !== null && _a !== void 0 ? _a : '' : '';
+    });
+    return selected;
+});
+export var tagsReducer = tagsSlice.reducer;

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

@@ -1,4 +1,4 @@
-import { RequestError, RequestStatus, Taxes, Version } from '../types';
+import { RequestError, RequestStatus, Taxes, Version } from '@open-tender/types';
 import { AppState } from '../app';
 export interface TaxesState {
     entities: Taxes;
@@ -7,12 +7,18 @@ export interface TaxesState {
     version: Version;
 }
 export declare enum TaxesActionType {
-    GetTaxes = "taxes/getTaxes"
+    GetTaxes = "taxes/fetchTaxes"
 }
-export declare const getTaxes: import("@reduxjs/toolkit").AsyncThunk<Taxes, void, {
+export declare const fetchTaxes: import("@reduxjs/toolkit").AsyncThunk<Taxes, void, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").UnknownAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-export declare const resetTaxes: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const resetTaxes: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"taxes/resetTaxes">;
 export declare const selectTaxes: (state: AppState) => TaxesState;
-export declare const taxesReducer: import("redux").Reducer<TaxesState, import("redux").AnyAction>;
+export declare const taxesReducer: import("redux").Reducer<TaxesState>;

package/dist/esm/slices/taxes.js

@@ -9,29 +9,28 @@ var initialState = {
 };
 export var TaxesActionType;
 (function (TaxesActionType) {
-    TaxesActionType["GetTaxes"] = "taxes/getTaxes";
+    TaxesActionType["GetTaxes"] = "taxes/fetchTaxes";
 })(TaxesActionType || (TaxesActionType = {}));
-export var getTaxes = createAsyncThunk(TaxesActionType.GetTaxes, function (_, _a) {
-    var getState = _a.getState, rejectWithValue = _a.rejectWithValue;
-    return __awaiter(void 0, void 0, void 0, function () {
-        var api, order, serviceType, orderType, err_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    api = getState().config.api;
-                    order = { serviceType: 'PICKUP', orderType: 'OLO' };
-                    serviceType = order.serviceType, orderType = order.orderType;
-                    return [4 /*yield*/, api.getTaxes(serviceType, orderType)];
-                case 1: return [2 /*return*/, _b.sent()];
-                case 2:
-                    err_1 = _b.sent();
-                    return [2 /*return*/, rejectWithValue(err_1)];
-                case 3: return [2 /*return*/];
-            }
-        });
+export var fetchTaxes = createAsyncThunk(TaxesActionType.GetTaxes, function (_1, _a) { return __awaiter(void 0, [_1, _a], void 0, function (_, _b) {
+    var api, _c, serviceType, orderType, err_1;
+    var getState = _b.getState, rejectWithValue = _b.rejectWithValue;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _d.trys.push([0, 2, , 3]);
+                api = getState().config.api;
+                _c = getState().order, serviceType = _c.serviceType, orderType = _c.orderType;
+                if (!serviceType || !orderType)
+                    return [2 /*return*/, []];
+                return [4 /*yield*/, api.getTaxes(serviceType, orderType)];
+            case 1: return [2 /*return*/, _d.sent()];
+            case 2:
+                err_1 = _d.sent();
+                return [2 /*return*/, rejectWithValue(err_1)];
+            case 3: return [2 /*return*/];
+        }
     });
-});
+}); });
 var taxesSlice = createSlice({
     name: ReducerType.Taxes,
     initialState: initialState,
@@ -40,17 +39,17 @@ var taxesSlice = createSlice({
     },
     extraReducers: function (builder) {
         builder
-            .addCase(getTaxes.fulfilled, function (state, action) {
+            .addCase(fetchTaxes.fulfilled, function (state, action) {
             if (action.payload) {
                 state.entities = action.payload;
             }
             state.loading = 'idle';
             state.error = null;
         })
-            .addCase(getTaxes.pending, function (state) {
+            .addCase(fetchTaxes.pending, function (state) {
             state.loading = 'pending';
         })
-            .addCase(getTaxes.rejected, function (state, action) {
+            .addCase(fetchTaxes.rejected, function (state, action) {
             state.error = action.payload;
             state.loading = 'idle';
         });