@sonic-equipment/ui 0.0.119 → 121.0.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/algolia/algolia-active-categories.js

@@ -0,0 +1,38 @@
+"use client";
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { useHierarchicalMenu } from 'react-instantsearch';
+import clsx from 'clsx';
+import { StrokeCategoriesIcon } from '../icons/stroke/stroke-categories-icon.js';
+import { useFormattedMessage } from '../intl/use-formatted-message.js';
+import { RouteLink } from '../shared/routing/route-link.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',
+        ],
+    });
+    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(RouteLink, { hasUnderline: true, className: clsx(styles.category, {
+                            [styles['is-active']]: isActive,
+                        }), href: path, isDisabled: isActive, children: [jsx(StrokeCategoriesIcon, { height: 24, width: 24 }), 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,33 @@
+"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',
+    ];
+    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,29 @@
+"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 { StrokeCategoriesIcon } from '../icons/stroke/stroke-categories-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 AlgoliaCategoriesFilters() {
+    const { items: categories, refine } = useHierarchicalMenu({
+        attributes: [
+            'hierarchicalCategories.lvl0',
+            'hierarchicalCategories.lvl1',
+            'hierarchicalCategories.lvl2',
+        ],
+    });
+    const t = useFormattedMessage();
+    if (categories.length <= 0)
+        return null;
+    return (jsx(FilterSection, { title: t('facet.categories'), variant: "default", children: categories.map(category => (jsx(Fragment, { children: jsx("div", { className: filterSectionStyles['filter-section-item'], children: jsxs(Link, { hasUnderline: true, className: clsx(styles.category, {
+                        [styles['is-active']]: category.isRefined,
+                    }), onClick: () => refine(category.value), children: [jsx(StrokeCategoriesIcon, { height: 24, width: 24 }), jsx("span", { children: category.label }), jsxs("span", { className: styles.count, children: ["(", category.count, ")"] })] }) }) }, category.value))) }));
+}
+
+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,42 @@
+"use client";
+import { jsx, jsxs } 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 PanelCloseButton() {
+    const { close } = useSidebarActions();
+    return (jsx("div", { className: styles.button, children: jsxs(Button, { withArrow: true, onClick: close, size: "md", children: [jsx(FormattedMessage, { id: "Show" }), " ", jsx(AlgoliaResultsCount, {})] }) }));
+}
+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,
+    });
+    return (jsx("div", { className: styles['filter-panel'], children: jsxs("div", { className: styles['scroll-container'], 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, index) => {
+                        return (jsx(AlgoliaMultiSelectFilterSection, { attribute: attribute }, `attribute-${index}`));
+                    }) })), jsx(PanelCloseButton, {})] }) }));
+}
+
+export { AlgoliaFilterPanel };

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

@@ -0,0 +1,3 @@
+var styles = {"filter-panel":"algolia-filter-panel-module-GfhOO","scroll-container":"algolia-filter-panel-module-4ubB1","category":"algolia-filter-panel-module-LKet3","is-active":"algolia-filter-panel-module-yf8kI","value":"algolia-filter-panel-module-gQzED","count":"algolia-filter-panel-module-uAHPx","button":"algolia-filter-panel-module-ABOYv"};
+
+export { styles as default };

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.js

@@ -0,0 +1,175 @@
+"use client";
+const defaultLanguageCodes = {
+    PL: 'EN',
+};
+const getLanguageForAlgoliaIndex = (languageCode) => defaultLanguageCodes[languageCode] || languageCode;
+const algoliaIndexesPerEnvironment = {
+    local: {
+        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',
+    },
+    marketingLocal: {
+        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',
+    },
+    next: {
+        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',
+    },
+    sandbox: {
+        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',
+    },
+    'sandbox-reverse-proxy': {
+        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',
+    },
+    storybook: {
+        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',
+    },
+};
+const getAlgoliaIndex = (environment, languageCode) => {
+    const environmentIndex = algoliaIndexesPerEnvironment[environment];
+    const language = getLanguageForAlgoliaIndex(languageCode).toLowerCase();
+    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-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.js

@@ -0,0 +1,18 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { createContext, useContext } from 'react';
+import { useAlgoliaInsightsGlobalState } from './use-algolia-insights-provider-global-state.js';
+
+const AlgoliaInsightsProviderContext = createContext({});
+function AlgoliaInsightsProvider({ children, value, }) {
+    const [globalState] = useAlgoliaInsightsGlobalState();
+    const context = useContext(AlgoliaInsightsProviderContext);
+    const combinedValue = {
+        ...globalState,
+        ...context,
+        ...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-intialization.js

@@ -0,0 +1,26 @@
+"use client";
+import { config } from '../config.js';
+import Cookies from 'js-cookie';
+import aa from 'search-insights';
+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 console.error(err);
+    userToken = value === undefined ? generateUserToken() : String(value);
+});
+aa('onUserTokenChange', value => {
+    userToken = value === undefined ? generateUserToken() : String(value);
+});
+function generateUserToken() {
+    return `anonymous-${createUUID()}`;
+}
+
+export { userToken };

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/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), 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,106 @@
+"use client";
+import historyRouter from '../node_modules/.pnpm/instantsearch.js@4.75.4_algoliasearch@4.24.0/node_modules/instantsearch.js/es/lib/routers/history.js';
+import simpleStateMapping from '../node_modules/.pnpm/instantsearch.js@4.75.4_algoliasearch@4.24.0/node_modules/instantsearch.js/es/lib/stateMappings/simple.js';
+
+function createQueryStringRouting({ algoliaIndex, hierarchicalCategories, }) {
+    return {
+        router: historyRouter({
+            cleanUrlOnDispose: true,
+            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.keys(queryString.filters || {}).reduce((refinementList, filter) => {
+                    refinementList[filter] = [queryString.filters?.[filter]].flat();
+                    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 };