@envive-ai/react-hooks 0.2.4 → 0.2.6-alpha

package/dist/src/atoms/chat/replies.js

@@ -0,0 +1,43 @@
+import { atom } from 'jotai';
+import { MessageType } from '@envive-ai/types';
+import { userHasRepliedAtom, messagesAtom, userQueryAtom, replyEventCategoryAtom, } from 'src/atoms/chat';
+import { UserEventCategory } from '@spiffy-ai/commerce-api-client';
+import { queueUserEventAtom } from './messageQueue';
+import { SpiffyMetricsEventName } from 'src/contexts/amplitudeContext/amplitudeContext';
+import { amplitudeTrackEventAtom } from 'src/atoms/amplitude/amplitudeTrackEventAtom';
+export const handleReplyAtom = atom(null, (get, set, { message, userTyped }) => {
+    var _a;
+    if (message.type !== MessageType.QueryTyped) {
+        return;
+    }
+    const trackEvent = get(amplitudeTrackEventAtom);
+    const queryTyped = message.metadata.content;
+    set(replyEventCategoryAtom, UserEventCategory.QueryTyped);
+    set(userQueryAtom, queryTyped);
+    set(messagesAtom, [...get(messagesAtom), [message]]);
+    set(userHasRepliedAtom, true);
+    set(queueUserEventAtom, {
+        eventId: message.id,
+        createdAt: message.createdAt,
+        category: UserEventCategory.QueryTyped,
+        attributes: {
+            query: queryTyped,
+        },
+    });
+    if (trackEvent) {
+        trackEvent({
+            eventName: SpiffyMetricsEventName.ChatUserMessageInput,
+            eventProps: {
+                message_id: message.id,
+                message_role: message.role,
+                message_type: message.type,
+                message_metadata: {
+                    content: (_a = message === null || message === void 0 ? void 0 : message.metadata) === null || _a === void 0 ? void 0 : _a.content, // Removed amplitudeSafeString
+                    created_at: message.createdAt,
+                    user_typed: userTyped,
+                },
+            },
+            alsoSendToGoogleAnalytics: true,
+        });
+    }
+});

package/dist/src/atoms/chat/suggestions.js

@@ -0,0 +1,29 @@
+import { atom } from "jotai";
+import { MessageRole, MessageType } from "src/types";
+import { messagesAtom, replyEventCategoryAtom, suggestionAtom, userHasRepliedAtom, } from "src/atoms/chat";
+import { UserEventCategory } from "@spiffy-ai/commerce-api-client";
+import { queueUserEventAtom } from "./messageQueue";
+export const handleSuggestionAtom = atom(null, (get, set, suggestion) => {
+    const newMessage = {
+        id: suggestion.id,
+        role: MessageRole.User,
+        type: MessageType.SuggestionClicked,
+        createdAt: new Date().toISOString(),
+        metadata: {
+            suggestionId: suggestion.id,
+            suggestionContent: suggestion.content,
+        },
+    };
+    set(replyEventCategoryAtom, UserEventCategory.SuggestionClicked);
+    set(suggestionAtom, suggestion);
+    set(messagesAtom, [...get(messagesAtom), [newMessage]]);
+    set(userHasRepliedAtom, true);
+    set(queueUserEventAtom, {
+        eventId: suggestion.id,
+        category: UserEventCategory.SuggestionClicked,
+        createdAt: newMessage.createdAt,
+        attributes: {
+            suggestionId: suggestion.id,
+        },
+    });
+});

package/dist/src/atoms/envive/enviveConfig.js

@@ -0,0 +1,67 @@
+import Logger from 'src/application/logging/logger';
+import { atom } from 'jotai';
+import { ContextSourceEnum } from '@spiffy-ai/commerce-api-client';
+import { LocalStorageKeys } from '@envive-ai/types';
+const internalEnviveConfigAtom = atom(undefined);
+export const enviveConfigAtom = atom((get) => {
+    const config = get(internalEnviveConfigAtom);
+    Logger.logDebug('enviveConfig.ts: Accessing internalEnviveConfigAtom', config);
+    return config; // Return undefined if not set instead of throwing
+}, (_, set, value) => {
+    set(internalEnviveConfigAtom, value);
+});
+export const amplitudeApiKeyAtom = atom((get) => {
+    const config = get(enviveConfigAtom);
+    return config === null || config === void 0 ? void 0 : config.amplitudeApiKey;
+});
+export const dataResidencyAtom = atom((get) => {
+    const config = get(enviveConfigAtom);
+    return config === null || config === void 0 ? void 0 : config.dataResidency;
+});
+export const envAtom = atom((get) => {
+    const config = get(enviveConfigAtom);
+    return config === null || config === void 0 ? void 0 : config.env;
+});
+export const baseUrlAtom = atom((get) => {
+    const config = get(enviveConfigAtom);
+    return (config === null || config === void 0 ? void 0 : config.baseUrl) || 'https://commerce-api.dev.spiffy.ai';
+});
+export const reactAppNameAtom = atom((get) => {
+    const config = get(enviveConfigAtom);
+    return config === null || config === void 0 ? void 0 : config.reactAppName;
+});
+export const cdnUrlAtom = atom((get) => {
+    const config = get(enviveConfigAtom);
+    return config === null || config === void 0 ? void 0 : config.cdnUrl;
+});
+export const contextSourceAtom = atom((get) => {
+    const config = get(enviveConfigAtom);
+    if (config === null || config === void 0 ? void 0 : config.contextSource) {
+        return config.contextSource;
+    }
+    const spiffyOnFeatureFlagSet = window.localStorage.getItem(LocalStorageKeys.SpiffyOnOverride);
+    if (spiffyOnFeatureFlagSet === 'true') {
+        return ContextSourceEnum.Playground;
+    }
+    return ContextSourceEnum.App;
+});
+export const orgLevelApiKeyAtom = atom((get) => {
+    const config = get(enviveConfigAtom);
+    Logger.logDebug('enviveConfig.ts: Accessing orgLevelApiKey', config);
+    return config === null || config === void 0 ? void 0 : config.orgLevelApiKey;
+});
+export const orgShortNameAtom = atom((get) => {
+    const config = get(enviveConfigAtom);
+    Logger.logDebug('enviveConfig.ts: Accessing orgShortName', config);
+    return config === null || config === void 0 ? void 0 : config.orgShortName;
+});
+export const identifyingPrefixAtom = atom((get) => {
+    const config = get(enviveConfigAtom);
+    Logger.logDebug('enviveConfig.ts: Accessing identifyingPrefix', config);
+    return (config === null || config === void 0 ? void 0 : config.identifyingPrefix) || 'spiffy';
+});
+export const publicKeyAtom = atom((get) => {
+    const config = get(enviveConfigAtom);
+    Logger.logDebug('enviveConfig.ts: Accessing publicKey', config);
+    return config === null || config === void 0 ? void 0 : config.publicKey;
+});

package/dist/src/atoms/globalSearch/globalSearch.js

@@ -0,0 +1,8 @@
+import { atom } from 'jotai';
+export const autocompleteStateAtom = atom({
+    results: [],
+    isLoading: false,
+});
+export const isFilterOpenAtom = atom(false);
+export const isGlobalSearchOpenAtom = atom(false);
+export const isSearchResultsOpenAtom = atom(false);

package/dist/src/atoms/globalSearch/index.js

@@ -0,0 +1 @@
+export * from "./globalSearch";

package/dist/src/atoms/org/customerService.js

@@ -0,0 +1,6 @@
+import { atom } from 'jotai';
+export const isBusinessHoursAtom = atom(true);
+export const isCustomerServiceOpenAtom = atom(false);
+export const customerServiceResponseAtom = atom();
+export const customerServiceChatStateAtom = atom();
+export const customerServiceAttachment = atom();

package/dist/src/atoms/org/graphqlConfig.js

@@ -0,0 +1,8 @@
+import { atom } from 'jotai';
+export const internalGraphQLColorsConfigAtom = atom(undefined);
+const internalGraphQLFrontendConfigAtom = atom(undefined);
+export const orgIdAtom = atom(undefined); // New atom for orgId
+export const featureFlagServiceAtom = atom(undefined); // New atom for FeatureFlagService
+export const frontendConfigAtom = atom((get) => get(internalGraphQLFrontendConfigAtom), (_, set, value) => {
+    set(internalGraphQLFrontendConfigAtom, value);
+});

package/dist/src/atoms/org/index.js

@@ -0,0 +1,4 @@
+export * from './customerService';
+export * from './graphqlConfig';
+export * from './orgAnalyticsConfig';
+export * from './newOrgConfigAtom';

package/dist/src/atoms/org/newOrgConfigAtom.js

@@ -0,0 +1,2 @@
+import { atom } from 'jotai';
+export const newOrgConfigAtom = atom(null);

package/dist/src/atoms/org/orgAnalyticsConfig.js

@@ -0,0 +1,8 @@
+import { atom } from 'jotai';
+const internalOrgAnalyticsConfigAtom = atom(undefined);
+export const orgAnalyticsConfigAtom = atom((get) => get(internalOrgAnalyticsConfigAtom), (_, set, value) => {
+    set(internalOrgAnalyticsConfigAtom, value);
+});
+export const orgAnalyticsAmplitudeConfigAtom = atom((get) => { var _a; return (_a = get(orgAnalyticsConfigAtom)) === null || _a === void 0 ? void 0 : _a.amplitude; });
+export const orgAnalyticsCustomerServiceConfigAtom = atom((get) => { var _a; return (_a = get(orgAnalyticsConfigAtom)) === null || _a === void 0 ? void 0 : _a.customerService; });
+export const orgAnalyticsGoogleAnalyticsConfigAtom = atom((get) => { var _a; return (_a = get(orgAnalyticsConfigAtom)) === null || _a === void 0 ? void 0 : _a.googleAnalytics; });

package/dist/src/atoms/search/index.js

@@ -0,0 +1 @@
+export * from './searchAPI';

package/dist/src/atoms/search/productFilters.js

@@ -0,0 +1,163 @@
+import { formatFilterDisplayName } from "./utils";
+const getPriceBucket = (price, bucketSize) => {
+    const bucket = Math.floor(price / bucketSize);
+    return bucket * bucketSize;
+};
+const isStringArray = (value) => {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    return value.every((item) => typeof item === "string");
+};
+const sortFilter = (filterConfig) => {
+    if (filterConfig.type === "price") {
+        return (a, b) => Number(a.filterItemId) - Number(b.filterItemId);
+    }
+    if (filterConfig.type === "dynamic") {
+        if (filterConfig.sorting.type === "alphabetic") {
+            return (a, b) => a.displayName.localeCompare(b.displayName);
+        }
+        // Sort by the number of products, if they match, sort by alphabetical
+        if (filterConfig.sorting.type === "productCount") {
+            return (a, b) => a.productCount === b.productCount
+                ? a.displayName.localeCompare(b.displayName)
+                : b.productCount - a.productCount;
+        }
+        if (filterConfig.sorting.type === "custom") {
+            const sortedKeys = filterConfig.sorting.map;
+            return (a, b) => {
+                if (sortedKeys[a.displayName] && sortedKeys[b.displayName]) {
+                    // If both are in the sortedKeys, sort by the index
+                    return sortedKeys[a.displayName] - sortedKeys[b.displayName];
+                }
+                // If only 'a' is in the sortedKeys, put it before the other
+                if (sortedKeys[a.displayName]) {
+                    return -1;
+                }
+                // If only 'b' is in the sortedKeys, put it before the other
+                if (sortedKeys[b.displayName]) {
+                    return 1;
+                }
+                // If neither are in the sortedKeys, sort by productCount
+                return b.productCount - a.productCount;
+            };
+        }
+    }
+    throw new Error("Invaalid search filter configuration");
+};
+export class ProductFilters {
+    static getFiltersForProducts(products, filterConfigs, selectedFilterOptions) {
+        if (!products || products.length === 0) {
+            return [];
+        }
+        const filters = filterConfigs.map((filterConfig) => products.reduce((acc, product) => {
+            var _a, _b, _c, _d, _e;
+            // Price has special handling for the filters
+            if (filterConfig.type === "price") {
+                const priceBucket = getPriceBucket((_b = (_a = product.salePrice) !== null && _a !== void 0 ? _a : product.originalPrice) !== null && _b !== void 0 ? _b : 0, filterConfig.bucketSize);
+                const current = (_c = acc.map[priceBucket]) !== null && _c !== void 0 ? _c : {
+                    filterItemId: priceBucket,
+                    displayName: `$${priceBucket}-$${priceBucket + filterConfig.bucketSize}`,
+                    productCount: 0,
+                };
+                acc.map[priceBucket] = {
+                    ...current,
+                    productCount: current.productCount + 1,
+                };
+                return acc;
+            }
+            // Assume that the "attribute" is an array of values
+            const attributeValues = (_e = (product.filters && ((_d = product.filters) === null || _d === void 0 ? void 0 : _d[filterConfig.attribute]))) !== null && _e !== void 0 ? _e : [];
+            if (isStringArray(attributeValues)) {
+                attributeValues.forEach((val) => {
+                    var _a;
+                    const normalizedVal = val.toLowerCase();
+                    const current = (_a = acc.map[normalizedVal]) !== null && _a !== void 0 ? _a : {
+                        filterItemId: normalizedVal,
+                        displayName: formatFilterDisplayName(val), // Keep original case for display
+                        productCount: 0,
+                    };
+                    acc.map[normalizedVal] = {
+                        ...current,
+                        productCount: current.productCount + 1,
+                    };
+                });
+            }
+            return acc;
+        }, {
+            filterConfig,
+            map: {},
+        }));
+        const transformedFilters = filters.map(({ filterConfig, map }) => ({
+            filterId: filterConfig.filterId,
+            displayName: filterConfig.displayName,
+            items: Object.values(map)
+                .map((filter) => {
+                var _a;
+                return ({
+                    filterItemId: filter.filterItemId,
+                    displayName: filter.displayName,
+                    productCount: filter.productCount,
+                    isSelected: (_a = selectedFilterOptions.some((option) => option.id ===
+                        `${filterConfig.filterId}:${filter.filterItemId}`)) !== null && _a !== void 0 ? _a : false,
+                });
+            })
+                .sort(sortFilter(filterConfig)),
+        }));
+        return [...transformedFilters];
+    }
+    static filterProducts(products, filterConfigs, selectedFilterOptions, additiveDynamicFilters = false // Set this to true to restore the original behavior where stacking filters has OR logic.
+    ) {
+        const selectedFilters = filterConfigs
+            .map((filterConfig) => ({
+            filterConfig,
+            hasSelectedOptions: selectedFilterOptions.some((option) => option.filterId === filterConfig.filterId),
+        }))
+            .filter(({ hasSelectedOptions }) => hasSelectedOptions);
+        return selectedFilterOptions.length === 0
+            ? products
+            : products.filter((product) => selectedFilters.reduce((acc, selectedFilter) => {
+                var _a, _b, _c;
+                // Finding one false removes the product
+                if (!acc) {
+                    return acc;
+                }
+                // Price is special
+                if (selectedFilter.filterConfig.type === "price") {
+                    const priceBucket = getPriceBucket((_b = (_a = product.salePrice) !== null && _a !== void 0 ? _a : product.originalPrice) !== null && _b !== void 0 ? _b : 0, selectedFilter.filterConfig.bucketSize);
+                    const matchesPriceFilter = selectedFilterOptions.some((option) => option.id === `price:${priceBucket}`);
+                    if (!matchesPriceFilter) {
+                        return false;
+                    }
+                }
+                if (selectedFilter.filterConfig.type === "dynamic") {
+                    // dynamic is misleading here. Its not just dynamic filters, but static filters because the config counts static filters as type: dynamic.
+                    const { filterId, attribute } = selectedFilter.filterConfig;
+                    const attributeValues = (_c = product.filters) === null || _c === void 0 ? void 0 : _c[attribute];
+                    if (!isStringArray(attributeValues)) {
+                        return false;
+                    }
+                    const isDynamicFilter = selectedFilter.filterConfig.attribute === "dynamic"; // True dynamic filters (the ones that appear beneath the search input)
+                    const isSubtractiveLogic = isDynamicFilter && !additiveDynamicFilters;
+                    if (isSubtractiveLogic) {
+                        // AND logic for subtractive dynamic filters and between static filter categories
+                        const selectedOptionsForThisFilter = selectedFilterOptions
+                            .filter((option) => option.filterId === filterId)
+                            .map((option) => option.filterItemId.toLowerCase());
+                        const hasAllSelectedValues = selectedOptionsForThisFilter.every((selectedValue) => attributeValues.some((val) => val.toLowerCase() === selectedValue));
+                        if (!hasAllSelectedValues) {
+                            return false;
+                        }
+                    }
+                    else {
+                        // OR logic for static filters in the sidebar within a category.
+                        const matches = attributeValues.some((val) => selectedFilterOptions.some((option) => option.id === `${filterId}:${val.toLowerCase()}`));
+                        if (!matches) {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            }, true));
+    }
+}

package/dist/src/atoms/search/productRetrievalAPI.js

@@ -0,0 +1,50 @@
+import { atom } from "jotai";
+import { getProductRetrievalFunction } from "./productRetrievalAdapter";
+export const productRetrievalAtom = atom({
+    data: null,
+    loading: false,
+    error: null,
+    lastProductIds: null,
+});
+export const performProductRetrievalAtom = atom(null, async (get, set, params) => {
+    const currentState = get(productRetrievalAtom);
+    if (currentState.loading) {
+        return; // Prevent concurrent retrievals
+    }
+    set(productRetrievalAtom, {
+        data: null,
+        loading: true,
+        error: null,
+        lastProductIds: params.productIds,
+    });
+    try {
+        const retrieveProducts = getProductRetrievalFunction();
+        const result = await retrieveProducts(params);
+        set(productRetrievalAtom, {
+            data: result,
+            loading: false,
+            error: null,
+            lastProductIds: params.productIds,
+        });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "An unknown error occurred";
+        set(productRetrievalAtom, {
+            data: null,
+            loading: false,
+            error: errorMessage,
+            lastProductIds: params.productIds,
+        });
+    }
+});
+// Get just the products array (already normalized by service)
+export const retrievedProductsAtom = atom((get) => {
+    const retrievalData = get(productRetrievalAtom).data;
+    return (retrievalData === null || retrievalData === void 0 ? void 0 : retrievalData.products) || [];
+});
+export const productRetrievalLoadingAtom = atom((get) => {
+    return get(productRetrievalAtom).loading;
+});
+export const productRetrievalErrorAtom = atom((get) => {
+    return get(productRetrievalAtom).error;
+});

package/dist/src/atoms/search/productRetrievalAdapter.js

@@ -0,0 +1,14 @@
+// This will be set by the ProductRetrievalProvider when it initializes
+let productRetrievalFunction = null;
+export const setProductRetrievalFunction = (fn) => {
+    productRetrievalFunction = fn;
+};
+export const getProductRetrievalFunction = () => {
+    if (!productRetrievalFunction) {
+        throw new Error("Product retrieval function not initialized. Make sure ProductRetrievalProvider is mounted.");
+    }
+    return productRetrievalFunction;
+};
+export const clearProductRetrievalFunction = () => {
+    productRetrievalFunction = null;
+};

package/dist/src/atoms/search/productSorter.js

@@ -0,0 +1,13 @@
+import { ProductSorting } from '@envive-ai/types';
+export class ProductSorter {
+    static sort(products, sorting) {
+        switch (sorting) {
+            case ProductSorting.PRICE_ASC:
+                return [...products].sort((p1, p2) => { var _a, _b, _c, _d; return ((_b = (_a = p1.salePrice) !== null && _a !== void 0 ? _a : p1.originalPrice) !== null && _b !== void 0 ? _b : 0) - ((_d = (_c = p2.salePrice) !== null && _c !== void 0 ? _c : p2.originalPrice) !== null && _d !== void 0 ? _d : 0); });
+            case ProductSorting.PRICE_DESC:
+                return [...products].sort((p1, p2) => { var _a, _b, _c, _d; return ((_b = (_a = p2.salePrice) !== null && _a !== void 0 ? _a : p2.originalPrice) !== null && _b !== void 0 ? _b : 0) - ((_d = (_c = p1.salePrice) !== null && _c !== void 0 ? _c : p1.originalPrice) !== null && _d !== void 0 ? _d : 0); });
+            default:
+                return products;
+        }
+    }
+}

package/dist/src/atoms/search/searchAPI.js

@@ -0,0 +1,140 @@
+import { atom } from 'jotai';
+import { ProductSorting } from '@envive-ai/types';
+import { ProductFilters } from './productFilters';
+import { ProductSorter } from './productSorter';
+import { newOrgConfigAtom } from '../org';
+import { getSearchServiceFunction } from './searchServiceAdapter';
+export const searchAtom = atom({
+    data: null,
+    loading: false,
+    error: null,
+    lastQuery: null,
+});
+export const searchProductSortingAtom = atom(ProductSorting.FEATURED);
+export const searchSelectedFiltersAtom = atom([]);
+export const createFilterOption = (filterId, filterItemId, displayName) => ({
+    id: `${filterId}:${filterItemId}`,
+    displayName,
+    filterId,
+    filterItemId,
+});
+const internalSearchParamsAtom = atom({
+    id: null,
+    query: null,
+});
+export const searchParamsAtom = atom((get) => get(internalSearchParamsAtom), (_, set, value) => {
+    set(internalSearchParamsAtom, value);
+});
+export const internalSearchSystemStateAtom = atom(false);
+export const searchSystemAtom = atom((get) => get(internalSearchSystemStateAtom), (get, set, value) => {
+    if (value === get(internalSearchSystemStateAtom)) {
+        return;
+    }
+    const stateChangeHandler = () => {
+        const params = new URLSearchParams(window.location.search);
+        if (params.get('es') === 'true') {
+            const id = params.get('esi');
+            const query = params.get('esq');
+            set(searchParamsAtom, { id, query });
+        }
+        else {
+            set(searchParamsAtom, { id: null, query: null });
+        }
+    };
+    if (value) {
+        set(internalSearchSystemStateAtom, true);
+        window.addEventListener('popstate', stateChangeHandler);
+        // Also trigger the hash change handler to set the initial state
+        stateChangeHandler();
+    }
+    else {
+        set(internalSearchSystemStateAtom, false);
+        window.removeEventListener('popstate', stateChangeHandler);
+    }
+});
+export const filteredSearchProductsAtom = atom((get) => {
+    var _a, _b;
+    const searchData = get(searchAtom).data;
+    const sorting = get(searchProductSortingAtom);
+    const selectedFilters = get(searchSelectedFiltersAtom);
+    const newOrgConfig = get(newOrgConfigAtom);
+    if (!(searchData === null || searchData === void 0 ? void 0 : searchData.products) || !((_b = (_a = newOrgConfig === null || newOrgConfig === void 0 ? void 0 : newOrgConfig.frontendConfig) === null || _a === void 0 ? void 0 : _a.uiConfigs) === null || _b === void 0 ? void 0 : _b.searchConfig))
+        return [];
+    const filteredProducts = ProductFilters.filterProducts(searchData.products, newOrgConfig.frontendConfig.uiConfigs.searchConfig.searchFilterConfig, selectedFilters, newOrgConfig.frontendConfig.uiConfigs.searchConfig.additiveDynamicFilters);
+    return ProductSorter.sort(filteredProducts, sorting);
+});
+export const searchFiltersAtom = atom((get) => {
+    var _a, _b;
+    const searchData = get(searchAtom).data;
+    const selectedFilters = get(searchSelectedFiltersAtom);
+    const newOrgConfig = get(newOrgConfigAtom);
+    if (!(searchData === null || searchData === void 0 ? void 0 : searchData.products) || !((_b = (_a = newOrgConfig === null || newOrgConfig === void 0 ? void 0 : newOrgConfig.frontendConfig) === null || _a === void 0 ? void 0 : _a.uiConfigs) === null || _b === void 0 ? void 0 : _b.searchConfig))
+        return [];
+    return ProductFilters.getFiltersForProducts(searchData.products, newOrgConfig.frontendConfig.uiConfigs.searchConfig.searchFilterConfig, selectedFilters);
+});
+export const addSearchFilterAtom = atom(null, (get, set, filter) => {
+    const current = get(searchSelectedFiltersAtom);
+    if (!current.some((f) => f.id === filter.id)) {
+        set(searchSelectedFiltersAtom, [...current, filter]);
+    }
+});
+export const removeSearchFilterAtom = atom(null, (get, set, filterId) => {
+    const current = get(searchSelectedFiltersAtom);
+    set(searchSelectedFiltersAtom, current.filter((f) => f.id !== filterId));
+});
+export const clearSearchFiltersAtom = atom(null, (_, set) => {
+    set(searchSelectedFiltersAtom, []);
+});
+export const performSearchAtom = atom(null, async (get, set, params, allowRedirect = false) => {
+    var _a, _b, _c;
+    const currentState = get(searchAtom);
+    const newOrgConfig = get(newOrgConfigAtom);
+    const redirectSearchResultsUrl = (_c = (_b = (_a = newOrgConfig === null || newOrgConfig === void 0 ? void 0 : newOrgConfig.frontendConfig) === null || _a === void 0 ? void 0 : _a.uiConfigs) === null || _b === void 0 ? void 0 : _b.searchConfig) === null || _c === void 0 ? void 0 : _c.redirectSearchResultsUrl;
+    if (allowRedirect && redirectSearchResultsUrl) {
+        const redirectUrl = new URL(redirectSearchResultsUrl);
+        redirectUrl.searchParams.set('es', 'true');
+        redirectUrl.searchParams.set('esq', params.query);
+        window.location.href = redirectUrl.toString();
+    }
+    else {
+        // Update URL and manually trigger state change (since pushState doesn't trigger popstate)
+        const url = new URL(window.location.href);
+        url.searchParams.set('es', 'true');
+        url.searchParams.set('esq', params.query);
+        window.history.pushState({}, '', url);
+        // Manually trigger page variant re-evaluation by dispatching a popstate event
+        // This ensures the page variant system detects the URL change and mounts search results
+        window.dispatchEvent(new PopStateEvent('popstate', { state: {} }));
+    }
+    // Manually trigger page variant re-evaluation by dispatching a popstate event
+    // This ensures the page variant system detects the URL change and mounts search results
+    window.dispatchEvent(new PopStateEvent('popstate', { state: {} }));
+    if (currentState.loading) {
+        return; // Prevent concurrent searches
+    }
+    set(searchAtom, {
+        data: null,
+        loading: true,
+        error: null,
+        lastQuery: params.query,
+    });
+    try {
+        const searchServiceFunction = getSearchServiceFunction();
+        const result = await searchServiceFunction(params);
+        set(searchAtom, {
+            data: result,
+            loading: false,
+            error: null,
+            lastQuery: params.query,
+        });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+        set(searchAtom, {
+            data: null,
+            loading: false,
+            error: errorMessage,
+            lastQuery: params.query,
+        });
+    }
+});

package/dist/src/atoms/search/searchServiceAdapter.js

@@ -0,0 +1,14 @@
+// This will be set by the SearchProvider when it initializes
+let searchServiceFunction = null;
+export const setSearchServiceFunction = (fn) => {
+    searchServiceFunction = fn;
+};
+export const getSearchServiceFunction = () => {
+    if (!searchServiceFunction) {
+        throw new Error("Search service function not initialized. Make sure SearchProvider is mounted.");
+    }
+    return searchServiceFunction;
+};
+export const clearSearchServiceFunction = () => {
+    searchServiceFunction = null;
+};

package/dist/src/atoms/search/utils.js

@@ -0,0 +1,15 @@
+export const formatFilterDisplayName = (displayName) => {
+    const sizes = ['xxxs', 'xxs', 'xs', 's', 'm', 'l', 'xl', 'xxl', 'xxxl', 'xxxxl'];
+    const processedWords = displayName
+        .toLowerCase()
+        .split(' ')
+        .map((word) => {
+        if (sizes.includes(word)) {
+            return word.toUpperCase();
+        }
+        return word.charAt(0).toUpperCase() + word.slice(1);
+    });
+    const titleCasedName = processedWords.join(' ');
+    // Final replacements for special cases
+    return titleCasedName.replace(/Iphone/g, 'iPhone');
+};

package/dist/src/config/index.js

@@ -0,0 +1 @@
+export * from './locators';

package/dist/src/config/locators/components/chat/entrypoints.js

@@ -0,0 +1,10 @@
+export const SOCIAL_PROOF_CUSTOMER_COUNT_MESSAGE_TESTID = 'spiffy-social-proof-customer-count-message';
+export const SOCIAL_PROOF_CUSTOMER_COUNT_BUTTON_TESTID = 'spiffy-social-proof-customer-count-button';
+export const SOCIAL_PROOF_PDP_CONTENTS_TESTID = 'spiffy-social-proof-pdp-contents';
+export const SOCIAL_PROOF_PLP_CONTENTS_TESTID = 'spiffy-social-proof-plp-contents';
+export const SOCIAL_PROOF_SUGGESTION_FOOTER_TESTID = 'spiffy-social-proof-suggestion-footer';
+export const SOCIAL_PROOF_WIDGET_TESTID = 'spiffy-social-proof-widget';
+export const SOCIAL_PROOF_WIDGET_HEADER_TESTID = 'spiffy-social-proof-widget-header';
+// used in spanx config
+export const TOP_IMAGE_BANNER_PLP_TESTID = 'spiffy-top-image-banner-plp';
+export const BOTTOM_IMAGE_BANNER_PLP_TESTID = 'spiffy-bottom-image-banner-plp';

package/dist/src/config/locators/components/chat/index.js

@@ -0,0 +1,21 @@
+// Test ids for components rendered inside the chat modal, and the chat modal
+export const CHAT_CONTAINER_ID = '#spiffy-modal-container';
+export const CHAT_HEADER_CONTAINER_TESTID = 'spiffy-chat-header-container';
+export const CHAT_HEADER_CLOSE_BUTTON_TESTID = 'spiffy-chat-header-close-button';
+export const CHAT_MESSAGE_CONTAINER_TESTID = 'spiffy-chat-message-container';
+export const CHAT_MESSAGE_DIVIDER_TESTID = 'spiffy-chat-message-divider';
+export const CHAT_MODAL_TESTID = 'spiffy-modal-shadow-dom-container';
+export const CHAT_REPLY_INPUT_TESTID = 'spiffy-chat-reply-input';
+export const CHAT_REPLY_INPUT_SEND_BUTTON_TESTID = 'spiffy-chat-reply-input-send-button';
+export const CHAT_VIEW_PREVIOUS_MESSAGES_TESTID = 'spiffy-chat-view-previous-messages';
+export const DYNAMIC_CAROUSEL_TESTID = 'dynamic-carousel';
+export const IMAGE_STACK_TESTID = 'spiffy-product-comparison-image-stack';
+export const IMAGE_STACK_FIRST_IMAGE_TESTID = 'spiffy-product-comparison-image-stack-first-image';
+export const IMAGE_STACK_SECOND_IMAGE_TESTID = 'spiffy-product-comparison-image-stack-second-image';
+export const LOADING_MESSAGE_CONTAINER_TESTID = 'spiffy-messages-loading-container';
+export const MOBILE_CHAT_HEADER_TESTID = 'spiffy-mobile-chat-header';
+export const SCROLLABLE_SUGGESTIONS_TESTID = 'spiffy-scrollable-suggestions';
+export const SUGGESTION_BAR_TESTID = 'spiffy-suggestion-bar';
+export const SUGGESTION_BAR_BUTTON_TESTID = 'spiffy-suggestion-bar-button';
+export const TAG_TESTID = 'spiffy-tag';
+export const ANIMATED_MESSAGES_TESTID = 'spiffy-animated-messages';