@sonic-equipment/ui 0.0.119 → 120.0.0

package/dist/shared/api/storefront/hooks/website/use-fetch-settings.js

@@ -0,0 +1,18 @@
+import { useQuery } from '@tanstack/react-query';
+import { TIME } from '../../../../utils/time.js';
+import { fetchSettings } from '../../services/website-service.js';
+
+function useFetchSettings({ enabled = true, } = {}) {
+    return useQuery({
+        enabled,
+        gcTime: TIME.DAY,
+        queryFn: async () => {
+            return await fetchSettings();
+        },
+        queryKey: ['settings'],
+        retry: 3,
+        staleTime: TIME.DAY,
+    });
+}
+
+export { useFetchSettings };

package/dist/shared/api/storefront/hooks/website/use-update-locale.js

@@ -0,0 +1,11 @@
+import { useMutation } from '@tanstack/react-query';
+import { updateLocale } from '../../services/website-service.js';
+
+function useUpdateLocale() {
+    return useMutation({
+        mutationFn: updateLocale,
+        throwOnError: true,
+    });
+}
+
+export { useUpdateLocale };

package/dist/shared/api/storefront/hooks/wishlist/use-add-wishlist-item-to-current-wishlist.js

@@ -0,0 +1,34 @@
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { createWishList, addWishListItemToWishList } from '../../services/wishlist-service.js';
+
+function useAddWishListItemToCurrentWishList() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ productId }) => {
+            const wishLists = queryClient.getQueryData(['wishlists']) || [];
+            let wishList = wishLists[0];
+            if (!wishList) {
+                wishList = await createWishList();
+                queryClient.setQueryData(['wishlists'], [...wishLists, wishList]);
+            }
+            const wishListItem = await addWishListItemToWishList({
+                productId,
+                wishListId: wishList.id,
+            });
+            const wishListLines = queryClient.getQueryData(['wishlistlines']) || [];
+            queryClient.setQueryData(['wishlistlines'], [
+                ...wishListLines,
+                {
+                    wishList,
+                    wishListItem,
+                },
+            ]);
+        },
+        onError() {
+            queryClient.removeQueries({ queryKey: ['wishlists'] });
+            queryClient.removeQueries({ queryKey: ['wishlistlines'] });
+        },
+    });
+}
+
+export { useAddWishListItemToCurrentWishList };

package/dist/shared/api/storefront/hooks/wishlist/use-add-wishlist-item-to-wishlist.js

@@ -0,0 +1,33 @@
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { getWishLists, addWishListItemToWishList } from '../../services/wishlist-service.js';
+
+/* eslint-disable unicorn/no-await-expression-member */
+function useAddWishListItemToWishList() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ productId, wishListId }) => {
+            let wishLists = queryClient.getQueryData(['wishlists']);
+            if (!wishLists) {
+                wishLists = (await getWishLists()).wishListCollection || [];
+                queryClient.setQueryData(['wishlists'], wishLists);
+            }
+            const wishList = wishLists.find(wishList => wishList.id === wishListId);
+            if (!wishList)
+                throw new Error(`Wish list with id ${wishListId} not found`);
+            const wishListItem = await addWishListItemToWishList({
+                productId,
+                wishListId,
+            });
+            const wishListLines = queryClient.getQueryData(['wishlistlines']) || [];
+            queryClient.setQueryData(['wishlistlines'], [
+                ...wishListLines,
+                {
+                    wishList,
+                    wishListItem,
+                },
+            ]);
+        },
+    });
+}
+
+export { useAddWishListItemToWishList };

package/dist/shared/api/storefront/hooks/wishlist/use-create-wishlist.js

@@ -0,0 +1,17 @@
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { createWishList } from '../../services/wishlist-service.js';
+
+function useCreateWishList() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ name }) => {
+            const createdWishList = await createWishList({ name });
+            // Add to cache
+            const wishLists = queryClient.getQueryData(['wishlists']) || [];
+            queryClient.setQueryData(['wishlists'], [...wishLists, createdWishList]);
+            return createdWishList.id;
+        },
+    });
+}
+
+export { useCreateWishList };

package/dist/shared/api/storefront/hooks/wishlist/use-delete-wishlist-item-from-wishlist.js

@@ -0,0 +1,21 @@
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { deleteWishListItemFromWishList } from '../../services/wishlist-service.js';
+
+function useDeleteWishListItemFromWishList() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ wishListId, wishListItemId }) => {
+            await deleteWishListItemFromWishList({ wishListId, wishListItemId });
+            const wishListLines = queryClient.getQueryData(['wishlistlines']) || [];
+            if (wishListLines.some(item => item.wishListItem.id === wishListItemId)) {
+                queryClient.setQueryData(['wishlistlines'], wishListLines.filter(line => line.wishListItem.id !== wishListItemId));
+            }
+        },
+        onError() {
+            queryClient.removeQueries({ queryKey: ['wishlists'] });
+            queryClient.removeQueries({ queryKey: ['wishlistlines'] });
+        },
+    });
+}
+
+export { useDeleteWishListItemFromWishList };

package/dist/shared/api/storefront/hooks/wishlist/use-fetch-all-wishlists-items.js

@@ -0,0 +1,36 @@
+import { useQueryClient, useQuery } from '@tanstack/react-query';
+import { TIME } from '../../../../utils/time.js';
+import { getWishLists, getWishListItemsByWishListId } from '../../services/wishlist-service.js';
+
+/* eslint-disable unicorn/no-await-expression-member */
+function useFetchAllWishListsItems({ enabled = true } = { enabled: true }) {
+    const queryClient = useQueryClient();
+    return useQuery({
+        enabled,
+        gcTime: 15 * TIME.MINUTE,
+        queryFn: async () => {
+            let wishLists = 
+            // Reuse existing data if available
+            queryClient.getQueryData(['wishlists']);
+            if (wishLists === undefined) {
+                wishLists = (await getWishLists()).wishListCollection || [];
+                // Update the cache with the new or existing data
+                queryClient.setQueryData(['wishlists'], wishLists);
+            }
+            if (wishLists.length === 0)
+                return [];
+            const wishListLines = await Promise.all(wishLists.map(async (wishList) => {
+                return ((await getWishListItemsByWishListId({ wishListId: wishList.id }))
+                    .wishListLines || []).map(wishListItem => ({
+                    wishList,
+                    wishListItem,
+                }));
+            }));
+            return wishListLines.flat();
+        },
+        queryKey: ['wishlistlines'],
+        staleTime: 15 * TIME.MINUTE,
+    });
+}
+
+export { useFetchAllWishListsItems };

package/dist/shared/api/storefront/hooks/wishlist/use-fetch-wishlists.js

@@ -0,0 +1,14 @@
+import { useQuery } from '@tanstack/react-query';
+import { TIME } from '../../../../utils/time.js';
+import { getWishLists } from '../../services/wishlist-service.js';
+
+function useFetchWishLists() {
+    return useQuery({
+        gcTime: 15 * TIME.MINUTE,
+        queryFn: getWishLists,
+        queryKey: ['wishlists'],
+        staleTime: 15 * TIME.MINUTE,
+    });
+}
+
+export { useFetchWishLists };

package/dist/shared/api/storefront/model/shop.model.js

@@ -0,0 +1,42 @@
+var CurrencyPositioningType;
+(function (CurrencyPositioningType) {
+    CurrencyPositioningType["Left"] = "Left";
+    CurrencyPositioningType["Right"] = "Right";
+})(CurrencyPositioningType || (CurrencyPositioningType = {}));
+var AvailabilityMessageType;
+(function (AvailabilityMessageType) {
+    AvailabilityMessageType[AvailabilityMessageType["NoMessage"] = 0] = "NoMessage";
+    AvailabilityMessageType[AvailabilityMessageType["Available"] = 1] = "Available";
+    AvailabilityMessageType[AvailabilityMessageType["OutOfStock"] = 2] = "OutOfStock";
+    AvailabilityMessageType[AvailabilityMessageType["LowStock"] = 3] = "LowStock";
+})(AvailabilityMessageType || (AvailabilityMessageType = {}));
+var VariantDisplayTypeValues;
+(function (VariantDisplayTypeValues) {
+    VariantDisplayTypeValues["Button"] = "Button";
+    VariantDisplayTypeValues["Dropdown"] = "Dropdown";
+    VariantDisplayTypeValues["SwatchDropdown"] = "SwatchDropdown";
+    VariantDisplayTypeValues["SwatchGrid"] = "SwatchGrid";
+    VariantDisplayTypeValues["SwatchList"] = "SwatchList";
+})(VariantDisplayTypeValues || (VariantDisplayTypeValues = {}));
+var BadgeTypeValues;
+(function (BadgeTypeValues) {
+    BadgeTypeValues["Image"] = "Image";
+    BadgeTypeValues["Text"] = "Text";
+})(BadgeTypeValues || (BadgeTypeValues = {}));
+var BadgeImagePlacementValues;
+(function (BadgeImagePlacementValues) {
+    BadgeImagePlacementValues["BottomCenter"] = "Bottom Center";
+    BadgeImagePlacementValues["BottomLeft"] = "Bottom Left";
+    BadgeImagePlacementValues["BottomRight"] = "Bottom Right";
+    BadgeImagePlacementValues["None"] = "None";
+    BadgeImagePlacementValues["TopCenter"] = "Top Center";
+    BadgeImagePlacementValues["TopLeft"] = "Top Left";
+    BadgeImagePlacementValues["TopRight"] = "Top Right";
+})(BadgeImagePlacementValues || (BadgeImagePlacementValues = {}));
+var BadgeStyleValues;
+(function (BadgeStyleValues) {
+    BadgeStyleValues["Rectangle"] = "Rectangle";
+    BadgeStyleValues["Round"] = "Round";
+})(BadgeStyleValues || (BadgeStyleValues = {}));
+
+export { AvailabilityMessageType, BadgeImagePlacementValues, BadgeStyleValues, BadgeTypeValues, CurrencyPositioningType, VariantDisplayTypeValues };

package/dist/shared/api/storefront/services/authentication-service.js

@@ -0,0 +1,80 @@
+import { config } from '../../../../config.js';
+import { request } from '../../../fetch/request.js';
+
+async function fetchSession() {
+    const { body } = await request({
+        credentials: 'include',
+        url: `${config.SHOP_API_URL}/api/v1/sessions/current`,
+    });
+    return body;
+}
+async function patchSession({ session, }) {
+    const { body } = await request({
+        body: session,
+        credentials: 'include',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'PATCH',
+        url: `${config.SHOP_API_URL}/api/v1/sessions/current`,
+    });
+    return body;
+}
+async function signIn({ password, userName, }) {
+    const params = new URLSearchParams();
+    params.append('grant_type', 'password');
+    params.append('username', userName);
+    params.append('password', password);
+    params.append('scope', 'iscapi offline_access');
+    const { body } = await request({
+        body: params.toString(),
+        headers: {
+            Authorization: `Basic ${btoa('isc:009AC476-B28E-4E33-8BAE-B5F103A142BC')}`,
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        method: 'POST',
+        url: `${config.SHOP_API_URL}/identity/connect/token`,
+    });
+    return body;
+}
+async function createSession({ accessToken, password, userName, }) {
+    const { body } = await request({
+        body: {
+            isGuest: false,
+            password,
+            rememberMe: true,
+            userName,
+        },
+        headers: {
+            Accept: 'application/json, text/plain, */*',
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+        url: `${config.SHOP_API_URL}/api/v1/sessions`,
+    });
+    return body;
+}
+async function signOut() {
+    await request({
+        method: 'DELETE',
+        url: `${config.SHOP_API_URL}/api/v1/sessions/current`,
+    });
+}
+async function createGuestAccount({ defaultWarehouseId, }) {
+    const { body } = await request({
+        body: {
+            defaultFulfillmentMethod: 'Ship',
+            defaultWarehouseId,
+            isGuest: true,
+        },
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+        url: `${config.SHOP_API_URL}/api/v1/accounts`,
+    });
+    return body;
+}
+
+export { createGuestAccount, createSession, fetchSession, patchSession, signIn, signOut };

package/dist/shared/api/storefront/services/cart-service.js

@@ -0,0 +1,128 @@
+import { config } from '../../../../config.js';
+import { request } from '../../../fetch/request.js';
+
+async function fetchCurrentCart() {
+    const { body } = await request({
+        credentials: 'include',
+        url: `${config.SHOP_API_URL}/api/v1/carts/current?expand=shipping%2Cvalidation%2CcartLines%2Crestrictions%2Ccarriers%2CpaymentOptions%2CcostCodes%2Chiddenproducts%2Ctax&forceRecalculation=true&allowInvalidAddress=true`,
+    });
+    return body;
+}
+async function fetchCurrentCartPromotions() {
+    const { body } = await request({
+        credentials: 'include',
+        url: `${config.SHOP_API_URL}/api/v1/carts/current/promotions`,
+    });
+    return body.promotions || [];
+}
+async function fetchCurrentCartLines() {
+    const { body: { cartLines }, } = await request({
+        credentials: 'include',
+        url: `${config.SHOP_API_URL}/api/v1/carts/current/cartlines?page=1&pageSize=999`,
+    });
+    return cartLines;
+}
+async function updateCartLineById({ cartLine, cartLineId, }) {
+    await request({
+        body: JSON.stringify(cartLine),
+        credentials: 'include',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'PATCH',
+        url: `${config.SHOP_API_URL}/api/v1/carts/current/cartlines/${cartLineId}`,
+    });
+}
+async function patchCart({ cart }) {
+    const { body } = await request({
+        body: cart,
+        credentials: 'include',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'PATCH',
+        url: `${config.SHOP_API_URL}/api/v1/carts/current`,
+    });
+    return body;
+}
+async function deleteCurrentCart() {
+    const { body } = await request({
+        credentials: 'include',
+        method: 'DELETE',
+        url: `${config.SHOP_API_URL}/api/v1/carts/current`,
+    });
+    return body;
+}
+async function deleteCartLineById({ cartLineId, }) {
+    await request({
+        credentials: 'include',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'DELETE',
+        url: `${config.SHOP_API_URL}/api/v1/carts/current/cartlines/${cartLineId}`,
+    });
+}
+async function addProductToCurrentCart(productOrderData) {
+    const { body } = await request({
+        body: JSON.stringify(productOrderData),
+        credentials: 'include',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+        url: `${config.SHOP_API_URL}/api/v1/carts/current/cartlines`,
+    });
+    return body;
+}
+async function fetchCurrentCartProductAtp() {
+    const { body } = await request({
+        credentials: 'include',
+        method: 'GET',
+        url: `${config.SHOP_API_URL}/api/custom/atp/cart`,
+    });
+    return body.map(atp => ({
+        ...atp,
+        date: new Date(atp.date),
+    }));
+}
+async function fetchCurrentCheckoutAtp() {
+    const { body } = await request({
+        credentials: 'include',
+        method: 'GET',
+        url: `${config.SHOP_API_URL}/api/custom/atp`,
+    });
+    return body;
+}
+async function placeOrder({ cart, isPending, }) {
+    const newStatus = cart.requiresApproval
+        ? 'AwaitingApproval'
+        : isPending
+            ? 'PendingPaymentValidation'
+            : 'Submitted';
+    const { body } = await request({
+        body: { ...cart, status: newStatus },
+        credentials: 'include',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'PATCH',
+        url: `${config.SHOP_API_URL}/api/v1/carts/current`,
+    });
+    return body;
+}
+async function saveCartForLater({ cart }) {
+    // USER NEEDS TO BE LOGGED IN
+    const { body } = await request({
+        body: JSON.stringify({ ...cart, status: 'Saved' }),
+        credentials: 'include',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'PATCH',
+        url: `${config.SHOP_API_URL}/api/v1/carts/current`,
+    });
+    return body;
+}
+
+export { addProductToCurrentCart, deleteCartLineById, deleteCurrentCart, fetchCurrentCart, fetchCurrentCartLines, fetchCurrentCartProductAtp, fetchCurrentCartPromotions, fetchCurrentCheckoutAtp, patchCart, placeOrder, saveCartForLater, updateCartLineById };

package/dist/shared/api/storefront/services/translation-service.js

@@ -0,0 +1,16 @@
+import { config } from '../../../../config.js';
+import { request } from '../../../fetch/request.js';
+
+async function fetchTranslations(languageCode) {
+    const translations = {};
+    const { body } = await request({
+        credentials: 'include',
+        url: `${config.SHOP_API_URL}/api/v1/translationdictionaries?page=1&pageSize=9999&languageCode=${languageCode}`,
+    });
+    body.translationDictionaries?.forEach(dictionary => {
+        translations[dictionary.keyword] = dictionary.translation;
+    });
+    return translations;
+}
+
+export { fetchTranslations };

package/dist/shared/api/storefront/services/website-service.js

@@ -0,0 +1,83 @@
+import { config } from '../../../../config.js';
+import { isCountryCode, isLanguageCode, isCultureCode } from '../../../../intl/types.js';
+import { request } from '../../../fetch/request.js';
+
+const countryIsoCodeToLanguageIsoCode = {
+    '*': ['EN'],
+    AT: ['EN', 'DE'],
+    BE: ['EN', 'NL', 'FR'],
+    CH: ['EN', 'FR', 'DE', 'IT'],
+    DE: ['EN', 'DE'],
+    FR: ['EN', 'FR'],
+    IT: ['EN', 'IT'],
+    LU: ['EN', 'FR', 'DE'],
+    NL: ['EN', 'NL'],
+};
+async function fetchCountries() {
+    const { body } = await request({
+        url: `${config.SHOP_API_URL}/api/v1/websites/current/countries?expand=isActive`,
+    });
+    return body.countries || [];
+}
+async function fetchCountriesLanguages() {
+    const { body } = await request({
+        url: `${config.SHOP_API_URL}/api/v1/websites/current?expand=languages%2Ccountries`,
+    });
+    return {
+        countries: body.countries?.countries || [],
+        languages: body.languages?.languages || [],
+    };
+}
+async function fetchCountriesWithLanguages() {
+    const { countries, languages } = await fetchCountriesLanguages();
+    return countries.map((country) => {
+        const abbreviation = country.abbreviation.toUpperCase();
+        if (!isCountryCode(abbreviation))
+            throw new Error(`Invalid country code: ${abbreviation}`);
+        return {
+            abbreviation,
+            id: country.id,
+            languages: languages
+                .filter(language => countryIsoCodeToLanguageIsoCode[country.abbreviation]?.includes(language.languageCode) ??
+                countryIsoCodeToLanguageIsoCode['*'].includes(language.languageCode.toUpperCase()))
+                .map((language) => {
+                const languageCode = language.languageCode.toUpperCase();
+                if (!isLanguageCode(languageCode))
+                    throw new Error(`Invalid language code: ${languageCode}`);
+                if (!isCultureCode(language.cultureCode))
+                    throw new Error(`Invalid culture code: ${language.cultureCode}`);
+                return {
+                    cultureCode: language.cultureCode,
+                    description: language.description,
+                    id: language.id,
+                    languageCode,
+                };
+            }),
+            name: country.name,
+        };
+    });
+}
+async function updateLocale({ countryId, languageId, }) {
+    const { body } = await request({
+        body: JSON.stringify({
+            countryId,
+            languageId,
+        }),
+        credentials: 'include',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+        url: `${config.SHOP_API_URL}/api/v1/locale`,
+    });
+    return body;
+}
+async function fetchSettings() {
+    const { body } = await request({
+        credentials: 'include',
+        url: `${config.SHOP_API_URL}/api/v1/settings`,
+    });
+    return body.settingsCollection;
+}
+
+export { fetchCountries, fetchCountriesLanguages, fetchCountriesWithLanguages, fetchSettings, updateLocale };

package/dist/shared/api/storefront/services/wishlist-service.js

@@ -0,0 +1,72 @@
+import { config } from '../../../../config.js';
+import { request, BadRequestError } from '../../../fetch/request.js';
+
+async function getWishList({ wishListId, }) {
+    const { body } = await request({
+        url: `${config.SHOP_API_URL}/api/v1/wishlists/${wishListId}`,
+    });
+    return body;
+}
+async function getWishLists() {
+    const { body } = await request({
+        url: `${config.SHOP_API_URL}/api/v1/wishlists?page=1&pageSize=999`,
+    });
+    return body;
+}
+class WishListNameAlreadyExistsError extends Error {
+    constructor() {
+        super('List name already exists');
+        this.name = 'WishListNameAlreadyExistsError';
+    }
+}
+async function createWishList(args) {
+    try {
+        const { body } = await request({
+            body: args ? { name: args.name } : {},
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            method: 'POST',
+            url: `${config.SHOP_API_URL}/api/v1/wishlists`,
+        });
+        return body;
+    }
+    catch (error) {
+        if (error instanceof BadRequestError &&
+            error.body?.message === 'Name already exists') {
+            throw new WishListNameAlreadyExistsError();
+        }
+        throw error;
+    }
+}
+async function deleteWishList({ wishListId, }) {
+    await request({
+        method: 'DELETE',
+        url: `${config.SHOP_API_URL}/api/v1/wishlists/${wishListId}`,
+    });
+}
+async function addWishListItemToWishList({ productId, wishListId, }) {
+    const { body } = await request({
+        body: { productId, qtyOrdered: 1, unitOfMeasure: '' },
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+        url: `${config.SHOP_API_URL}/api/v1/wishlists/${wishListId}/wishlistlines`,
+    });
+    return body;
+}
+async function deleteWishListItemFromWishList({ wishListId, wishListItemId, }) {
+    await request({
+        method: 'DELETE',
+        url: `${config.SHOP_API_URL}/api/v1/wishlists/${wishListId}/wishlistlines/${wishListItemId}`,
+    });
+}
+async function getWishListItemsByWishListId({ wishListId, }) {
+    const { body } = await request({
+        url: `${config.SHOP_API_URL}/api/v1/wishlists/${wishListId}/wishlistlines?page=1&pageSize=999`,
+    });
+    return body;
+}
+
+export { WishListNameAlreadyExistsError, addWishListItemToWishList, createWishList, deleteWishList, deleteWishListItemFromWishList, getWishList, getWishListItemsByWishListId, getWishLists };

package/dist/shared/feature-flags/use-feature-flags.js

@@ -0,0 +1,45 @@
+import { useMemo } from 'react';
+import qs from 'query-string';
+
+const features = {
+    cart: 'cartV2',
+    language: 'language',
+    pdp: 'pdpV2',
+    plpv1: 'plpV1',
+    searchv1: 'searchV1',
+};
+function useFeatureFlags() {
+    const { search } = typeof window === 'undefined'
+        ? {
+            search: '',
+        }
+        : window.location;
+    return useMemo(() => {
+        const queryParams = qs.parse(search);
+        const hasQueryStringFeatures = queryParams['features'] !== undefined && queryParams['features'] !== null;
+        if (!hasQueryStringFeatures) {
+            /* When no new feature flags are set get them from localStorage */
+            return Object.entries(features).reduce((acc, [, value]) => ({
+                ...acc,
+                [value]: localStorage?.getItem(value) === 'true',
+            }), {});
+        }
+        const queryStringFeatures = String(queryParams['features'])
+            .toLowerCase()
+            .split(',');
+        const featureResults = Object.entries(features).map(([key, value]) => ({
+            key: key,
+            selected: queryStringFeatures.includes(key),
+            value: value,
+        }));
+        featureResults.forEach(({ selected, value }) => {
+            localStorage?.setItem(value, selected.toString());
+        });
+        return featureResults.reduce((acc, { selected, value }) => ({
+            ...acc,
+            [value]: selected,
+        }), {});
+    }, [search]);
+}
+
+export { useFeatureFlags };