@fast-simon/dashboard-utilities 1.0.37 → 1.0.38

package/dist/dashboard/dashboard-client/src/store/merchandising/merchandisingSlice.js

@@ -1,660 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { createAsyncThunk, createSlice } from "@reduxjs/toolkit";
-import { EditorVersion, MerchandisingType } from "./models";
-import { Merchandising } from "../../services/merchandising";
-import { deleteCollectionsMerchandisingRule, fetchCollectionsMerchandising, pushCollectionsRulesToSites, setCollectionsMerchandisingRule, updateShopifyCollection } from "./actions/collectionsActions";
-import { formatCollectionsMerchandisingRule, formatSearchMerchandisingRule } from "./rules";
-import { defaultMerchandisingStrategiesState } from "./models/strategiesModels";
-import { fetchMerchandisingStrategies, fetchStrategyStatus, updateMerchandisingStrategy } from "./actions/strategiesActions";
-import { resetState } from "../store";
-import { defaultEditedRule } from "./models/merchandisingRulesModels";
-import { NoResultsMode } from "./models/noResults";
-import { defaultProductMerchandising } from "./models/productMerchandising";
-import { fetchProductMerchandisingRanked, searchProductMerchandising, updateProductMerchandising } from "./actions/productActions";
-import { defaultPreviewConfig } from "./models/previewConfig";
-import { fetchPreviewConfig } from "./actions/configActions";
-import { rebuildStrategiesGroupOrder } from "../../pages/Merchandising/MerchandisingStrategies/utils";
-import { addBanner, deleteBanner, editBanner, fetchBanners } from "./actions/bannerActions";
-import { getToggledEditorVersionVal } from "../../pages/Merchandising/editor/utils";
-const initialState = {
-    searchMerchandising: {
-        isLoading: true,
-        rules: [],
-        editorVersion: EditorVersion.JQUERY,
-        isShowUpgrade: false
-    },
-    merchandisingStrategies: defaultMerchandisingStrategiesState,
-    productMerchandising: defaultProductMerchandising,
-    geographies: {
-        countryCode: "",
-        geographies: {}
-    },
-    merchandisingRules: {
-        errorMessage: '',
-        rules: [],
-        editedRule: defaultEditedRule,
-        isOpenEditor: false,
-        preview: {
-            scope: { type: '', value: '' },
-            scopeRules: []
-        }
-    },
-    collectionsMerchandising: {
-        rules: [],
-        isWriteProductsShopifyPermission: false,
-        editorVersion: EditorVersion.REACT,
-        isShowUpgrade: false
-    },
-    collectionPushedToShopify: null,
-    noResults: {
-        mode: NoResultsMode.Auto,
-        products_ids: [],
-        banner_html: ''
-    },
-    table: {
-        collectionsMerchandising: {
-            page: 1,
-            resultsPerPage: 25,
-            query: ""
-        },
-        searchMerchandising: {
-            page: 1,
-            resultsPerPage: 25,
-            query: ""
-        }
-    },
-    loading: {
-        collectionsMerchandising: {
-            rules: true,
-            pushingToShopify: false,
-            pushToSites: false
-        },
-        merchandisingRules: {
-            rules: false,
-            pushToSites: false
-        }
-    },
-    dataReceived: false,
-    previewConfig: defaultPreviewConfig,
-    segmentInPreview: "",
-    promotiles: [],
-    promotilesLoading: false,
-    banners: [],
-    bannersLoading: false,
-    relatedCollections: [],
-    editorProductsPerPage: { search: 30, collection: 30 }
-};
-export const fetchPromotiles = createAsyncThunk('merchandising/fetchPromotiles', () => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.fetchPromotiles()).data;
-}));
-export const addPromotile = createAsyncThunk('merchandising/addPromotile', (promotile) => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.addPromotile(promotile)).data;
-}));
-export const editPromotile = createAsyncThunk('merchandising/editPromotile', (promotile) => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.editPromotile(promotile)).data;
-}));
-export const deletePromotile = createAsyncThunk('merchandising/deletePromotile', (id) => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.deletePromotile(id)).data;
-}));
-export const fetchMerchandising = createAsyncThunk('merchandising/fetchMerchandising', () => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.fetchMerchandising()).data;
-}));
-export const fetchSearchMerchandising = createAsyncThunk('merchandising/fetchSearchMerchandising', () => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.fetchSearchMerchandising()).data;
-}));
-export const fetchGeographies = createAsyncThunk('merchandising/fetchGeographies', () => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.fetchGeographies()).data;
-}));
-export const uploadSearchMerchandisingRules = createAsyncThunk('merchandising/uploadSearchMerchandisingRules', ({ rules, ruleIndex }) => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.uploadSearchMerchandisingRules(rules, ruleIndex)).data;
-}));
-export const resetVariationMerchandisingRules = createAsyncThunk('merchandising/resetVariationMerchandisingRules', (variation_id) => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.resetVariationMerchandisingRules(variation_id)).data;
-}));
-export const clearVariationMerchandisingRules = createAsyncThunk('merchandising/clearVariationMerchandisingRules', (variation_id) => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.clearVariationMerchandisingRules(variation_id)).data;
-}));
-export const fetchMerchandisingRulesRules = createAsyncThunk('merchandising/fetchMerchandisingRulesRules', (variation_id) => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.fetchMerchandisingRulesRules(variation_id)).data;
-}));
-export const uploadMerchRulesRules = createAsyncThunk('merchandising/uploadMerchandisingRulesRules', ({ rules, oldRules, variation_id }, { rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const data = (yield Merchandising.uploadMerchandisingRulesRules(rules, variation_id)).data;
-        if (!data.success) {
-            console.error('Failed to save rule.');
-        }
-        return data;
-    }
-    catch (error) {
-        console.error(error);
-        return rejectWithValue(null);
-    }
-}));
-export const getProductsPerPage = createAsyncThunk('merchandising/getProductsPerPage', () => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.getProductsPerPage()).data;
-}));
-/**
- * Removes pinned products that have negative indexes or that are in the promoted region.
- * @param pinned
- * @param promoted
- */
-export function fixPinnedProducts(pinned, promoted) {
-    return pinned.filter(([index]) => index >= promoted.length);
-}
-export const fetchNoResultsConfig = createAsyncThunk('merchandising/fetchNoResultsConfig', () => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.fetchNoResultsConfig()).data;
-}));
-export const setNoResultsMerchandisingMode = createAsyncThunk('merchandising/setNoResultsMerchandisingMode', (mode) => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.setNoResultsMerchandisingMode(mode)).data;
-}));
-export const setNoResultsMerchandisingRule = createAsyncThunk('merchandising/setNoResultsMerchandisingRule', ({ productsIds, bannerHtml }) => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.setNoResultsMerchandisingRule(productsIds, bannerHtml)).data;
-}));
-export const pushMerchandisingRulesToSites = createAsyncThunk('merchandising/pushMerchandisingRulesToSites', ({ sites }) => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.pushMerchandisingRulesToSites(sites)).data;
-}));
-export const toggleEditorVersion = createAsyncThunk('merchandising/toggleEditorVersion', ({ merchType, version }) => __awaiter(void 0, void 0, void 0, function* () {
-    return (yield Merchandising.toggleEditorVersion(merchType, version)).data;
-}));
-const merchandisingSlice = createSlice({
-    name: 'merchandising',
-    initialState,
-    reducers: {
-        setMerchRulesEditedRule: (state, action) => {
-            state.merchandisingRules.editedRule = action.payload;
-        },
-        setMerchandisingRulesEditedIndex: (state, action) => {
-            state.merchandisingRules.editedRule.index = action.payload;
-        },
-        setMerchRulesIsSearchContext: (state, action) => {
-            state.merchandisingRules.editedRule.isSearchContext = action.payload;
-        },
-        setMerchRulesIsAllQueries: (state, action) => {
-            state.merchandisingRules.editedRule.isAllQueries = action.payload;
-        },
-        setMerchRulesSearchContextValues: (state, action) => {
-            state.merchandisingRules.editedRule.searchContextValues = action.payload;
-        },
-        setMerchRulesIsCategoriesContext: (state, action) => {
-            state.merchandisingRules.editedRule.isCategoriesContext = action.payload;
-        },
-        setMerchRulesIsAllCategories: (state, action) => {
-            state.merchandisingRules.editedRule.isAllCategories = action.payload;
-        },
-        setMerchRulesCategoriesContextValues: (state, action) => {
-            state.merchandisingRules.editedRule.categoriesContextValues = action.payload;
-        },
-        setMerchRulesRuleType: (state, action) => {
-            state.merchandisingRules.editedRule.type = action.payload;
-        },
-        setMerchRulesAction: (state, action) => {
-            state.merchandisingRules.editedRule.action = action.payload;
-        },
-        setMerchRulesPromotionLevel: (state, action) => {
-            state.merchandisingRules.editedRule.promotionLevel = action.payload;
-        },
-        setMerchRulesSegments: (state, action) => {
-            state.merchandisingRules.editedRule.segments = action.payload;
-        },
-        setMerchRulesErrorMessage: (state, action) => {
-            state.merchandisingRules.errorMessage = action.payload;
-        },
-        setMerchRulesPreviewScope: (state, action) => {
-            state.merchandisingRules.preview.scope = action.payload;
-        },
-        setMerchRulesPreviewScopeRules: (state, action) => {
-            state.merchandisingRules.preview.scopeRules = action.payload;
-        },
-        toggleDataReceived: (state, action) => {
-            state.dataReceived = action.payload;
-        },
-        setCollectionTablePage: (state, action) => {
-            state.table.collectionsMerchandising.page = action.payload;
-        },
-        setCollectionTableResultsPerPage: (state, action) => {
-            state.table.collectionsMerchandising.resultsPerPage = action.payload;
-        },
-        setCollectionTableQuery: (state, action) => {
-            state.table.collectionsMerchandising.query = action.payload;
-        },
-        resetCollectionTable: (state) => {
-            state.table.collectionsMerchandising = initialState.table.collectionsMerchandising;
-        },
-        setSearchTablePage: (state, action) => {
-            state.table.searchMerchandising.page = action.payload;
-        },
-        setSearchTableResultsPerPage: (state, action) => {
-            state.table.searchMerchandising.resultsPerPage = action.payload;
-        },
-        setSearchTableQuery: (state, action) => {
-            state.table.searchMerchandising.query = action.payload;
-        },
-        resetSearchTable: (state) => {
-            state.table.searchMerchandising = initialState.table.searchMerchandising;
-        },
-        setSegmentInPreview: (state, action) => {
-            state.segmentInPreview = action.payload;
-        },
-        setIsShowEditorUpgrade: (state, action) => {
-            if (action.payload.merchType === MerchandisingType.COLLECTIONS) {
-                state.collectionsMerchandising.isShowUpgrade = action.payload.value;
-            }
-            else if (action.payload.merchType === MerchandisingType.SEARCH) {
-                state.searchMerchandising.isShowUpgrade = action.payload.value;
-            }
-        },
-        setEditorVersion: (state, action) => {
-            setEditorVersionState(state, action.payload.merchType, action.payload.version);
-        }
-    },
-    extraReducers: builder => {
-        builder.addCase(resetState, () => initialState);
-        builder.addCase(fetchPromotiles.pending, (state, action) => {
-            state.promotilesLoading = true;
-        });
-        builder.addCase(fetchPromotiles.fulfilled, (state, action) => {
-            state.promotiles = action.payload.promotiles;
-            state.promotilesLoading = false;
-        });
-        builder.addCase(addPromotile.pending, (state, action) => {
-            state.promotiles = [...state.promotiles, action.meta.arg];
-        });
-        builder.addCase(addPromotile.fulfilled, (state, action) => {
-            const promotileId = state.promotiles.findIndex((promotile) => promotile.id === "");
-            state.promotiles[promotileId].id = action.payload.id;
-        });
-        builder.addCase(editPromotile.pending, (state, action) => {
-            const promotileId = state.promotiles.findIndex((promotile) => promotile.id === action.meta.arg.id);
-            state.promotiles[promotileId] = action.meta.arg;
-        });
-        builder.addCase(deletePromotile.pending, (state, action) => {
-            state.promotiles = state.promotiles.filter((promotile) => promotile.id !== action.meta.arg);
-        });
-        builder.addCase(fetchMerchandising.fulfilled, (state, action) => {
-            //not in use
-        });
-        builder.addCase(fetchSearchMerchandising.fulfilled, (state, action) => {
-            state.searchMerchandising = {
-                rules: action.payload.rules.map(rule => formatSearchMerchandisingRule(rule)),
-                editorVersion: action.payload.editorVersion,
-                isShowUpgrade: action.payload.isShowUpgrade,
-                isLoading: false
-            };
-        });
-        builder.addCase(fetchMerchandisingStrategies.pending, (state, action) => {
-            state.merchandisingStrategies.status = "loading";
-        });
-        builder.addCase(fetchMerchandisingStrategies.rejected, (state, action) => {
-            state.merchandisingStrategies.status = "error";
-        });
-        builder.addCase(fetchMerchandisingStrategies.fulfilled, (state, action) => {
-            const strategies = rebuildStrategiesGroupOrder(action.payload.strategies);
-            state.merchandisingStrategies = {
-                status: "fulfilled",
-                strategies: strategies
-            };
-        });
-        builder.addCase(updateMerchandisingStrategy.pending, (state, action) => {
-            let { strategy, key } = action.meta.arg;
-            if (action.meta.arg.action === "add") {
-                strategy.status = "saving";
-                state.merchandisingStrategies.strategies.push(strategy);
-            }
-            else if (action.meta.arg.action === "delete") {
-                state.merchandisingStrategies.strategies = state.merchandisingStrategies.strategies.filter(s => s.key !== key);
-            }
-            else if (action.meta.arg.action === "change") {
-                strategy.status = "updating";
-                state.merchandisingStrategies.strategies = state.merchandisingStrategies.strategies.map(s => {
-                    if (key === s.key) {
-                        return strategy;
-                    }
-                    return s;
-                });
-            }
-        });
-        builder.addCase(updateMerchandisingStrategy.rejected, (state, action) => {
-            if (action.meta.arg.action === "add") {
-                state.merchandisingStrategies.strategies = state.merchandisingStrategies.strategies.map(s => {
-                    if (!s.key) {
-                        s.status = "error";
-                    }
-                    return s;
-                });
-            }
-        });
-        builder.addCase(updateMerchandisingStrategy.fulfilled, (state, action) => {
-            state.merchandisingStrategies.strategies = state.merchandisingStrategies.strategies.map(s => {
-                if (!s.key) {
-                    s.key = action.payload;
-                }
-                return s;
-            });
-        });
-        builder.addCase(fetchStrategyStatus.fulfilled, (state, action) => {
-            const strategyKey = action.meta.arg.key;
-            state.merchandisingStrategies.strategies = state.merchandisingStrategies.strategies.map(s => {
-                if (s.key === strategyKey) {
-                    s.status = action.payload.status ? "ready" : s.status;
-                }
-                return s;
-            });
-        });
-        builder.addCase(fetchGeographies.fulfilled, (state, action) => {
-            state.geographies = action.payload;
-        });
-        builder.addCase(fetchMerchandisingRulesRules.pending, (state, action) => {
-            state.loading.merchandisingRules.rules = true;
-            state.merchandisingRules.errorMessage = '';
-        });
-        builder.addCase(fetchMerchandisingRulesRules.rejected, (state, action) => {
-            state.loading.merchandisingRules.rules = false;
-        });
-        builder.addCase(fetchMerchandisingRulesRules.fulfilled, (state, action) => {
-            state.loading.merchandisingRules.rules = false;
-            if (action.payload.success) {
-                state.merchandisingRules.rules = action.payload.rules;
-            }
-        });
-        builder.addCase(uploadMerchRulesRules.pending, (state, action) => {
-            state.merchandisingRules.errorMessage = '';
-            state.merchandisingRules.rules = action.meta.arg.rules;
-        });
-        builder.addCase(uploadMerchRulesRules.rejected, (state, action) => {
-            state.merchandisingRules.errorMessage =
-                'There was an error while saving the rule, please try again.';
-            state.merchandisingRules.rules = action.meta.arg.oldRules;
-        });
-        builder.addCase(uploadMerchRulesRules.fulfilled, (state, action) => {
-            if (action.payload.success === false) {
-                state.merchandisingRules.errorMessage =
-                    'There was an error while saving the rule, please try again.';
-                state.merchandisingRules.rules = action.meta.arg.oldRules;
-            }
-        });
-        builder.addCase(resetVariationMerchandisingRules.pending, (state, action) => {
-            state.loading.merchandisingRules.rules = true;
-        });
-        builder.addCase(resetVariationMerchandisingRules.rejected, (state, action) => {
-        });
-        builder.addCase(resetVariationMerchandisingRules.fulfilled, (state, action) => {
-            state.merchandisingRules.rules = action.payload.rules;
-            state.loading.merchandisingRules.rules = false;
-        });
-        builder.addCase(clearVariationMerchandisingRules.pending, (state, action) => {
-            state.loading.merchandisingRules.rules = true;
-        });
-        builder.addCase(clearVariationMerchandisingRules.fulfilled, (state, action) => {
-            state.merchandisingRules.rules = [];
-            state.loading.merchandisingRules.rules = false;
-        });
-        builder.addCase(uploadSearchMerchandisingRules.pending, (state, action) => {
-            state.searchMerchandising.rules = action.meta.arg.rules;
-        });
-        builder.addCase(uploadSearchMerchandisingRules.fulfilled, (state, action) => {
-            state.searchMerchandising.rules = action.payload.rules.map(rule => (Object.assign(Object.assign({}, rule), { isNew: false })));
-        });
-        builder.addCase(fetchCollectionsMerchandising.pending, state => {
-            state.loading.collectionsMerchandising.rules = true;
-        });
-        builder.addCase(fetchCollectionsMerchandising.fulfilled, (state, action) => {
-            const rules = action.payload.rules;
-            state.collectionsMerchandising.rules =
-                rules.map(rule => formatCollectionsMerchandisingRule(rule));
-            state.collectionsMerchandising.editorVersion = action.payload.editorVersion;
-            state.collectionsMerchandising.isShowUpgrade = action.payload.isShowUpgrade;
-            state.collectionsMerchandising.isWriteProductsShopifyPermission =
-                action.payload.isWriteProductsShopifyPermission;
-            state.loading.collectionsMerchandising.rules = false;
-        });
-        builder.addCase(setCollectionsMerchandisingRule.pending, (state, action) => {
-            var _a, _b;
-            const newRule = {
-                ruleInput: action.meta.arg.rule.ruleInput,
-                promoted: action.meta.arg.rule.promoted,
-                buried: action.meta.arg.rule.buried,
-                hidden: action.meta.arg.rule.hidden,
-                pinned: action.meta.arg.rule.pinned.map(([index, id]) => [index, id.toString()]),
-                promotiles: (_a = action.meta.arg.rule.promotiles) !== null && _a !== void 0 ? _a : {},
-                start_time: action.meta.arg.rule.start_time,
-                end_time: action.meta.arg.rule.end_time,
-                description: action.meta.arg.rule.description,
-                geos: action.meta.arg.rule.geos,
-                banner_html: action.meta.arg.rule.banner_html,
-                banner_html_mobile: action.meta.arg.rule.banner_html_mobile,
-                last_modified: null,
-                isNew: true,
-                id: action.meta.arg.rule.id,
-                relatedCollections: action.meta.arg.rule.relatedCollections,
-                selectedBannerId: (_b = action.meta.arg.rule.selectedBannerId) !== null && _b !== void 0 ? _b : '',
-            };
-            const rules = state.collectionsMerchandising.rules;
-            const existingRuleIndex = rules.findIndex(rule => rule.id === newRule.id);
-            if (existingRuleIndex !== -1) {
-                state.collectionsMerchandising.rules[existingRuleIndex] = newRule;
-            }
-            else {
-                state.collectionsMerchandising.rules.push(newRule);
-            }
-        });
-        builder.addCase(setCollectionsMerchandisingRule.fulfilled, (state, action) => {
-            state.collectionsMerchandising.rules =
-                state.collectionsMerchandising.rules.map(rule => {
-                    if (!rule.isNew) {
-                        return rule;
-                    }
-                    return Object.assign(Object.assign({}, rule), { isNew: false, id: action.payload.id });
-                });
-        });
-        builder.addCase(setCollectionsMerchandisingRule.rejected, (state) => {
-            state.collectionsMerchandising.rules =
-                state.collectionsMerchandising.rules.map(rule => {
-                    return Object.assign(Object.assign({}, rule), { isNew: false });
-                });
-        });
-        builder.addCase(deleteCollectionsMerchandisingRule.pending, (state, action) => {
-            state.collectionsMerchandising.rules =
-                state.collectionsMerchandising.rules.filter(rule => rule.id !== action.meta.arg.ruleId);
-        });
-        builder.addCase(updateShopifyCollection.pending, (state, action) => {
-            state.loading.collectionsMerchandising.pushingToShopify = true;
-            state.collectionPushedToShopify = action.meta.arg;
-        });
-        builder.addCase(updateShopifyCollection.fulfilled, (state, action) => {
-            state.loading.collectionsMerchandising.pushingToShopify = false;
-            state.collectionPushedToShopify = null;
-        });
-        builder.addCase(updateShopifyCollection.rejected, (state, action) => {
-            state.loading.collectionsMerchandising.pushingToShopify = false;
-            state.collectionPushedToShopify = null;
-        });
-        builder.addCase(pushCollectionsRulesToSites.pending, (state) => {
-            state.loading.collectionsMerchandising.pushToSites = true;
-        });
-        builder.addCase(pushCollectionsRulesToSites.fulfilled, (state) => {
-            state.loading.collectionsMerchandising.pushToSites = false;
-        });
-        builder.addCase(pushCollectionsRulesToSites.rejected, (state) => {
-            state.loading.collectionsMerchandising.pushToSites = false;
-        });
-        builder.addCase(pushMerchandisingRulesToSites.pending, (state) => {
-            state.loading.merchandisingRules.pushToSites = true;
-            state.loading.merchandisingRules.rules = true;
-        });
-        builder.addCase(pushMerchandisingRulesToSites.fulfilled, (state, action) => {
-            state.loading.merchandisingRules.pushToSites = false;
-            state.loading.merchandisingRules.rules = false;
-            if (action.payload.success) {
-                state.merchandisingRules.rules = action.payload.rules;
-            }
-        });
-        builder.addCase(pushMerchandisingRulesToSites.rejected, (state) => {
-            state.loading.merchandisingRules.pushToSites = false;
-            state.loading.merchandisingRules.rules = false;
-        });
-        builder.addCase(fetchNoResultsConfig.fulfilled, (state, action) => {
-            state.noResults.mode = action.payload.mode;
-            state.noResults.products_ids = action.payload.data.products_ids;
-            state.noResults.banner_html = action.payload.data.banner_html;
-        });
-        builder.addCase(setNoResultsMerchandisingMode.pending, (state, action) => {
-            state.noResults.mode = action.meta.arg;
-        });
-        builder.addCase(setNoResultsMerchandisingRule.pending, (state, action) => {
-            state.noResults.products_ids = action.meta.arg.productsIds;
-            state.noResults.banner_html = action.meta.arg.bannerHtml;
-        });
-        builder.addCase(setNoResultsMerchandisingMode.rejected, (state, action) => {
-            state.noResults.mode = action.meta.arg === NoResultsMode.Auto ? NoResultsMode.Manual : NoResultsMode.Auto;
-        });
-        builder.addCase(fetchProductMerchandisingRanked.fulfilled, (state, action) => {
-            state.productMerchandising.productRanking = action.payload;
-            state.productMerchandising.isLoading.ranked = false;
-        });
-        builder.addCase(searchProductMerchandising.pending, (state, action) => {
-            state.productMerchandising.query = action.meta.arg.query;
-            state.productMerchandising.isLoading.search = true;
-        });
-        builder.addCase(searchProductMerchandising.fulfilled, (state, action) => {
-            state.productMerchandising.searchProducts = action.payload;
-            state.productMerchandising.isLoading.search = false;
-        });
-        builder.addCase(fetchPreviewConfig.fulfilled, (state, action) => {
-            state.previewConfig = Object.assign(Object.assign({}, action.payload), { isLoading: false });
-        });
-        builder.addCase(updateProductMerchandising.pending, (state, action) => {
-            const { source, product } = action.meta.arg;
-            if (source === "ranking") {
-                if (product.ranking !== 0) {
-                    // update ranking for a product inside the current group
-                    state.productMerchandising.productRanking = state.productMerchandising.productRanking.map(p => {
-                        if (p.id === product.id) {
-                            return product;
-                        }
-                        return p;
-                    });
-                }
-                else {
-                    state.productMerchandising.productRanking = state.productMerchandising.productRanking.filter(p => p.id !== product.id);
-                }
-                // id might be in search product as well
-                state.productMerchandising.searchProducts = state.productMerchandising.searchProducts.map(p => {
-                    if (p.id === product.id) {
-                        return product;
-                    }
-                    return p;
-                });
-            }
-            else {
-                if (product.ranking !== 0) {
-                    // move to current group and remove from search group
-                    state.productMerchandising.productRanking.unshift(product);
-                    state.productMerchandising.searchProducts = state.productMerchandising.searchProducts.filter(p => p.id !== product.id);
-                }
-            }
-        });
-        builder.addCase(toggleEditorVersion.pending, (state, action) => {
-            setEditorVersionState(state, action.meta.arg.merchType, action.meta.arg.version);
-        });
-        builder.addCase(toggleEditorVersion.rejected, (state, action) => {
-            const toggledVersion = getToggledEditorVersionVal(action.meta.arg.version);
-            setEditorVersionState(state, action.meta.arg.merchType, toggledVersion);
-        });
-        builder.addCase(fetchBanners.pending, (state, action) => {
-            state.bannersLoading = true;
-        });
-        builder.addCase(fetchBanners.fulfilled, (state, action) => {
-            state.banners = action.payload.banners;
-            state.bannersLoading = false;
-        });
-        builder.addCase(addBanner.pending, (state, action) => {
-            state.banners = [...state.banners, action.meta.arg];
-        });
-        builder.addCase(editBanner.pending, (state, action) => {
-        });
-        builder.addCase(deleteBanner.pending, (state, action) => {
-            state.banners = state.banners.filter((banner) => banner.id !== action.meta.arg);
-        });
-        builder.addCase(getProductsPerPage.fulfilled, (state, action) => {
-            state.editorProductsPerPage = action.payload.products_per_page;
-        });
-    }
-});
-export const selectPromotiles = (state) => ({
-    promotiles: state.merchandising.promotiles,
-    isLoading: state.merchandising.promotilesLoading
-});
-export const selectSearchMerchandisingRules = (state) => state.merchandising.searchMerchandising;
-export const selectMerchandisingStrategies = (state) => state.merchandising.merchandisingStrategies;
-export const selectGeographies = (state) => state.merchandising.geographies;
-export const selectMerchandisingRules = (state) => state.merchandising.merchandisingRules;
-export const selectCollectionsMerchandising = (state) => state.merchandising.collectionsMerchandising;
-export const selectMerchandisingLoading = (state) => state.merchandising.loading;
-export const selectCollectionPushedToShopify = (state) => state.merchandising.collectionPushedToShopify;
-export const selectNoResultsMode = (state) => state.merchandising.noResults.mode;
-export const selectNoResultsProducts = (state) => state.merchandising.noResults.products_ids;
-export const selectNoResultsBanner = (state) => state.merchandising.noResults.banner_html;
-export const selectProductMerchandising = (state) => state.merchandising.productMerchandising;
-export const selectIsDataReceivedMerch = (state) => state.merchandising.dataReceived;
-export const selectMerchandisingPreviewConfig = (state) => state.merchandising.previewConfig;
-export const selectMerchandisingCollectionTable = (state) => state.merchandising.table.collectionsMerchandising;
-export const selectMerchandisingSearchTable = (state) => state.merchandising.table.searchMerchandising;
-export const selectMerchRulesEditedRuleSegments = (state) => state.merchandising.merchandisingRules.editedRule.segments;
-export const selectSegmentInPreview = (state) => state.merchandising.segmentInPreview;
-export const selectCollectionsEditorVersion = (state) => state.merchandising.collectionsMerchandising.editorVersion;
-export const selectSearchEditorVersion = (state) => state.merchandising.searchMerchandising.editorVersion;
-export const selectIsShowCollectionsEditorUpgrade = (state) => state.merchandising.collectionsMerchandising.isShowUpgrade;
-export const selectIsShowSearchEditorUpgrade = (state) => state.merchandising.searchMerchandising.isShowUpgrade;
-export const selectProductsPerPage = (state) => state.merchandising.editorProductsPerPage;
-export const selectBanners = (state) => ({
-    banners: state.merchandising.banners,
-    isLoading: state.merchandising.bannersLoading
-});
-export const setMerchRulesIsSearchContext = merchandisingSlice.actions.setMerchRulesIsSearchContext;
-export const setMerchRulesIsAllQueries = merchandisingSlice.actions.setMerchRulesIsAllQueries;
-export const setMerchRulesSearchContextValues = merchandisingSlice.actions.setMerchRulesSearchContextValues;
-export const setMerchRulesIsCategoriesContext = merchandisingSlice.actions.setMerchRulesIsCategoriesContext;
-export const setMerchRulesIsAllCategories = merchandisingSlice.actions.setMerchRulesIsAllCategories;
-export const setMerchRulesCategoriesContextValues = merchandisingSlice.actions.setMerchRulesCategoriesContextValues;
-export const setMerchRulesRuleType = merchandisingSlice.actions.setMerchRulesRuleType;
-export const setMerchRulesEditedRule = merchandisingSlice.actions.setMerchRulesEditedRule;
-export const setMerchRulesAction = merchandisingSlice.actions.setMerchRulesAction;
-export const setMerchRulesPromotionLevel = merchandisingSlice.actions.setMerchRulesPromotionLevel;
-export const setMerchRulesSegments = merchandisingSlice.actions.setMerchRulesSegments;
-export const setMerchRulesErrorMessage = merchandisingSlice.actions.setMerchRulesErrorMessage;
-export const setMerchRulesPreviewScope = merchandisingSlice.actions.setMerchRulesPreviewScope;
-export const setMerchRulesPreviewScopeRules = merchandisingSlice.actions.setMerchRulesPreviewScopeRules;
-export const setMerchDataReceived = merchandisingSlice.actions.toggleDataReceived;
-export const setIsShowEditorUpgrade = merchandisingSlice.actions.setIsShowEditorUpgrade;
-export const setEditorVersion = merchandisingSlice.actions.setEditorVersion;
-export const setMerchCollectionTable = {
-    setPage: merchandisingSlice.actions.setCollectionTablePage,
-    setResultPerPage: merchandisingSlice.actions.setCollectionTableResultsPerPage,
-    setQuery: merchandisingSlice.actions.setCollectionTableQuery,
-    reset: merchandisingSlice.actions.resetCollectionTable
-};
-export const setMerchSearchTable = {
-    setPage: merchandisingSlice.actions.setSearchTablePage,
-    setResultPerPage: merchandisingSlice.actions.setSearchTableResultsPerPage,
-    setQuery: merchandisingSlice.actions.setSearchTableQuery,
-    reset: merchandisingSlice.actions.resetSearchTable,
-};
-function setEditorVersionState(state, merchType, version) {
-    if (merchType === MerchandisingType.COLLECTIONS) {
-        state.collectionsMerchandising.editorVersion = version;
-    }
-    else if (merchType === MerchandisingType.SEARCH) {
-        state.searchMerchandising.editorVersion = version;
-    }
-}
-export const setSegmentInPreview = merchandisingSlice.actions.setSegmentInPreview;
-export default merchandisingSlice.reducer;
-//# sourceMappingURL=merchandisingSlice.js.map