@sonic-equipment/ui 0.0.119 → 1.1.0

package/dist/_virtual/_commonjsHelpers.js

@@ -0,0 +1,5 @@
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export { getDefaultExportFromCjs };

package/dist/_virtual/index.js

@@ -0,0 +1,7 @@
+import { getDefaultExportFromCjs } from './_commonjsHelpers.js';
+import { __require as requireLib } from '../node_modules/.pnpm/qs@6.9.7/node_modules/qs/lib/index.js';
+
+var libExports = requireLib();
+var qs = /*@__PURE__*/getDefaultExportFromCjs(libExports);
+
+export { qs as default };

package/dist/address-info-display/address-info-display.d.ts

@@ -0,0 +1,6 @@
+import { Address } from '../shared/model/address';
+export interface AddressProps {
+    address: Address;
+    'data-test-selector'?: string;
+}
+export declare function AddressInfoDisplay({ address, 'data-test-selector': dataTestSelector, }: AddressProps): import("react/jsx-runtime").JSX.Element;

package/dist/address-info-display/address-info-display.js

@@ -0,0 +1,10 @@
+"use client";
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import styles from './address-info-display.module.css.js';
+
+function AddressInfoDisplay({ address, 'data-test-selector': dataTestSelector, }) {
+    const { address1, address2, address3, city, companyName, country, email, firstName, lastName, phone, postalCode, } = address;
+    return (jsxs("address", { className: styles.address, "data-test-selector": dataTestSelector, children: [(firstName || lastName) && (jsxs("p", { "data-test-selector": "addressInfoDisplay_name", children: [jsx("span", { "data-test-selector": "addressInfoDisplay_name_firstName", children: firstName }), ` `, jsx("span", { "data-test-selector": "addressInfoDisplay_name_lastName", children: lastName })] })), companyName && (jsx("p", { "data-test-selector": "addressInfoDisplay_companyName", children: companyName })), address1 && (jsx("p", { "data-test-selector": "addressInfoDisplay_address1", children: address1 })), address2 && (jsx("p", { "data-test-selector": "addressInfoDisplay_address2", children: address2 })), address3 && (jsx("p", { "data-test-selector": "addressInfoDisplay_address3", children: address3 })), (postalCode || city) && (jsxs("p", { children: [postalCode && (jsxs(Fragment, { children: [jsx("span", { "data-test-selector": "addressInfoDisplay_postalCode", children: postalCode }), ' '] })), city && (jsx("span", { "data-test-selector": "addressInfoDisplay_city", children: city }))] })), country && (jsx("p", { "data-test-selector": "addressInfoDisplay_country", children: typeof country === 'string' ? country : country.name })), phone && jsx("p", { "data-test-selector": "addressInfoDisplay_phone", children: phone }), email && jsx("p", { "data-test-selector": "addressInfoDisplay_email", children: email })] }));
+}
+
+export { AddressInfoDisplay };

package/dist/address-info-display/address-info-display.module.css.js

@@ -0,0 +1,3 @@
+var styles = {"address":"address-info-display-module-CbRth"};
+
+export { styles as default };

package/dist/algolia/algolia-active-categories.js

@@ -0,0 +1,39 @@
+"use client";
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { useHierarchicalMenu } from 'react-instantsearch';
+import clsx from 'clsx';
+import { Link } from '../buttons/link/link.js';
+import { Icon } from '../icon/icon.js';
+import { useFormattedMessage } from '../intl/use-formatted-message.js';
+import { FilterSection } from './filter-section.js';
+import styles from './algolia-filter-panel.module.css.js';
+import filterSectionStyles from './filter-section.module.css.js';
+
+function AlgoliaActiveCategories() {
+    const { items: categories } = useHierarchicalMenu({
+        attributes: [
+            'hierarchicalCategories.lvl0',
+            'hierarchicalCategories.lvl1',
+            'hierarchicalCategories.lvl2',
+            'hierarchicalCategories.lvl3',
+        ],
+    });
+    const t = useFormattedMessage();
+    if (categories.length <= 0)
+        return null;
+    return (jsx(FilterSection, { gap: "sm", title: t('facet.categories'), variant: "default", children: jsx(Categories, { categories: categories, path: "/Catalog" }) }));
+}
+function Categories({ categories, path: _path, }) {
+    return categories
+        .filter(category => category.isRefined)
+        .map(category => {
+        const categorySlug = category.label.toLowerCase().replaceAll(' ', '-');
+        const path = `${_path}/${categorySlug}`;
+        const isActive = !category.data || !category.data.some(c => c.isRefined);
+        return (jsxs(Fragment, { children: [jsx("div", { className: filterSectionStyles['filter-section-item'], children: jsxs(Link, { hasUnderline: true, className: clsx(styles.category, {
+                            [styles['is-active']]: isActive,
+                        }), href: path, isDisabled: isActive, children: [jsx(Icon, { name: "Categories" }), jsx("span", { children: category.label })] }) }), category.data && (jsx(Categories, { categories: category.data, path: path }))] }, category.value));
+    });
+}
+
+export { AlgoliaActiveCategories };

package/dist/algolia/algolia-active-filters.js

@@ -0,0 +1,38 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { useCurrentRefinements, useClearRefinements } from 'react-instantsearch';
+import { ActiveFilters } from '../filters/active-filters/active-filters.js';
+
+function AlgoliaActiveFilters() {
+    const { items, refine } = useCurrentRefinements();
+    const itemsToIgnore = [
+        'hierarchicalCategories.lvl0',
+        'hierarchicalCategories.lvl1',
+        'hierarchicalCategories.lvl2',
+        'hierarchicalCategories.lvl3',
+        'hierarchicalStorefrontCategories.lvl0',
+        'hierarchicalStorefrontCategories.lvl1',
+        'hierarchicalStorefrontCategories.lvl2',
+        'hierarchicalStorefrontCategories.lvl3',
+    ];
+    const { refine: clearAllFilters } = useClearRefinements({
+        excludedAttributes: itemsToIgnore,
+    });
+    const itemsToDisplay = items.filter(item => !itemsToIgnore.includes(item.label));
+    const selectedFilterCategories = itemsToDisplay
+        .sort((a, b) => (a.label.localeCompare(b.label) ? 1 : -1))
+        .map((category) => ({
+        filters: category.refinements,
+        label: category.label,
+    }));
+    function onClearFilter(categoryLabel, filter) {
+        selectedFilterCategories
+            .filter(category => category.label === categoryLabel)
+            .flatMap(category => category.filters)
+            .filter(f => f.value === filter.value)
+            .forEach(refine);
+    }
+    return (jsx(ActiveFilters, { onClearAllFilters: clearAllFilters, onClearFilter: onClearFilter, selectedFilterCategories: selectedFilterCategories }));
+}
+
+export { AlgoliaActiveFilters };

package/dist/algolia/algolia-categories-filters.js

@@ -0,0 +1,27 @@
+"use client";
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { Fragment } from 'react';
+import { useHierarchicalMenu } from 'react-instantsearch';
+import clsx from 'clsx';
+import { Link } from '../buttons/link/link.js';
+import { Icon } from '../icon/icon.js';
+import { useFormattedMessage } from '../intl/use-formatted-message.js';
+import { transformAlgoliaCategoryData } from '../shared/model/category.js';
+import { FilterSection } from './filter-section.js';
+import styles from './algolia-filter-panel.module.css.js';
+import filterSectionStyles from './filter-section.module.css.js';
+
+function AlgoliaCategoriesFilters() {
+    const { items, refine } = useHierarchicalMenu({
+        attributes: ['hierarchicalStorefrontCategories.lvl0'],
+    });
+    const t = useFormattedMessage();
+    if (items.length <= 0)
+        return null;
+    const categories = transformAlgoliaCategoryData(items);
+    return (jsx(FilterSection, { title: t('facet.categories'), variant: "default", children: categories.map((category, index) => (jsx(Fragment, { children: jsx("div", { className: filterSectionStyles['filter-section-item'], children: jsxs(Link, { hasUnderline: true, className: clsx(styles.category, {
+                        [styles['is-active']]: category.isRefined,
+                    }), color: "primary", onClick: () => refine(category.value), children: [jsx(Icon, { name: "Categories" }), jsx("span", { children: category.name }), jsxs("span", { className: styles.count, children: ["(", category.count, ")"] })] }) }) }, category.href || index))) }));
+}
+
+export { AlgoliaCategoriesFilters };

package/dist/algolia/algolia-dummy-refinement-list-consumer.js

@@ -0,0 +1,20 @@
+"use client";
+import { useRefinementList } from 'react-instantsearch';
+
+function AlgoliaDummyRefinementListConsumer() {
+    /*
+     * This component supresses the following Algolia warning:
+     *
+     *   [InstantSearch.js]: The UI state for the index "instant_search" is not consistent with the widgets mounted.
+     *
+     * When the page loads the useDynamicWidgets hook is called to
+     * get a list of attributes to render. This is list is empty initially
+     * and therefor no refinement list is rendered. This causes the warning.
+     *
+     * Reference: https://github.com/algolia/instantsearch/pull/4140
+     */
+    useRefinementList({ attribute: 'dummy' });
+    return null;
+}
+
+export { AlgoliaDummyRefinementListConsumer };

package/dist/algolia/algolia-filter-panel.js

@@ -0,0 +1,39 @@
+"use client";
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useDynamicWidgets } from 'react-instantsearch';
+import { Button } from '../buttons/button/button.js';
+import { FormattedMessage } from '../intl/formatted-message.js';
+import { useSidebarActions } from '../sidebar/use-sidebar.js';
+import { AlgoliaActiveCategories } from './algolia-active-categories.js';
+import { AlgoliaActiveFilters } from './algolia-active-filters.js';
+import { AlgoliaCategoriesFilters } from './algolia-categories-filters.js';
+import { AlgoliaDummyRefinementListConsumer } from './algolia-dummy-refinement-list-consumer.js';
+import { AlgoliaMultiSelectFilterSection } from './algolia-multi-select-filter-section.js';
+import { AlgoliaResultsCount } from './algolia-results-count.js';
+import styles from './algolia-filter-panel.module.css.js';
+
+const MULTISELECT_ATTRIBUTE_IGNORE_LIST = [
+    'hierarchicalCategories.lvl0',
+];
+function AlgoliaFilterPanel({ showActiveCategories = false, showCategoriesFilters = false, }) {
+    /*
+     * This hook will return the attributes that are available to be rendered.
+     * Initially it will return an empty array and fires a new query to Algolia
+     * to get the attributes that are available to be rendered.
+     *
+     * *** THIS WILL CAUSE A SECOND QUERY TO ALGOLIA ON PAGE LOAD***
+     * See ticket: https://dev.azure.com/arlanet/Sonic%20Equipment/_workitems/edit/23095
+     */
+    const { attributesToRender } = useDynamicWidgets({
+        facets: ['*'],
+        maxValuesPerFacet: 100,
+    });
+    const { close } = useSidebarActions();
+    return (jsxs("div", { className: styles['filter-panel'], children: [jsxs("div", { className: styles.content, children: [showActiveCategories && jsx(AlgoliaActiveCategories, {}), showCategoriesFilters && jsx(AlgoliaCategoriesFilters, {}), jsx(AlgoliaActiveFilters, {}), attributesToRender.length === 0 ? (jsx(AlgoliaDummyRefinementListConsumer, {})) : (jsx("section", { children: attributesToRender
+                            .filter(attribute => !MULTISELECT_ATTRIBUTE_IGNORE_LIST.includes(attribute))
+                            .map(attribute => {
+                            return (jsx(AlgoliaMultiSelectFilterSection, { attribute: attribute }, `attribute-${attribute}`));
+                        }) }))] }), jsx("div", { className: styles.footer, children: jsxs(Button, { withArrow: true, onClick: close, size: "md", children: [jsx(FormattedMessage, { id: "Show" }), " ", jsx(AlgoliaResultsCount, {})] }) })] }));
+}
+
+export { AlgoliaFilterPanel };

package/dist/algolia/algolia-filter-panel.module.css.js

@@ -0,0 +1,3 @@
+var styles = {"filter-panel":"algolia-filter-panel-module-GfhOO","content":"algolia-filter-panel-module-KFCCf","footer":"algolia-filter-panel-module--DfrD","category":"algolia-filter-panel-module-LKet3","is-active":"algolia-filter-panel-module-yf8kI","count":"algolia-filter-panel-module-uAHPx"};
+
+export { styles as default };

package/dist/algolia/algolia-hit-type.d.ts

@@ -1,4 +1,5 @@
 import { Hit } from '@algolia/client-search';
+import { CurrencyCode } from '../intl/types';
 import { ImageType } from '../shared/model/image';
 interface AlgoliaHitBase {
     [key: string]: any;
@@ -17,6 +18,7 @@ export interface AlgoliaProduct extends AlgoliaHitBase {
     categories: string[];
     categoryPageId: string[];
     consumerPrice: number;
+    currencyCode: CurrencyCode;
     discountedPrice: number;
     drawerQuantity: string;
     ean: string;

package/dist/algolia/algolia-hit-type.js

@@ -0,0 +1,6 @@
+"use client";
+function isAlgoliaProductHit(hit) {
+    return hit.type === 'product';
+}
+
+export { isAlgoliaProductHit };

package/dist/algolia/algolia-hits-provider.js

@@ -0,0 +1,17 @@
+"use client";
+import { useHits } from 'react-instantsearch';
+import { useAlgoliaHitsItems, useAlgoliaHitsLoading } from './use-algolia-hits.js';
+import { useAlgoliaInstantSearchState } from './use-algolia-instant-search-state.js';
+
+function AlgoliaHitsProvider() {
+    const { status } = useAlgoliaInstantSearchState();
+    const [, setItems] = useAlgoliaHitsItems();
+    const [, setLoading] = useAlgoliaHitsLoading();
+    const { items, results } = useHits();
+    setItems(items);
+    // @ts-expect-error -- params is not officially exposed but is included in results
+    setLoading(status !== 'idle' || !results || results.params === '');
+    return null;
+}
+
+export { AlgoliaHitsProvider };

package/dist/algolia/algolia-index-config.d.ts

@@ -8,5 +8,7 @@ export interface Indexes {
     }[];
     suggestions: string;
 }
-export declare const algoliaIndexesPerEnvironment: Record<Environment, Indexes>;
+type AlgoliaEnvironment = 'development' | 'production';
+export declare const algoliaIndexesPerEnvironment: Record<AlgoliaEnvironment, Indexes>;
 export declare const getAlgoliaIndex: (environment: Environment, languageCode: LanguageCode) => Indexes;
+export {};

package/dist/algolia/algolia-index-config.js

@@ -0,0 +1,77 @@
+"use client";
+const defaultLanguageCodes = {
+    PL: 'EN',
+};
+const getLanguageForAlgoliaIndex = (languageCode) => defaultLanguageCodes[languageCode] || languageCode;
+const algoliaIndexesPerEnvironment = {
+    development: {
+        default: 'dev_sonic_products_<languageCode>',
+        sort: [
+            {
+                index: 'dev_sonic_products_<languageCode>',
+                name: 'relevance',
+            },
+            {
+                index: 'dev_sonic_products_<languageCode>_is-new_desc',
+                name: 'newest',
+            },
+            {
+                index: 'dev_sonic_products_<languageCode>_price_asc',
+                name: 'price_asc',
+            },
+            {
+                index: 'dev_sonic_products_<languageCode>_price_desc',
+                name: 'price_desc',
+            },
+        ],
+        suggestions: 'dev_sonic_products_<languageCode>_query_suggestions',
+    },
+    production: {
+        default: 'prod_sonic_products_<languageCode>',
+        sort: [
+            {
+                index: 'prod_sonic_products_<languageCode>',
+                name: 'relevance',
+            },
+            {
+                index: 'prod_sonic_products_<languageCode>_is-new_desc',
+                name: 'newest',
+            },
+            {
+                index: 'prod_sonic_products_<languageCode>_price_asc',
+                name: 'price_asc',
+            },
+            {
+                index: 'prod_sonic_products_<languageCode>_price_desc',
+                name: 'price_desc',
+            },
+        ],
+        suggestions: 'prod_sonic_products_<languageCode>_query_suggestions',
+    },
+};
+const DEV_LIKE = new Set([
+    'local',
+    'marketingLocal',
+    'sandbox',
+    'sandbox-reverse-proxy',
+    'storybook',
+    'next-development',
+]);
+const getAlgoliaIndex = (environment, languageCode) => {
+    let algoliaIndexEnv = 'production';
+    const language = getLanguageForAlgoliaIndex(languageCode).toLowerCase();
+    if (DEV_LIKE.has(environment)) {
+        algoliaIndexEnv = 'development';
+    }
+    const environmentIndex = algoliaIndexesPerEnvironment[algoliaIndexEnv];
+    return {
+        default: environmentIndex.default.replace(/<languageCode>/, language),
+        sort: environmentIndex.sort.map(({ index, name }) => ({
+            index: index.replace(/<languageCode>/, language),
+            name,
+        })),
+        suggestions: environmentIndex.suggestions.replace(/<languageCode>/, language),
+    };
+};
+
+export { algoliaIndexesPerEnvironment, getAlgoliaIndex };

package/dist/algolia/algolia-initialization.js

@@ -0,0 +1,34 @@
+"use client";
+import Cookies from 'js-cookie';
+import aa from 'search-insights';
+import { config } from '../config.js';
+import { logger } from '../logging/logger.js';
+import { request } from '../shared/fetch/request.js';
+import { createUUID } from '../shared/utils/uuid.js';
+
+let userToken = generateUserToken();
+aa('init', {
+    apiKey: config.ALGOLIA_API_KEY,
+    appId: config.ALGOLIA_APP_ID,
+    useCookie: (Cookies.get('cookie-statistics-0') || 'false').toLowerCase() === 'true',
+    userToken,
+});
+aa('getUserToken', {}, (err, value) => {
+    if (err)
+        return logger.error(err);
+    userToken = value === undefined ? generateUserToken() : String(value);
+});
+aa('onUserTokenChange', value => {
+    userToken = value === undefined ? generateUserToken() : String(value);
+});
+request.after(({ body, options: { url } }) => {
+    if (url.toLocaleLowerCase().includes('/api/v1/sessions/current')) {
+        const userToken = body?.userProfileId || generateUserToken();
+        aa('setUserToken', userToken);
+    }
+});
+function generateUserToken() {
+    return `anonymous-${createUUID()}`;
+}
+
+export { userToken };

package/dist/algolia/algolia-insight-instant-search-provider.js

@@ -0,0 +1,14 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { AlgoliaInsightsProvider } from './algolia-insights-provider.js';
+import { useAlgoliaInstantSearchState } from './use-algolia-instant-search-state.js';
+
+function AlgoliaInsightInstantSearchProvider({ children, }) {
+    const { index, queryId } = useAlgoliaInstantSearchState();
+    return (jsx(AlgoliaInsightsProvider, { value: {
+            index,
+            queryId,
+        }, children: children }));
+}
+
+export { AlgoliaInsightInstantSearchProvider };

package/dist/algolia/algolia-insights-provider.d.ts

@@ -4,7 +4,7 @@ export interface AlgoliaInsightsProviderState extends AlgoliaInsightsProviderGlo
     objectId?: string | string[] | undefined;
     position?: number | number[] | undefined;
 }
-export declare const AlgoliaInsightsProviderContext: React.Context<AlgoliaInsightsProviderState>;
+export declare const AlgoliaInsightsProviderContext: import("react").Context<AlgoliaInsightsProviderState>;
 export declare function AlgoliaInsightsProvider({ children, value, }: {
     children?: ReactNode;
     value?: AlgoliaInsightsProviderState;

package/dist/algolia/algolia-insights-provider.js

@@ -0,0 +1,25 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { createContext, useContext, useMemo } from 'react';
+import { useCultureCode } from '../intl/use-culture-code.js';
+import { getLanguageCodeFromCultureCode } from '../intl/utils.js';
+import { environment } from '../shared/utils/environment.js';
+import { getAlgoliaIndex } from './algolia-index-config.js';
+import { useAlgoliaInsightsGlobalState } from './use-algolia-insights-provider-global-state.js';
+
+const AlgoliaInsightsProviderContext = createContext({});
+function AlgoliaInsightsProvider({ children, value, }) {
+    const cultureCode = useCultureCode();
+    const algoliaIndex = getAlgoliaIndex(environment, getLanguageCodeFromCultureCode(cultureCode));
+    const [globalState] = useAlgoliaInsightsGlobalState();
+    const context = useContext(AlgoliaInsightsProviderContext);
+    const combinedValue = useMemo(() => ({
+        index: algoliaIndex.default,
+        ...globalState,
+        ...context,
+        ...value,
+    }), [algoliaIndex.default, context, globalState, value]);
+    return (jsx(AlgoliaInsightsProviderContext.Provider, { value: combinedValue, children: children }));
+}
+
+export { AlgoliaInsightsProvider, AlgoliaInsightsProviderContext };

package/dist/algolia/algolia-instant-search-state-provider.js

@@ -0,0 +1,16 @@
+"use client";
+import { useInstantSearch } from 'react-instantsearch';
+import { useAlgoliaInstantSearchStateIndex, useAlgoliaInstantSearchStateQueryId, useAlgoliaInstantSearchStateStatus } from './use-algolia-instant-search-state.js';
+
+function AlgoliaInstantSearchStateProvider() {
+    const { results: { index, queryID }, status, } = useInstantSearch();
+    const [, setIndex] = useAlgoliaInstantSearchStateIndex();
+    const [, setQueryId] = useAlgoliaInstantSearchStateQueryId();
+    const [, setStatus] = useAlgoliaInstantSearchStateStatus();
+    setStatus(status);
+    setIndex(index);
+    setQueryId(queryID);
+    return null;
+}
+
+export { AlgoliaInstantSearchStateProvider };

package/dist/algolia/algolia-multi-select-filter-section.js

@@ -0,0 +1,27 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { useRefinementList } from 'react-instantsearch';
+import { MultiSelect } from '../filters/multi-select/multi-select.js';
+import { Checkbox } from '../forms/elements/checkbox/checkbox.js';
+import { FilterSection } from './filter-section.js';
+
+function AlgoliaMultiSelectFilterSection({ attribute, }) {
+    const { items, refine } = useRefinementList({
+        attribute,
+        limit: 100,
+        operator: 'or',
+        showMoreLimit: 100,
+    });
+    if (items.length === 0 ||
+        (items.length < 2 && items.filter(item => item.isRefined).length === 0)) {
+        return null;
+    }
+    return (jsx(FilterSection, { title: attribute, variant: "collapsible", children: jsx(MultiSelect, { onChange: ({ value }) => refine(value), options: items.map(item => ({
+                amount: item.count,
+                isSelected: item.isRefined,
+                label: item.label,
+                value: item.value,
+            })), render: ({ onChange, option }) => (jsx(Checkbox, { isSelected: option.isSelected, onChange: () => onChange(option.value), textSize: "small", value: option.value, children: option.label })) }) }));
+}
+
+export { AlgoliaMultiSelectFilterSection };

package/dist/algolia/algolia-pagination.js

@@ -0,0 +1,18 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { usePagination } from 'react-instantsearch';
+import { Pagination } from '../filters/pagination/pagination.js';
+
+function AlgoliaPagination({ onChange }) {
+    const { currentRefinement, nbPages, refine } = usePagination();
+    function handlePageChange(pageNumber) {
+        refine(pageNumber - 1);
+        onChange(pageNumber);
+    }
+    if (nbPages === 0) {
+        return null;
+    }
+    return (jsx(Pagination, { currentPage: currentRefinement + 1, onChange: pageNumber => handlePageChange(pageNumber), totalPages: nbPages }));
+}
+
+export { AlgoliaPagination };

package/dist/algolia/algolia-provider.js

@@ -0,0 +1,34 @@
+"use client";
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { InstantSearch, Configure } from 'react-instantsearch';
+import { useGlobalState } from '../shared/providers/global-state-provider.js';
+import { environment } from '../shared/utils/environment.js';
+import { AlgoliaHitsProvider } from './algolia-hits-provider.js';
+import { getAlgoliaIndex } from './algolia-index-config.js';
+import { AlgoliaInsightInstantSearchProvider } from './algolia-insight-instant-search-provider.js';
+import { AlgoliaInstantSearchStateProvider } from './algolia-instant-search-state-provider.js';
+import { createQueryStringRouting } from './algolia-query-string-routing.js';
+import { useAlgoliaInstantSearchState } from './use-algolia-instant-search-state.js';
+
+function AlgoliaProvider({ categoryPages, children, hierarchicalCategories, languageCode, offlineSearchClient, online: _online = true, query, searchClient, }) {
+    const { online } = useAlgoliaInstantSearchState({
+        online: _online,
+    });
+    const algoliaIndex = getAlgoliaIndex(environment, languageCode);
+    return (jsxs(InstantSearch, { future: {
+            persistHierarchicalRootCount: true,
+            preserveSharedStateOnUnmount: true,
+        }, indexName: algoliaIndex.default, insights: true, routing: createQueryStringRouting({
+            algoliaIndex,
+            hierarchicalCategories,
+        }), searchClient: online ? searchClient : offlineSearchClient || searchClient, children: [jsx(Configure, { analytics: true, filters: categoryPages
+                    ? // Replace double quotes with escaped double quotes to avoid breaking the query
+                        `categoryPages: "${categoryPages.replaceAll('"', String.raw `\"`)}"`
+                    : undefined, hitsPerPage: 12, maxValuesPerFacet: 100, query: query, ruleContexts: ['storefront'] }), jsx(AlgoliaInstantSearchStateProvider, {}), jsx(AlgoliaHitsProvider, {}), jsx(AlgoliaInsightInstantSearchProvider, { children: children })] }));
+}
+function useAlgolia() {
+    const [online, setOnline] = useGlobalState('algolia', false);
+    return { online, setOnline, toggleOnline: () => setOnline(!online) };
+}
+
+export { AlgoliaProvider, useAlgolia };

package/dist/algolia/algolia-query-string-routing.js

@@ -0,0 +1,108 @@
+"use client";
+import simpleStateMapping from '../node_modules/.pnpm/instantsearch.js@4.79.2_algoliasearch@4.24.0/node_modules/instantsearch.js/es/lib/stateMappings/simple.js';
+import historyRouter from '../node_modules/.pnpm/instantsearch.js@4.79.2_algoliasearch@4.24.0/node_modules/instantsearch.js/es/lib/routers/history.js';
+
+function createQueryStringRouting({ algoliaIndex, hierarchicalCategories, }) {
+    return {
+        router: historyRouter({
+            cleanUrlOnDispose: false,
+            createURL({ location, qsModule: qs, routeState }) {
+                const indexNames = Object.keys(routeState);
+                const indexName = indexNames[0];
+                if (!indexName)
+                    return location.href;
+                if (indexNames.length !== 1)
+                    throw new Error('Only one index is supported');
+                const state = routeState[indexName];
+                if (!state)
+                    throw new Error(`Index ${indexName} not found in routeState`);
+                const queryString = qs.parse(location.search.slice(1), {
+                    allowDots: true,
+                    duplicates: 'combine',
+                });
+                queryString.filters = state.refinementList;
+                queryString.sortBy = state.sortBy;
+                if (state.page) {
+                    queryString.page = state.page.toString();
+                }
+                else {
+                    delete queryString.page;
+                }
+                if (!hierarchicalCategories &&
+                    state.hierarchicalMenu?.['hierarchicalCategories.lvl0']) {
+                    queryString.category =
+                        state.hierarchicalMenu['hierarchicalCategories.lvl0'].join('+');
+                }
+                const newQueryString = qs.stringify(queryString, {
+                    addQueryPrefix: true,
+                    allowDots: true,
+                    arrayFormat: 'repeat',
+                });
+                return `${location.href.split('?')[0]}${newQueryString}`;
+            },
+            parseURL({ location, qsModule: qs }) {
+                const queryString = qs.parse(location.search.slice(1), {
+                    allowDots: true,
+                    duplicates: 'combine',
+                });
+                const refinementList = Object.entries(queryString.filters || {}).reduce((refinementList, [filter, value]) => {
+                    refinementList[filter] = [value && String(value)]
+                        .flat()
+                        .filter(Boolean);
+                    return refinementList;
+                }, {});
+                const hierarchicalMenu = hierarchicalCategories
+                    ? {
+                        'hierarchicalCategories.lvl0': hierarchicalCategories,
+                    }
+                    : queryString.category
+                        ? typeof queryString.category === 'string'
+                            ? {
+                                'hierarchicalCategories.lvl0': queryString.category.split('+'),
+                            }
+                            : Array.isArray(queryString.category)
+                                ? {
+                                    'hierarchicalCategories.lvl0': queryString.category
+                                        .join('+')
+                                        .split('+'),
+                                }
+                                : undefined
+                        : undefined;
+                const sortBy = queryString.sortBy?.toString();
+                const uiState = {
+                    [algoliaIndex.default]: {
+                        hierarchicalMenu,
+                        page: queryString.page
+                            ? Number.parseInt(queryString.page.toString(), 10)
+                            : 0,
+                        refinementList,
+                        sortBy,
+                    },
+                };
+                return uiState;
+            },
+        }),
+        stateMapping: {
+            routeToState(routeState) {
+                return simpleStateMapping().routeToState(hierarchicalCategories
+                    ? Object.keys(routeState).reduce((newRouteState, indexName) => {
+                        if (!routeState[indexName])
+                            return newRouteState;
+                        return {
+                            ...newRouteState,
+                            [indexName]: {
+                                ...routeState[indexName],
+                                hierarchicalMenu: {
+                                    'hierarchicalCategories.lvl0': hierarchicalCategories,
+                                },
+                            },
+                        };
+                    }, routeState)
+                    : routeState);
+            },
+            stateToRoute: simpleStateMapping().stateToRoute,
+        },
+    };
+}
+
+export { createQueryStringRouting };