react-instantsearch-nextjs/dist/es/InitializePromise.js

React InstantSearch SSR utilities for Next.js

import { _ as _$1 } from '@swc/helpers/esm/_object_spread.js';
import { _ } from '@swc/helpers/esm/_object_spread_props.js';
import { getInitialResults } from 'instantsearch.js/es/lib/server.js';
import { resetWidgetId, walkIndex, isTwoPassWidget } from 'instantsearch.js/es/lib/utils/index.js';
import { ServerInsertedHTMLContext } from 'next/navigation.js';
import { useContext } from 'react';
import { useInstantSearchContext, useRSCContext, wrapPromiseWithState } from 'react-instantsearch-core';
import { createInsertHTML } from './createInsertHTML.js';

function isWithinIsolatedIndex(index) {
    var current = index;
    while(current){
        if (current._isolated) {
            return true;
        }
        current = current.getParent();
    }
    return false;
}
function InitializePromise(param) {
    var nonce = param.nonce;
    var search = useInstantSearchContext();
    var _useRSCContext = useRSCContext(), waitForResultsRef = _useRSCContext.waitForResultsRef, resolveWaitForResultsRef = _useRSCContext.resolveWaitForResultsRef;
    var insertHTML = useContext(ServerInsertedHTMLContext) || function() {
        throw new Error('Missing ServerInsertedHTMLContext');
    };
    // Extract search parameters from the search client to use them
    // later during hydration.
    var requestParamsList;
    if (search.compositionID) {
        search.mainHelper.setClient(_(_$1({}, search.mainHelper.getClient()), {
            search: function search1(query) {
                requestParamsList = [
                    query.requestBody.params
                ];
                return search.client.search(query);
            }
        }));
    } else {
        search.mainHelper.setClient(_(_$1({}, search.mainHelper.getClient()), {
            search: function search1(queries) {
                requestParamsList = queries.map(function(param) {
                    var params = param.params;
                    return params;
                });
                return search.client.search(queries);
            }
        }));
    }
    resetWidgetId();
    var waitForResults = function waitForResults() {
        return new Promise(function(resolve) {
            var searchReceived = false;
            var recommendReceived = false;
            var settled = false;
            var derivedHelper = search.mainHelper.derivedHelpers[0];
            var settle = function settle() {
                if (settled) {
                    return;
                }
                settled = true;
                if (resolveWaitForResultsRef) {
                    resolveWaitForResultsRef.current = null;
                }
                resolve();
            };
            var onResult = function onResult() {
                searchReceived = true;
                if (!search._hasRecommendWidget || recommendReceived) {
                    settle();
                }
            };
            var onRecommendResult = function onRecommendResult() {
                recommendReceived = true;
                if (!search._hasSearchWidget || searchReceived) {
                    settle();
                }
            };
            if (resolveWaitForResultsRef) {
                resolveWaitForResultsRef.current = function() {
                    derivedHelper.removeListener('result', onResult);
                    derivedHelper.removeListener('recommend:result', onRecommendResult);
                    settle();
                };
            }
            derivedHelper.once('result', onResult);
            derivedHelper.once('recommend:result', onRecommendResult);
        });
    };
    var injectInitialResults = function injectInitialResults() {
        var options = {
            inserted: false
        };
        var results = getInitialResults(search.mainIndex, search._hasSearchWidget ? requestParamsList || [] : []);
        insertHTML(createInsertHTML({
            options: options,
            results: results,
            nonce: nonce
        }));
    };
    if ((waitForResultsRef === null || waitForResultsRef === void 0 ? void 0 : waitForResultsRef.current) === null) {
        waitForResultsRef.current = wrapPromiseWithState(waitForResults().then(function() {
            var shouldRefetch = false;
            walkIndex(search.mainIndex, function(index) {
                if (isWithinIsolatedIndex(index)) {
                    return;
                }
                shouldRefetch = shouldRefetch || index.getWidgets().some(isTwoPassWidget);
            });
            if (shouldRefetch) {
                var _search__resetScheduleSearch;
                (_search__resetScheduleSearch = search._resetScheduleSearch) === null || _search__resetScheduleSearch === void 0 ? void 0 : _search__resetScheduleSearch.call(search);
                waitForResultsRef.current = wrapPromiseWithState(waitForResults().then(injectInitialResults));
            }
            return shouldRefetch;
        }).then(function(shouldRefetch) {
            if (shouldRefetch) {
                return;
            }
            injectInitialResults();
        }));
    }
    return null;
}

export { InitializePromise };