@fast-simon/dashboard-utilities 1.0.35 → 1.0.37

package/dist/dashboard/dashboard-client/src/store/searchResults/searchResultsSlice.js

@@ -0,0 +1,689 @@
+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 { serpConfigurationDefaultState } from "./models/configurationModels";
+import { badgesDefaultState } from "./models/badgesModels";
+import { createAsyncThunk, createSlice } from "@reduxjs/toolkit";
+import { SearchResults } from "../../services/searchResults";
+import { resetState } from "../store";
+import { reviewsDefaultState } from "./models/reviewsModels";
+import { defaultRetailPackState } from "./models/retailPackModels";
+import { advancedConfigurationDefaultState } from "./models/advancedConfigModels";
+import { deleteColorFamily, fetchColorFamily, fetchColorMapping, toggleColorFamilySwitch, updateColorFamily, updateColorMapping, updateVisualTags, uploadImageHoverMode, uploadProductsSplit, uploadRetailPack } from "./actions/retailPackActions";
+import { setReviewProvider, testCredentials, toggleReviewProvider } from "./actions/reviewActions";
+import { defaultPreviewState } from "./models/previewModels";
+import { fetchPreviewURL } from "./actions/serpPreviewActions";
+import { API_BASE_URL } from "../../services/config";
+import { shopperExperienceDefaultState } from "./models/shopperExperienceModel";
+import { getErrorMessage } from "../../pages/SearchResults/pages/Configuration/utils";
+const initialState = {
+    isLoading: true,
+    previewState: defaultPreviewState,
+    shopperExperience: shopperExperienceDefaultState,
+    configuration: serpConfigurationDefaultState,
+    customCSS: { value: "", loading: false, uploadFailed: false, },
+    editedCSS: '',
+    mode: "desktop",
+    advancedConfig: advancedConfigurationDefaultState,
+    reviews: reviewsDefaultState,
+    retailPack: defaultRetailPackState,
+    badgesPage: badgesDefaultState,
+    timeStamp: 0,
+    swatches: [],
+    defaultSwatches: [],
+    options: [],
+    isSwatchesLoading: true,
+    unmappedColor: "",
+    loading: {
+        colorFamily: true,
+        colorMapping: true,
+        pushToSites: false
+    }
+};
+export const fetchSearchResults = createAsyncThunk('SearchResults/fetchSearchResults', ({ searchParams = {} }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.getSetup(searchParams)).data;
+}));
+export const uploadShopperExperience = createAsyncThunk('SearchResults/uploadShopperExperience', ({ optionName, field, value, mode }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.changeSetup({ field, value }));
+}));
+export const uploadConfiguration = createAsyncThunk('SearchResults/uploadConfiguration', ({ field, value, isContent, optionName }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.changeSetup({ field, value }));
+}));
+export const uploadCustomCSS = createAsyncThunk('SearchResults/uploadCustomCSS', ({ value }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.changeSetup({ field: "extension_custom_serp_css", value }));
+}));
+export const uploadSiteMapURL = createAsyncThunk('SearchResults/uploadSiteMapURL', ({ url }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.setSiteMapURL(url));
+}));
+export const getInaccessibleSiteMapUrls = createAsyncThunk('SearchResults/getInaccessibleSiteMapUrls', () => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.getInaccessibleSiteMapUrls()).data;
+}));
+export const saveTransliterationLanguage = createAsyncThunk('SearchResults/saveTransliterationLanguage', ({ isAllow, language, isAllowOld, oldLanguage: string }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.saveTransliterationLanguage(isAllow, language));
+}));
+export const saveAdvancedConfigSwitchValue = createAsyncThunk('SearchResults/saveAdvancedConfigSwitchValue', ({ switchId, switchName, value, oldValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.saveAdvancedConfigSwitchValue(switchId, value));
+}));
+export const setExcludeFromIndexingTags = createAsyncThunk('SearchResults/setExcludeFromIndexingTags', (tags) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.setExcludeTagsFromIndexing(tags));
+}));
+export const saveRankingSources = createAsyncThunk('SearchResults/saveRankingSources', ({ isManualRanking, sourceName, importance, isCustomAttrSource, isManualRankingOld, importanceOld, data }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.saveRankingSources(data));
+}));
+export const saveSearchRankingImportance = createAsyncThunk('SearchResults/saveSearchRankingImportance', (data) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.saveSearchRankingImportance(data));
+}));
+export const changeSiteBadge = createAsyncThunk('SearchResults/changeSiteBadge', ({ operation, tag, imageUrl, index }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.changeSiteBadge(operation, tag, imageUrl, index));
+}));
+export const changeSiteTextBadge = createAsyncThunk('SearchResults/changeSiteTextBadge', ({ operation, tag, badgeText, badgeStyle, index }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.changeSiteTextBadge(operation, tag, badgeText, badgeStyle, index));
+}));
+export const setIsInventoryLevelBadgeEnabled = createAsyncThunk('SearchResults/setIsInventoryLevelBadgeEnabled', (isEnabled) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.setIsInventoryLevelBadgeEnabled(isEnabled));
+}));
+export const setInventoryLevelBadgeMin = createAsyncThunk('SearchResults/setInventoryLevelBadgeMin', ({ min, minOld }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.setInventoryLevelBadgeMin(min));
+}));
+export const setPersonalizedSearch = createAsyncThunk('searchResults/setPersonalizedSearch', ({ value }) => {
+    return (SearchResults.setPersonalizedSearch(value));
+});
+export const setPersonalizationOverMerchandisingSearch = createAsyncThunk('searchResults/setPersonalizationOverMerchandisingSearch', ({ value }) => {
+    return (SearchResults.setPersonalizationOverMerchandisingSearch(value));
+});
+export const setNonSellableProducts = createAsyncThunk('searchResults/setNonSellableProducts', ({ isShow, isDemote, isShowOld, isDemoteOld }) => {
+    return SearchResults.setNonSellableProducts(isShow, isDemote);
+});
+export const fetchSwatches = createAsyncThunk('SearchResults/fetchSwatches', () => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.getSwatches()).data;
+}));
+export const setSwatches = createAsyncThunk('SearchResults/setSwatches', (swatches) => __awaiter(void 0, void 0, void 0, function* () {
+    const swatchesToSave = swatches.filter(s => !s.default);
+    return (yield SearchResults.setSwatches(swatchesToSave)).data;
+}));
+export const pushSwatchesConfigurationToSites = createAsyncThunk('searchResults/pushSwatchesConfigurationToSites', ({ sites }) => __awaiter(void 0, void 0, void 0, function* () {
+    return (yield SearchResults.pushSwatchesConfigurationToSites(sites)).data;
+}));
+export const searchResultsSlice = createSlice({
+    name: 'SearchResults',
+    initialState,
+    reducers: {
+        setCustomCSS: (state, action) => {
+            state.customCSS.value = action.payload;
+        },
+        setEditedCSS: (state, action) => {
+            state.editedCSS = action.payload;
+        },
+        setCustomSiteMapURL: ((state, action) => {
+            state.configuration.contentSearch.siteMapURL = action.payload;
+        }),
+        setSerpDevice: ((state, action) => {
+            state.mode = action.payload;
+        }),
+        clearReviewCredentials: (state) => {
+            state.reviews.credentials.valid = false;
+            state.reviews.credentials.testStatus = "";
+        },
+        onTestReviewPending: (state, action) => {
+            state.reviews.credentials = action.payload;
+        },
+        onTestReviewRejected: (state) => {
+            state.reviews.credentials.valid = false;
+            state.reviews.credentials.testStatus = "error";
+        },
+        onTestReviewFulfilled: (state) => {
+            state.reviews.credentials.valid = true;
+            state.reviews.credentials.testStatus = "success";
+        },
+        setBadgesMessage: (state, action) => {
+            state.badgesPage.badgesSection.message = action.payload;
+        },
+        setBadgesIsEditError: (state, action) => {
+            state.badgesPage.badgesSection.isEditError = action.payload;
+        },
+        fixDefaultSorting: (state, action) => {
+            const { desktop, mobile, tablet } = state.shopperExperience.defaultSortingOption;
+            state.shopperExperience.defaultSortingOption = {
+                desktop: action.payload === desktop ? 0 : desktop,
+                mobile: action.payload === mobile ? 0 : mobile,
+                tablet: action.payload === tablet ? 0 : tablet,
+            };
+        },
+        setContentSearchErrorMessage: (state, action) => {
+            state.configuration.contentSearch.errorMessage = action.payload;
+        },
+        setUnmappedColor: (state, action) => {
+            state.unmappedColor = action.payload;
+        },
+        setSwatches: (state, action) => {
+            state.swatches = action.payload;
+        },
+        setIsPersonalizationAddonEnabled(state, action) {
+            state.retailPack.isPersonalizationAddonEnabled = action.payload;
+        },
+        setColorFamiliesIsFetch(state, action) {
+            state.retailPack.colorFamilies.isFetch = action.payload;
+        }
+    },
+    extraReducers: builder => {
+        builder.addCase(resetState, () => initialState);
+        builder.addCase(fetchSearchResults.fulfilled, (state, action) => {
+            var _a, _b;
+            state.shopperExperience = action.payload.shopperExperience;
+            state.customCSS.value = action.payload.customCSS.value;
+            state.configuration = action.payload.configuration;
+            state.advancedConfig = action.payload.advancedConfig;
+            state.advancedConfig.excludeTagsFromIndexing.tags = action.payload.advancedConfig.excludeTagsFromIndexing.tags;
+            state.badgesPage = action.payload.badgesPage;
+            (_a = state.badgesPage.badgesSection.badges) === null || _a === void 0 ? void 0 : _a.forEach(badge => badge.type = 'Image');
+            (_b = state.badgesPage.badgesSection.textBadges) === null || _b === void 0 ? void 0 : _b.forEach(badge => badge.type = 'Text');
+            state.reviews.isActive = action.payload.reviews.isActive;
+            state.reviews.provider = action.payload.reviews.provider;
+            state.retailPack = Object.assign(Object.assign({}, action.payload.retailPack), { colorFamilies: Object.assign(Object.assign({}, state.retailPack.colorFamilies), action.payload.retailPack.colorFamilies) });
+            state.isLoading = false;
+            state.timeStamp = Math.round(Date.now() / 1000);
+        });
+        builder.addCase(uploadCustomCSS.pending, (state, action) => {
+            state.customCSS.loading = true;
+        });
+        builder.addCase(uploadCustomCSS.rejected, (state, action) => {
+            state.customCSS.loading = false;
+            state.customCSS.uploadFailed = true;
+        });
+        builder.addCase(uploadCustomCSS.fulfilled, (state, action) => {
+            state.customCSS.loading = false;
+            state.editedCSS = action.meta.arg.value;
+        });
+        builder.addCase(uploadShopperExperience.pending, (state, action) => {
+            const { optionName, mode, value } = action.meta.arg;
+            switch (optionName) {
+                case "productTitleLines":
+                    state.shopperExperience.productTitleLines[mode] = value;
+                    break;
+                case "productsPerRow":
+                    state.shopperExperience.productsPerRow[mode] = value;
+                    break;
+                case "pageSystem":
+                    state.shopperExperience.pageSystem[mode] = value;
+                    break;
+                case "isLoadMoreButton":
+                    state.shopperExperience.isLoadMoreButton[mode] = value;
+                    break;
+                case "filterTheme":
+                    state.shopperExperience.filterTheme = value;
+                    break;
+                case "isSortingSerp":
+                    state.shopperExperience.isSortingSerp[mode] = value;
+                    break;
+                case "defaultSortingOption":
+                    state.shopperExperience.defaultSortingOption[mode] = parseInt(value);
+                    break;
+                case "isQuickView":
+                    state.shopperExperience.isQuickView[mode] = value;
+                    break;
+                case "isInStockBanner":
+                    state.shopperExperience.isInStockBanner[mode] = value;
+                    break;
+                case "isSoldOutBanner":
+                    state.shopperExperience.isSoldOutBanner[mode] = value;
+                    break;
+                case "isAddToCartButton":
+                    state.shopperExperience.isAddToCartButton[mode] = value;
+                    break;
+                case "isAjaxAnimation":
+                    state.shopperExperience.isAjaxAnimation[mode] = value;
+                    break;
+                case "isProductSku":
+                    state.shopperExperience.isProductSku[mode] = value;
+                    break;
+                case "isProductDescription":
+                    state.shopperExperience.isProductDescription[mode] = value;
+                    break;
+                case "isSearchBox":
+                    state.shopperExperience.isSearchBox[mode] = value;
+                    break;
+                case "isPriceFilterSlider":
+                    state.shopperExperience.isPriceFilterSlider = value;
+                    break;
+                case "addToCartButtonColor":
+                    state.shopperExperience.addToCartButtonColor = value;
+                    break;
+                case "filterTitleColor":
+                    state.shopperExperience.filterTitleColor = value;
+                    break;
+                case "filterOptionColor":
+                    state.shopperExperience.filterOptionColor = value;
+                    break;
+                case "productPriceColor":
+                    state.shopperExperience.productPriceColor = value;
+                    break;
+                case "productComparePriceColor":
+                    state.shopperExperience.productComparePriceColor = value;
+                    break;
+                case "productBorderColor":
+                    state.shopperExperience.productBorderColor = value;
+                    break;
+                case "productInfoAlignment":
+                    state.shopperExperience.productInfoAlignment = value;
+                    break;
+                case "quickViewTheme":
+                    state.shopperExperience.quickViewTheme = value;
+                    break;
+                case "quickViewColorScheme":
+                    state.shopperExperience.quickViewColorScheme = value;
+                    break;
+                case "isAddToCartVariants":
+                    state.shopperExperience.isAddToCartVariants[mode] = value;
+                    break;
+                case "sliderDirection":
+                    state.shopperExperience.sliderDirection = value;
+                    break;
+                case "isModernSlidebarFilters":
+                    state.shopperExperience.isModernSlidebarFilters = value;
+                    break;
+                case "showFiltersHiddenButton":
+                    state.shopperExperience.showFiltersHiddenButton = value;
+                    break;
+                case "isPaginationProgressBar":
+                    state.shopperExperience.isPaginationProgressBar = value;
+                    break;
+            }
+        });
+        builder.addCase(uploadConfiguration.pending, (state, action) => {
+            const { value, isContent, optionName } = action.meta.arg;
+            if (isContent) {
+                state.configuration.contentSearch = Object.assign(Object.assign({}, state.configuration.contentSearch), { [optionName]: value });
+            }
+            else {
+                state.configuration = Object.assign(Object.assign({}, state.configuration), { [optionName]: value });
+            }
+        });
+        builder.addCase(uploadSiteMapURL.pending, (state, action) => {
+            state.configuration.contentSearch.status = "loading";
+            state.configuration.contentSearch.siteMapURL = action.meta.arg.url;
+            state.configuration.contentSearch.errorMessage = '';
+        });
+        builder.addCase(uploadSiteMapURL.rejected, (state, action) => {
+            state.configuration.contentSearch.status = "rejected";
+            state.configuration.contentSearch.siteMapURL = "";
+        });
+        builder.addCase(uploadSiteMapURL.fulfilled, (state, action) => {
+            const isSuccess = action.payload.data.success;
+            const inaccessibleUrls = action.payload.data.inaccessibleUrls;
+            let status = '';
+            if (isSuccess) {
+                status = "fulfilled";
+            }
+            else {
+                status = "rejected";
+                state.configuration.contentSearch.siteMapURL = "";
+            }
+            state.configuration.contentSearch.status = status;
+            state.configuration.contentSearch.inaccessibleSiteMapUrls = inaccessibleUrls;
+            state.configuration.contentSearch.errorMessage = getErrorMessage(inaccessibleUrls, status);
+        });
+        builder.addCase(uploadProductsSplit.pending, (state, action) => {
+            state.retailPack.productsSplit = action.meta.arg.value;
+        });
+        builder.addCase(uploadProductsSplit.rejected, (state, action) => {
+            state.retailPack.productsSplit = action.meta.arg.oldValue;
+        });
+        builder.addCase(getInaccessibleSiteMapUrls.fulfilled, (state, action) => {
+            if (action.payload.success) {
+                const urls = action.payload.urls;
+                state.configuration.contentSearch.inaccessibleSiteMapUrls = urls;
+                state.configuration.contentSearch.errorMessage = getErrorMessage(urls);
+            }
+        });
+        builder.addCase(saveTransliterationLanguage.pending, (state, action) => {
+            state.advancedConfig.isAllowTransliteration = action.meta.arg.isAllow;
+            state.advancedConfig.transliterationLanguage = action.meta.arg.language;
+        });
+        builder.addCase(saveTransliterationLanguage.rejected, (state, action) => {
+            state.advancedConfig.isAllowTransliteration = action.meta.arg.isAllowOld;
+            state.advancedConfig.transliterationLanguage = action.meta.arg.oldLanguage;
+        });
+        builder.addCase(saveRankingSources.pending, (state, action) => {
+            updateRankingSources(state, action, false);
+        });
+        builder.addCase(saveRankingSources.rejected, (state, action) => {
+            updateRankingSources(state, action, true);
+        });
+        builder.addCase(saveAdvancedConfigSwitchValue.pending, (state, action) => {
+            const switchName = action.meta.arg.switchName;
+            const value = action.meta.arg.value;
+            state.advancedConfig = Object.assign(Object.assign({}, state.advancedConfig), { [switchName]: value });
+        });
+        builder.addCase(saveAdvancedConfigSwitchValue.rejected, (state, action) => {
+            const switchName = action.meta.arg.switchName;
+            const oldValue = action.meta.arg.oldValue;
+            state.advancedConfig = Object.assign(Object.assign({}, state.advancedConfig), { [switchName]: oldValue });
+        });
+        builder.addCase(setExcludeFromIndexingTags.pending, (state, action) => {
+            state.advancedConfig.excludeTagsFromIndexing.isLoading = true;
+        });
+        builder.addCase(setExcludeFromIndexingTags.fulfilled, (state, action) => {
+            state.advancedConfig.excludeTagsFromIndexing.isLoading = false;
+            state.advancedConfig.excludeTagsFromIndexing.tags = action.meta.arg;
+        });
+        builder.addCase(saveRankingSources.fulfilled, (state, action) => {
+            const success = action.payload.success;
+            if (!success) {
+                const switchName = action.meta.arg.switchName;
+                const oldValue = action.meta.arg.oldValue;
+                state.advancedConfig = Object.assign(Object.assign({}, state.advancedConfig), { [switchName]: oldValue });
+            }
+        });
+        builder.addCase(changeSiteBadge.pending, (state, action) => {
+            state.badgesPage.badgesSection.isSaving = true;
+            state.badgesPage.badgesSection.message = '';
+        });
+        builder.addCase(changeSiteTextBadge.pending, (state, action) => {
+            state.badgesPage.badgesSection.isSaving = true;
+            state.badgesPage.badgesSection.message = '';
+        });
+        builder.addCase(changeSiteBadge.rejected, (state, action) => {
+            state.badgesPage.badgesSection.isSaving = false;
+        });
+        builder.addCase(changeSiteTextBadge.rejected, (state, action) => {
+            state.badgesPage.badgesSection.isSaving = false;
+        });
+        builder.addCase(changeSiteBadge.fulfilled, (state, action) => {
+            state.badgesPage.badgesSection.isSaving = false;
+            const success = action.payload.data.success;
+            const result = action.payload.data.result;
+            if (success) {
+                const index = action.meta.arg.index;
+                const badge = state.badgesPage.badgesSection.badges[index];
+                if (action.meta.arg.operation === 'add') {
+                    const badge = {
+                        tag: action.meta.arg.tag,
+                        imageUrl: action.meta.arg.imageUrl,
+                        imageServingUrl: action.meta.arg.imageUrl,
+                        type: "Image"
+                    };
+                    state.badgesPage.badgesSection.badges.push(badge);
+                }
+                else if (action.meta.arg.operation === 'edit') {
+                    if (typeof result.imageUrl !== 'undefined' && result.imageUrl !== null) {
+                        badge.imageUrl = result.imageUrl;
+                    }
+                    if (typeof result.imageServingUrl !== 'undefined' && result.imageServingUrl !== null) {
+                        badge.imageServingUrl = result.imageServingUrl;
+                    }
+                    badge.tag = action.meta.arg.tag;
+                }
+                else {
+                    //delete a badge
+                    state.badgesPage.badgesSection.badges.splice(index, 1);
+                }
+            }
+            else {
+                state.badgesPage.badgesSection.isEditError = true;
+                if (result && result.message) {
+                    state.badgesPage.badgesSection.message = result.message;
+                }
+                else {
+                    state.badgesPage.badgesSection.message = 'An error has occurred, please try again';
+                }
+                if (result && result.message && action.meta.arg.operation === 'edit') {
+                    state.badgesPage.badgesSection.isEditError = true;
+                }
+            }
+        });
+        builder.addCase(changeSiteTextBadge.fulfilled, (state, action) => {
+            state.badgesPage.badgesSection.isSaving = false;
+            const success = action.payload.data.success;
+            const result = action.payload.data.result;
+            if (success) {
+                const index = action.meta.arg.index;
+                const badge = state.badgesPage.badgesSection.textBadges[index];
+                if (action.meta.arg.operation === 'add') {
+                    const badge = {
+                        tag: action.meta.arg.tag,
+                        badgeText: action.meta.arg.badgeText,
+                        badgeStyle: action.meta.arg.badgeStyle,
+                        type: "Text"
+                    };
+                    state.badgesPage.badgesSection.textBadges.push(badge);
+                }
+                else if (action.meta.arg.operation === 'edit') {
+                    badge.badgeStyle = action.meta.arg.badgeStyle;
+                    badge.tag = action.meta.arg.tag;
+                    badge.badgeText = action.meta.arg.badgeText;
+                }
+                else {
+                    state.badgesPage.badgesSection.textBadges.splice(index, 1);
+                }
+            }
+            else {
+                if (result && result.message) {
+                    state.badgesPage.badgesSection.message = result.message;
+                }
+                else {
+                    state.badgesPage.badgesSection.message = 'An error has occurred, please try again';
+                }
+                if (result && result.message && action.meta.arg.operation === 'edit') {
+                    state.badgesPage.badgesSection.isEditError = true;
+                }
+            }
+        });
+        builder.addCase(testCredentials.pending, (state, action) => {
+            state.reviews.credentials = action.meta.arg.credentials;
+        });
+        builder.addCase(testCredentials.fulfilled, (state, action) => {
+            state.reviews.credentials.valid = true;
+            state.reviews.credentials.testStatus = "success";
+        });
+        builder.addCase(testCredentials.rejected, (state, action) => {
+            state.reviews.credentials.valid = false;
+            state.reviews.credentials.testStatus = "error";
+        });
+        builder.addCase(setReviewProvider.pending, (state, action) => {
+            if (action.meta.arg.credentials) {
+                state.reviews.credentials = action.meta.arg.credentials;
+            }
+            state.reviews.provider = action.meta.arg.newProvider;
+            state.reviews.isFetch = true;
+        });
+        builder.addCase(setReviewProvider.rejected, (state, action) => {
+            alert("Provider Failed to update");
+            state.reviews.provider = action.meta.arg.newProvider;
+            state.reviews.isFetch = false;
+        });
+        builder.addCase(toggleReviewProvider.pending, (state, action) => {
+            state.reviews.isActive = action.meta.arg.value;
+        });
+        builder.addCase(fetchColorFamily.fulfilled, (state, action) => {
+            state.retailPack.colorFamilies.siteColorFamilies = action.payload.siteColorFamilies;
+            state.loading.colorFamily = false;
+        });
+        builder.addCase(fetchColorMapping.fulfilled, (state, action) => {
+            state.retailPack.colorFamilies.siteColorMapping = action.payload.siteColorMapping;
+            state.loading.colorMapping = false;
+        });
+        builder.addCase(uploadRetailPack.pending, (state, action) => {
+            const { optionName, value } = action.meta.arg;
+            state.retailPack[optionName] = value;
+        });
+        builder.addCase(updateColorFamily.pending, (state, action) => {
+            const { family, color } = action.meta.arg;
+            const index = state.retailPack.colorFamilies.siteColorFamilies.findIndex(f => f.name === family);
+            if (index !== -1) {
+                state.retailPack.colorFamilies.siteColorFamilies[index].color = color;
+            }
+            else {
+                state.retailPack.colorFamilies.siteColorFamilies.push({
+                    name: family,
+                    color: color,
+                    overridden: false
+                });
+            }
+        });
+        builder.addCase(deleteColorFamily.pending, (state, action) => {
+            const { family } = action.meta.arg;
+            state.retailPack.colorFamilies.siteColorFamilies = state.retailPack.colorFamilies.siteColorFamilies.filter(f => f.name !== family);
+        });
+        builder.addCase(updateColorMapping.pending, (state, action) => {
+            const { update, color } = action.meta.arg;
+            if (color in state.retailPack.colorFamilies.siteColorMapping) {
+                state.retailPack.colorFamilies.siteColorMapping[color] = update;
+            }
+        });
+        builder.addCase(toggleColorFamilySwitch.pending, (state, action) => {
+            const { value } = action.meta.arg;
+            state.retailPack.colorFamilies.isActive = value;
+            state.retailPack.colorFamilies.isFetch = true;
+        });
+        builder.addCase(fetchPreviewURL.fulfilled, (state, action) => {
+            let { url, available, reason } = action.payload;
+            if (url.includes("{proxy_endpoint}")) {
+                url = url.replace("{proxy_endpoint}", API_BASE_URL);
+            }
+            if (reason) {
+                console.error(`site preview failed to load, reason: ${reason}`);
+            }
+            state.previewState = {
+                url: url || "error",
+                isAvailable: available,
+                reason: reason
+            };
+        });
+        builder.addCase(setIsInventoryLevelBadgeEnabled.pending, (state, action) => {
+            state.badgesPage.inventoryLevel.isBadgeEnabled = action.meta.arg;
+        });
+        builder.addCase(setIsInventoryLevelBadgeEnabled.rejected, (state, action) => {
+            const isEnabled = action.meta.arg;
+            state.badgesPage.inventoryLevel.isBadgeEnabled = !isEnabled;
+        });
+        builder.addCase(setIsInventoryLevelBadgeEnabled.fulfilled, (state, action) => {
+            const success = action.payload.data.success;
+            if (!success) {
+                const isEnabled = action.meta.arg;
+                state.badgesPage.inventoryLevel.isBadgeEnabled = !isEnabled;
+            }
+        });
+        builder.addCase(setInventoryLevelBadgeMin.pending, (state, action) => {
+            const min = action.meta.arg.min;
+            state.badgesPage.inventoryLevel.badgeMin = min;
+        });
+        builder.addCase(setInventoryLevelBadgeMin.rejected, (state, action) => {
+            state.badgesPage.inventoryLevel.badgeMin = action.meta.arg.minOld;
+        });
+        builder.addCase(setInventoryLevelBadgeMin.fulfilled, (state, action) => {
+            const success = action.payload.data.success;
+            if (!success) {
+                state.badgesPage.inventoryLevel.badgeMin = action.meta.arg.minOld;
+            }
+        });
+        builder.addCase(updateVisualTags.pending, (state, action) => {
+            state.retailPack.isVisualTags = action.meta.arg.value;
+        });
+        builder.addCase(uploadImageHoverMode.pending, (state, action) => {
+            state.retailPack.imageHoverMode = action.meta.arg.mode;
+        });
+        builder.addCase(setNonSellableProducts.pending, (state, action) => {
+            const isShow = action.meta.arg.isShow;
+            const isDemote = action.meta.arg.isDemote;
+            state.advancedConfig.nonSellableProducts.isShow = isShow;
+            state.advancedConfig.nonSellableProducts.isDemote = isDemote;
+        });
+        builder.addCase(setNonSellableProducts.rejected, (state, action) => {
+            const isShowOld = action.meta.arg.isShowOld;
+            const isDemoteOld = action.meta.arg.isDemoteOld;
+            state.advancedConfig.nonSellableProducts.isShow = isShowOld;
+            state.advancedConfig.nonSellableProducts.isDemote = isDemoteOld;
+        });
+        builder.addCase(setNonSellableProducts.fulfilled, (state, action) => {
+            const success = action.payload.data.success;
+            if (!success) {
+                const isShowOld = action.meta.arg.isShowOld;
+                const isDemoteOld = action.meta.arg.isDemoteOld;
+                state.advancedConfig.nonSellableProducts.isShow = isShowOld;
+                state.advancedConfig.nonSellableProducts.isDemote = isDemoteOld;
+            }
+        });
+        builder.addCase(fetchSwatches.fulfilled, ((state, action) => {
+            state.options = action.payload.options;
+            state.swatches = action.payload.swatches;
+            state.isSwatchesLoading = false;
+        }));
+        builder.addCase(setSwatches.pending, ((state, action) => {
+            state.swatches = action.meta.arg;
+        }));
+        builder.addCase(saveSearchRankingImportance.pending, ((state, action) => {
+            state.advancedConfig.searchCustomRanking = action.meta.arg;
+            state.advancedConfig.hasCustomSort = true;
+        }));
+        builder.addCase(pushSwatchesConfigurationToSites.pending, (state) => {
+            state.loading.pushToSites = true;
+        });
+        builder.addCase(pushSwatchesConfigurationToSites.fulfilled, (state) => {
+            state.loading.pushToSites = false;
+        });
+        builder.addCase(pushSwatchesConfigurationToSites.rejected, (state) => {
+            state.loading.pushToSites = false;
+        });
+    },
+});
+const updateRankingSources = (state, action, isRestoreOld) => {
+    const { isCustomAttrSource, sourceName, importance, importanceOld, isManualRanking, isManualRankingOld } = action.meta.arg;
+    if (isManualRanking !== isManualRankingOld) {
+        state.advancedConfig.rankingImportance.isManualRanking =
+            isRestoreOld ? isManualRankingOld : isManualRanking;
+    }
+    else {
+        if (sourceName === '' || importance === 0) {
+            return;
+        }
+        if (isCustomAttrSource) {
+            const source = state.advancedConfig.serpCustomAttrArr.find((s) => s.name === sourceName);
+            if (source) {
+                source.importance = isRestoreOld ? importanceOld : importance;
+            }
+        }
+        else {
+            const source = state.advancedConfig.rankingImportance.rankingSources.find((s) => s.name === sourceName);
+            if (source) {
+                source.importance = isRestoreOld ? importanceOld : importance;
+            }
+        }
+    }
+};
+export const selectShopperExperience = (state) => state.searchResults.shopperExperience;
+export const selectSerpConfiguration = (state) => state.searchResults.configuration;
+export const selectSerpReviews = (state) => state.searchResults.reviews;
+export const selectSerpAdvancedConfig = (state) => state.searchResults.advancedConfig;
+export const selectSerpBadgesSection = (state) => state.searchResults.badgesPage.badgesSection;
+export const selectSerpInventoryLevel = (state) => state.searchResults.badgesPage.inventoryLevel;
+export const selectIsLoading = (state) => state.searchResults.isLoading;
+export const selectCustomCSS = (state) => state.searchResults.customCSS;
+export const selectEditedCSS = (state) => state.searchResults.editedCSS;
+export const selectSerpMode = (state) => state.searchResults.mode;
+export const selectSerpLatestUpdate = (state) => state.searchResults.timeStamp;
+export const selectNonSellableProducts = (state) => state.searchResults.advancedConfig.nonSellableProducts;
+export const selectRetailPackData = (state) => state.searchResults.retailPack;
+export const selectIsLookALike = (state) => state.searchResults.retailPack.isLookALike;
+export const selectPreviewData = (state) => state.searchResults.previewState;
+export const selectSwatches = (state) => state.searchResults.swatches;
+export const selectOptions = (state) => state.searchResults.options;
+export const selectIsSwatchesLoading = (state) => state.searchResults.isSwatchesLoading;
+export const selectUnmappedColor = (state) => state.searchResults.unmappedColor;
+export const selectLoading = (state) => state.searchResults.loading;
+export const selectSwatchesConfigurationPushToSites = (state) => state.searchResults.loading.pushToSites;
+export const setBadgesMessage = searchResultsSlice.actions.setBadgesMessage;
+export const setBadgesIsEditError = searchResultsSlice.actions.setBadgesIsEditError;
+export const setContentSearchErrorMessage = searchResultsSlice.actions.setContentSearchErrorMessage;
+export const setUnmappedColor = searchResultsSlice.actions.setUnmappedColor;
+export const setSwatchesReducer = searchResultsSlice.actions.setSwatches;
+export const setEditedCSS = searchResultsSlice.actions.setEditedCSS;
+export const setIsPersonalizationAddonEnabled = searchResultsSlice.actions.setIsPersonalizationAddonEnabled;
+export const setColorFamiliesIsFetch = searchResultsSlice.actions.setColorFamiliesIsFetch;
+export default searchResultsSlice.reducer;
+//# sourceMappingURL=searchResultsSlice.js.map